@covalent/code-editor 3.1.2 → 4.0.0-beta.2

package/{fesm2015/covalent-code-editor.js → fesm2020/covalent-code-editor.mjs}

@@ -1,33 +1,19 @@
-import { EventEmitter, Component, forwardRef, NgZone, ChangeDetectorRef, ElementRef, ViewChild, Output, Input, NgModule } from '@angular/core';
+import * as i0 from '@angular/core';
+import { EventEmitter, forwardRef, Component, ViewChild, Output, Input, NgModule } from '@angular/core';
 import { NG_VALUE_ACCESSOR } from '@angular/forms';
 import { Subject, merge, fromEvent, timer } from 'rxjs';
 import { debounceTime, distinctUntilChanged, takeUntil } from 'rxjs/operators';
-import { editor, languages } from 'monaco-editor/esm/vs/editor/editor.api';
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
 import { CommonModule } from '@angular/common';
 
-/**
- * @fileoverview added by tsickle
- * Generated from: code-editor.component.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/** @type {?} */
-const noop = (/**
- * @return {?}
- */
-() => {
+const _c0 = ["editorContainer"];
+const noop = () => {
     // empty method
-});
-const ɵ0 = noop;
+};
 // counter for ids to allow for multiple editors on one page
-/** @type {?} */
 let uniqueCounter = 0;
 class TdCodeEditorComponent {
     // tslint:disable-next-line:member-ordering
-    /**
-     * @param {?} zone
-     * @param {?} _changeDetectorRef
-     * @param {?} _elementRef
-     */
     constructor(zone, _changeDetectorRef, _elementRef) {
         this.zone = zone;
         this._changeDetectorRef = _changeDetectorRef;
@@ -72,20 +58,11 @@ class TdCodeEditorComponent {
          */
         this.change = new EventEmitter();
         /* tslint:disable-next-line */
-        this.propagateChange = (/**
-         * @param {?} _
-         * @return {?}
-         */
-        (_) => { });
-        this.onTouched = (/**
-         * @return {?}
-         */
-        () => noop);
+        this.propagateChange = (_) => { };
+        this.onTouched = () => noop;
     }
     /**
      * value?: string
-     * @param {?} value
-     * @return {?}
      */
     set value(value) {
         if (value === this._value) {
@@ -96,15 +73,9 @@ class TdCodeEditorComponent {
             this.applyValue();
         }
     }
-    /**
-     * @return {?}
-     */
     get value() {
         return this._value;
     }
-    /**
-     * @return {?}
-     */
     applyValue() {
         if (!this._fromEditor) {
             this._editor.setValue(this._value);
@@ -116,8 +87,6 @@ class TdCodeEditorComponent {
     }
     /**
      * Implemented as part of ControlValueAccessor.
-     * @param {?} value
-     * @return {?}
      */
     writeValue(value) {
         // do not write if null or undefined
@@ -126,43 +95,29 @@ class TdCodeEditorComponent {
             this.value = value;
         }
     }
-    /**
-     * @param {?} fn
-     * @return {?}
-     */
     registerOnChange(fn) {
         this.propagateChange = fn;
     }
-    /**
-     * @param {?} fn
-     * @return {?}
-     */
     registerOnTouched(fn) {
         this.onTouched = fn;
     }
     /**
      * getEditorContent?: function
      * Returns the content within the editor
-     * @return {?}
      */
     getValue() {
         if (this._componentInitialized) {
-            setTimeout((/**
-             * @return {?}
-             */
-            () => {
+            setTimeout(() => {
                 this._subject.next(this._value);
                 this._subject.complete();
                 this._subject = new Subject();
-            }));
+            });
             return this._subject.asObservable();
         }
     }
     /**
      * language?: string
      * language used in editor
-     * @param {?} language
-     * @return {?}
      */
     set language(language) {
         this._language = language;
@@ -170,26 +125,18 @@ class TdCodeEditorComponent {
             this.applyLanguage();
         }
     }
-    /**
-     * @return {?}
-     */
     get language() {
         return this._language;
     }
-    /**
-     * @return {?}
-     */
     applyLanguage() {
         if (this._language) {
-            editor.setModelLanguage(this._editor.getModel(), this._language);
+            monaco.editor.setModelLanguage(this._editor.getModel(), this._language);
             this.editorLanguageChanged.emit();
         }
     }
     /**
      * registerLanguage?: function
      * Registers a custom Language within the editor
-     * @param {?} language
-     * @return {?}
      */
     registerLanguage(language) {
         if (this._componentInitialized) {
@@ -201,24 +148,20 @@ class TdCodeEditorComponent {
                 /* tslint:disable-next-line */
                 monarchTokens[0] = eval(monarchTokens[0]);
             }
-            languages.register({ id: language.id });
-            languages.setMonarchTokensProvider(language.id, {
+            monaco.languages.register({ id: language.id });
+            monaco.languages.setMonarchTokensProvider(language.id, {
                 tokenizer: {
                     root: language.monarchTokensProvider,
                 },
             });
             // Define a new theme that constains only rules that match this language
-            editor.defineTheme(language.customTheme.id, language.customTheme.theme);
+            monaco.editor.defineTheme(language.customTheme.id, language.customTheme.theme);
             this._theme = language.customTheme.id;
-            languages.registerCompletionItemProvider(language.id, {
-                provideCompletionItems: (/**
-                 * @return {?}
-                 */
-                () => {
+            monaco.languages.registerCompletionItemProvider(language.id, {
+                provideCompletionItems: () => {
                     return language.completionItemProvider;
-                }),
+                },
             });
-            /** @type {?} */
             const css = document.createElement('style');
             css.type = 'text/css';
             css.innerHTML = language.monarchTokensProviderCSS;
@@ -230,8 +173,6 @@ class TdCodeEditorComponent {
     /**
      * style?: string
      * css style of the editor on the page
-     * @param {?} editorStyle
-     * @return {?}
      */
     set editorStyle(editorStyle) {
         this._editorStyle = editorStyle;
@@ -239,18 +180,11 @@ class TdCodeEditorComponent {
             this.applyStyle();
         }
     }
-    /**
-     * @return {?}
-     */
     get editorStyle() {
         return this._editorStyle;
     }
-    /**
-     * @return {?}
-     */
     applyStyle() {
         if (this._editorStyle) {
-            /** @type {?} */
             const containerDiv = this._editorContainer.nativeElement;
             containerDiv.setAttribute('style', this._editorStyle);
         }
@@ -258,8 +192,6 @@ class TdCodeEditorComponent {
     /**
      * theme?: string
      * Theme to be applied to editor
-     * @param {?} theme
-     * @return {?}
      */
     set theme(theme) {
         this._theme = theme;
@@ -268,9 +200,6 @@ class TdCodeEditorComponent {
             this.editorConfigurationChanged.emit();
         }
     }
-    /**
-     * @return {?}
-     */
     get theme() {
         return this._theme;
     }
@@ -278,15 +207,10 @@ class TdCodeEditorComponent {
      * fullScreenKeyBinding?: number
      * See here for key bindings https://microsoft.github.io/monaco-editor/api/enums/monaco.keycode.html
      * Sets the KeyCode for shortcutting to Fullscreen mode
-     * @param {?} keycode
-     * @return {?}
      */
     set fullScreenKeyBinding(keycode) {
         this._keycode = keycode;
     }
-    /**
-     * @return {?}
-     */
     get fullScreenKeyBinding() {
         return this._keycode;
     }
@@ -294,8 +218,6 @@ class TdCodeEditorComponent {
      * editorOptions?: object
      * Options used on editor instantiation. Available options listed here:
      * https://microsoft.github.io/monaco-editor/api/interfaces/monaco.editor.ieditoroptions.html
-     * @param {?} editorOptions
-     * @return {?}
      */
     set editorOptions(editorOptions) {
         this._editorOptions = editorOptions;
@@ -304,15 +226,11 @@ class TdCodeEditorComponent {
             this.editorConfigurationChanged.emit();
         }
     }
-    /**
-     * @return {?}
-     */
     get editorOptions() {
         return this._editorOptions;
     }
     /**
      * layout method that calls layout method of editor and instructs the editor to remeasure its container
-     * @return {?}
      */
     layout() {
         if (this._componentInitialized) {
@@ -321,112 +239,80 @@ class TdCodeEditorComponent {
     }
     /**
      * Returns if in Full Screen Mode or not
-     * @return {?}
      */
     get isFullScreen() {
         return this._isFullScreen;
     }
-    /**
-     * @return {?}
-     */
     ngOnInit() {
-        /** @type {?} */
         const containerDiv = this._editorContainer.nativeElement;
         containerDiv.id = this._editorInnerContainer;
-        this._editor = editor.create(containerDiv, Object.assign({
+        this._editor = monaco.editor.create(containerDiv, Object.assign({
             value: this._value,
             language: this.language,
             theme: this._theme,
         }, this.editorOptions));
         this._componentInitialized = true;
-        setTimeout((/**
-         * @return {?}
-         */
-        () => {
+        setTimeout(() => {
             this.applyLanguage();
             this._fromEditor = true;
             this.applyValue();
             this.applyStyle();
             this.editorInitialized.emit(this._editor);
             this.editorConfigurationChanged.emit();
-        }));
-        this._editor.getModel().onDidChangeContent((/**
-         * @param {?} e
-         * @return {?}
-         */
-        (e) => {
+        });
+        // The `onDidChangeContent` returns a disposable object (an object with `dispose()` method) which will cleanup
+        // the listener. The callback, that we pass to `onDidChangeContent`, captures `this`. This leads to a circular reference
+        // (`td-code-editor -> monaco -> td-code-editor`) and prevents the `td-code-editor` from being GC'd.
+        this._onDidChangeContentDisposable = this._editor.getModel().onDidChangeContent((e) => {
             this._fromEditor = true;
             this.writeValue(this._editor.getValue());
             this.layout();
-        }));
+        });
         this.addFullScreenModeCommand();
         merge(fromEvent(window, 'resize').pipe(debounceTime(100)), this._widthSubject.asObservable().pipe(distinctUntilChanged()), this._heightSubject.asObservable().pipe(distinctUntilChanged()))
             .pipe(takeUntil(this._destroy), debounceTime(100))
-            .subscribe((/**
-         * @return {?}
-         */
-        () => {
+            .subscribe(() => {
             this.layout();
             this._changeDetectorRef.markForCheck();
-        }));
+        });
         timer(500, 250)
             .pipe(takeUntil(this._destroy))
-            .subscribe((/**
-         * @return {?}
-         */
-        () => {
+            .subscribe(() => {
             if (this._elementRef && this._elementRef.nativeElement) {
-                this._widthSubject.next(((/** @type {?} */ (this._elementRef.nativeElement))).getBoundingClientRect().width);
-                this._heightSubject.next(((/** @type {?} */ (this._elementRef.nativeElement))).getBoundingClientRect().height);
+                this._widthSubject.next(this._elementRef.nativeElement.getBoundingClientRect().width);
+                this._heightSubject.next(this._elementRef.nativeElement.getBoundingClientRect().height);
             }
-        }));
+        });
     }
-    /**
-     * @return {?}
-     */
     ngOnDestroy() {
         this._changeDetectorRef.detach();
-        this._registeredLanguagesStyles.forEach((/**
-         * @param {?} style
-         * @return {?}
-         */
-        (style) => style.remove()));
+        this._registeredLanguagesStyles.forEach((style) => style.remove());
+        if (this._onDidChangeContentDisposable) {
+            this._onDidChangeContentDisposable.dispose();
+            this._onDidChangeContentDisposable = undefined;
+        }
         if (this._editor) {
             this._editor.dispose();
+            this._editor = undefined;
         }
         this._destroy.next(true);
         this._destroy.unsubscribe();
     }
     /**
      * showFullScreenEditor request for full screen of Code Editor based on its browser type.
-     * @return {?}
      */
     showFullScreenEditor() {
         if (this._componentInitialized) {
-            /** @type {?} */
-            const codeEditorElement = (/** @type {?} */ (this._editorContainer.nativeElement));
-            /** @type {?} */
+            const codeEditorElement = this._editorContainer.nativeElement;
             const fullScreenMap = {
                 // Chrome
-                requestFullscreen: (/**
-                 * @return {?}
-                 */
-                () => codeEditorElement.requestFullscreen()),
+                requestFullscreen: () => codeEditorElement.requestFullscreen(),
                 // Safari
-                webkitRequestFullscreen: (/**
-                 * @return {?}
-                 */
-                () => ((/** @type {?} */ (codeEditorElement))).webkitRequestFullscreen()),
+                webkitRequestFullscreen: () => codeEditorElement.webkitRequestFullscreen(),
                 // IE
-                msRequestFullscreen: (/**
-                 * @return {?}
-                 */
-                () => ((/** @type {?} */ (codeEditorElement))).msRequestFullscreen()),
+                msRequestFullscreen: () => codeEditorElement.msRequestFullscreen(),
                 // Firefox
-                mozRequestFullScreen: (/**
-                 * @return {?}
-                 */
-                () => ((/** @type {?} */ (codeEditorElement))).mozRequestFullScreen()),
+                mozRequestFullScreen: () => codeEditorElement.mozRequestFullScreen(),
             };
             for (const handler of Object.keys(fullScreenMap)) {
                 if (codeEditorElement[handler]) {
@@ -438,32 +324,18 @@ class TdCodeEditorComponent {
     }
     /**
      * exitFullScreenEditor request to exit full screen of Code Editor based on its browser type.
-     * @return {?}
      */
     exitFullScreenEditor() {
         if (this._componentInitialized) {
-            /** @type {?} */
             const exitFullScreenMap = {
                 // Chrome
-                exitFullscreen: (/**
-                 * @return {?}
-                 */
-                () => document.exitFullscreen()),
+                exitFullscreen: () => document.exitFullscreen(),
                 // Safari
-                webkitExitFullscreen: (/**
-                 * @return {?}
-                 */
-                () => ((/** @type {?} */ (document))).webkitExitFullscreen()),
+                webkitExitFullscreen: () => document.webkitExitFullscreen(),
                 // Firefox
-                mozCancelFullScreen: (/**
-                 * @return {?}
-                 */
-                () => ((/** @type {?} */ (document))).mozCancelFullScreen()),
+                mozCancelFullScreen: () => document.mozCancelFullScreen(),
                 // IE
-                msExitFullscreen: (/**
-                 * @return {?}
-                 */
-                () => ((/** @type {?} */ (document))).msExitFullscreen()),
+                msExitFullscreen: () => document.msExitFullscreen(),
             };
             for (const handler of Object.keys(exitFullScreenMap)) {
                 if (document[handler]) {
@@ -475,8 +347,6 @@ class TdCodeEditorComponent {
     }
     /**
      * addFullScreenModeCommand used to add the fullscreen option to the context menu
-     * @private
-     * @return {?}
      */
     addFullScreenModeCommand() {
         this._editor.addAction({
@@ -490,220 +360,88 @@ class TdCodeEditorComponent {
             contextMenuOrder: 1.5,
             // Method that will be executed when the action is triggered.
             // @param editor The editor instance is passed in as a convinience
-            run: (/**
-             * @param {?} ed
-             * @return {?}
-             */
-            (ed) => {
+            run: (ed) => {
                 this.showFullScreenEditor();
-            }),
+            },
         });
     }
 }
-TdCodeEditorComponent.decorators = [
-    { type: Component, args: [{
-                selector: 'td-code-editor',
-                template: "<div class=\"editorContainer\" #editorContainer></div>\n",
-                providers: [
+/** @nocollapse */ /** @nocollapse */ TdCodeEditorComponent.ɵfac = function TdCodeEditorComponent_Factory(t) { return new (t || TdCodeEditorComponent)(i0.ɵɵdirectiveInject(i0.NgZone), i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef)); };
+/** @nocollapse */ /** @nocollapse */ TdCodeEditorComponent.ɵcmp = /** @pureOrBreakMyCode */ i0.ɵɵdefineComponent({ type: TdCodeEditorComponent, selectors: [["td-code-editor"]], viewQuery: function TdCodeEditorComponent_Query(rf, ctx) { if (rf & 1) {
+        i0.ɵɵviewQuery(_c0, 7);
+    } if (rf & 2) {
+        let _t;
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx._editorContainer = _t.first);
+    } }, inputs: { value: "value", language: "language", editorStyle: "editorStyle", theme: "theme", fullScreenKeyBinding: "fullScreenKeyBinding", editorOptions: "editorOptions" }, outputs: { editorInitialized: "editorInitialized", editorConfigurationChanged: "editorConfigurationChanged", editorLanguageChanged: "editorLanguageChanged", editorValueChange: "editorValueChange", change: "change" }, features: [i0.ɵɵProvidersFeature([
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef((() => TdCodeEditorComponent)),
+                multi: true,
+            },
+        ])], decls: 2, vars: 0, consts: [[1, "editor-container"], ["editorContainer", ""]], template: function TdCodeEditorComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵelement(0, "div", 0, 1);
+    } }, styles: ["[_nghost-%COMP%]{display:block;position:relative}[_nghost-%COMP%]   .editor-container[_ngcontent-%COMP%]{position:absolute;top:0;bottom:0;left:0;right:0}  .monaco-aria-container{display:none}"] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TdCodeEditorComponent, [{
+        type: Component,
+        args: [{ selector: 'td-code-editor', providers: [
                     {
                         provide: NG_VALUE_ACCESSOR,
-                        useExisting: forwardRef((/**
-                         * @return {?}
-                         */
-                        () => TdCodeEditorComponent)),
+                        useExisting: forwardRef((() => TdCodeEditorComponent)),
                         multi: true,
                     },
-                ],
-                styles: [":host{display:block;position:relative}:host .editorContainer{bottom:0;left:0;position:absolute;right:0;top:0}::ng-deep .monaco-aria-container{display:none}"]
-            }] }
-];
-/** @nocollapse */
-TdCodeEditorComponent.ctorParameters = () => [
-    { type: NgZone },
-    { type: ChangeDetectorRef },
-    { type: ElementRef }
-];
-TdCodeEditorComponent.propDecorators = {
-    _editorContainer: [{ type: ViewChild, args: ['editorContainer', { static: true },] }],
-    editorInitialized: [{ type: Output }],
-    editorConfigurationChanged: [{ type: Output }],
-    editorLanguageChanged: [{ type: Output }],
-    editorValueChange: [{ type: Output }],
-    change: [{ type: Output }],
-    value: [{ type: Input, args: ['value',] }],
-    language: [{ type: Input, args: ['language',] }],
-    editorStyle: [{ type: Input, args: ['editorStyle',] }],
-    theme: [{ type: Input, args: ['theme',] }],
-    fullScreenKeyBinding: [{ type: Input, args: ['fullScreenKeyBinding',] }],
-    editorOptions: [{ type: Input, args: ['editorOptions',] }]
-};
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    TdCodeEditorComponent.prototype._destroy;
-    /**
-     * @type {?}
-     * @private
-     */
-    TdCodeEditorComponent.prototype._widthSubject;
-    /**
-     * @type {?}
-     * @private
-     */
-    TdCodeEditorComponent.prototype._heightSubject;
-    /**
-     * @type {?}
-     * @private
-     */
-    TdCodeEditorComponent.prototype._editorStyle;
-    /**
-     * @type {?}
-     * @private
-     */
-    TdCodeEditorComponent.prototype._value;
-    /**
-     * @type {?}
-     * @private
-     */
-    TdCodeEditorComponent.prototype._theme;
-    /**
-     * @type {?}
-     * @private
-     */
-    TdCodeEditorComponent.prototype._language;
-    /**
-     * @type {?}
-     * @private
-     */
-    TdCodeEditorComponent.prototype._subject;
-    /**
-     * @type {?}
-     * @private
-     */
-    TdCodeEditorComponent.prototype._editorInnerContainer;
-    /**
-     * @type {?}
-     * @private
-     */
-    TdCodeEditorComponent.prototype._editor;
-    /**
-     * @type {?}
-     * @private
-     */
-    TdCodeEditorComponent.prototype._fromEditor;
-    /**
-     * @type {?}
-     * @private
-     */
-    TdCodeEditorComponent.prototype._componentInitialized;
-    /**
-     * @type {?}
-     * @private
-     */
-    TdCodeEditorComponent.prototype._editorOptions;
-    /**
-     * @type {?}
-     * @private
-     */
-    TdCodeEditorComponent.prototype._isFullScreen;
-    /**
-     * @type {?}
-     * @private
-     */
-    TdCodeEditorComponent.prototype._keycode;
-    /**
-     * @type {?}
-     * @private
-     */
-    TdCodeEditorComponent.prototype._registeredLanguagesStyles;
-    /** @type {?} */
-    TdCodeEditorComponent.prototype._editorContainer;
-    /**
-     * editorInitialized: function($event)
-     * Event emitted when editor is first initialized
-     * @type {?}
-     */
-    TdCodeEditorComponent.prototype.editorInitialized;
-    /**
-     * editorConfigurationChanged: function($event)
-     * Event emitted when editor's configuration changes
-     * @type {?}
-     */
-    TdCodeEditorComponent.prototype.editorConfigurationChanged;
-    /**
-     * editorLanguageChanged: function($event)
-     * Event emitted when editor's Language changes
-     * @type {?}
-     */
-    TdCodeEditorComponent.prototype.editorLanguageChanged;
-    /**
-     * editorValueChange: function($event)
-     * Event emitted any time something changes the editor value
-     * @type {?}
-     */
-    TdCodeEditorComponent.prototype.editorValueChange;
-    /**
-     * The change event notifies you about a change happening in an input field.
-     * Since the component is not a native Angular component have to specifiy the event emitter ourself
-     * @type {?}
-     */
-    TdCodeEditorComponent.prototype.change;
-    /** @type {?} */
-    TdCodeEditorComponent.prototype.propagateChange;
-    /** @type {?} */
-    TdCodeEditorComponent.prototype.onTouched;
-    /**
-     * @type {?}
-     * @private
-     */
-    TdCodeEditorComponent.prototype.zone;
-    /**
-     * @type {?}
-     * @private
-     */
-    TdCodeEditorComponent.prototype._changeDetectorRef;
-    /**
-     * @type {?}
-     * @private
-     */
-    TdCodeEditorComponent.prototype._elementRef;
-}
+                ], template: "<div class=\"editor-container\" #editorContainer></div>\n", styles: [":host{display:block;position:relative}:host .editor-container{position:absolute;top:0;bottom:0;left:0;right:0}::ng-deep .monaco-aria-container{display:none}\n"] }]
+    }], function () { return [{ type: i0.NgZone }, { type: i0.ChangeDetectorRef }, { type: i0.ElementRef }]; }, { _editorContainer: [{
+            type: ViewChild,
+            args: ['editorContainer', { static: true }]
+        }], editorInitialized: [{
+            type: Output
+        }], editorConfigurationChanged: [{
+            type: Output
+        }], editorLanguageChanged: [{
+            type: Output
+        }], editorValueChange: [{
+            type: Output
+        }], change: [{
+            type: Output
+        }], value: [{
+            type: Input,
+            args: ['value']
+        }], language: [{
+            type: Input,
+            args: ['language']
+        }], editorStyle: [{
+            type: Input,
+            args: ['editorStyle']
+        }], theme: [{
+            type: Input,
+            args: ['theme']
+        }], fullScreenKeyBinding: [{
+            type: Input,
+            args: ['fullScreenKeyBinding']
+        }], editorOptions: [{
+            type: Input,
+            args: ['editorOptions']
+        }] }); })();
 
-/**
- * @fileoverview added by tsickle
- * Generated from: code-editor.module.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 class CovalentCodeEditorModule {
 }
-CovalentCodeEditorModule.decorators = [
-    { type: NgModule, args: [{
+/** @nocollapse */ /** @nocollapse */ CovalentCodeEditorModule.ɵfac = function CovalentCodeEditorModule_Factory(t) { return new (t || CovalentCodeEditorModule)(); };
+/** @nocollapse */ /** @nocollapse */ CovalentCodeEditorModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: CovalentCodeEditorModule, bootstrap: [TdCodeEditorComponent] });
+/** @nocollapse */ /** @nocollapse */ CovalentCodeEditorModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ imports: [[CommonModule]] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CovalentCodeEditorModule, [{
+        type: NgModule,
+        args: [{
                 imports: [CommonModule],
                 declarations: [TdCodeEditorComponent],
                 exports: [TdCodeEditorComponent],
                 bootstrap: [TdCodeEditorComponent],
-            },] }
-];
-
-/**
- * @fileoverview added by tsickle
- * Generated from: public-api.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-
-/**
- * @fileoverview added by tsickle
- * Generated from: index.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(CovalentCodeEditorModule, { declarations: [TdCodeEditorComponent], imports: [CommonModule], exports: [TdCodeEditorComponent] }); })();
 
 /**
- * @fileoverview added by tsickle
- * Generated from: covalent-code-editor.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * Generated bundle index. Do not edit.
  */
 
 export { CovalentCodeEditorModule, TdCodeEditorComponent };
-//# sourceMappingURL=covalent-code-editor.js.map
+//# sourceMappingURL=covalent-code-editor.mjs.map