@dotglitch/ngx-common 2.0.0 → 3.0.0-beta.2

package/esm2022/monaco-editor/monaco-editor.component.mjs

@@ -0,0 +1,234 @@
+import { Component, EventEmitter, HostListener, Input, Output } from '@angular/core';
+import { debounceTime } from 'rxjs';
+import { MonacoAutoTypeImporter } from './ts-type-resolver/main';
+import * as i0 from "@angular/core";
+let Monaco;
+export class MonacoEditorComponent {
+    set code(value) {
+        if (value == this._code)
+            return;
+        if (typeof value != "string")
+            throw new TypeError("Value must be of type string");
+        this._code = value;
+        this.editor?.setValue(this.code);
+    }
+    ;
+    get code() { return this._code?.trim(); }
+    set language(value) {
+        this._language = {
+            'ts': "typescript",
+            'html': 'xml',
+            'scss': 'css'
+        }[value] || value || "auto";
+    }
+    get language() { return this._language; }
+    get settings() {
+        return {
+            ...this.restSettings,
+            theme: this.theme,
+            language: this.language,
+            tabSize: this.tabSize,
+            readOnly: this.readOnly,
+            fontFamily: this.fontFamily,
+            fontSize: this.fontSize,
+            automaticLayout: this.automaticLayout,
+            scrollBeyondLastLine: this.scrollBeyondLastLine,
+            colorDecorators: this.colorDecorators,
+            folding: this.folding,
+            scrollBeyondLastColumn: this.scrollBeyondLastColumn,
+            minimap: this.minimap,
+            scrollbar: this.scrollbar,
+            smoothScrolling: this.smoothScrolling,
+            mouseWheelScrollSensitivity: this.mouseWheelScrollSensitivity,
+            lineNumbers: this.lineNumbers
+        };
+    }
+    constructor(viewContainer) {
+        this.viewContainer = viewContainer;
+        this.isDirty = false;
+        this.codeChange = new EventEmitter();
+        this.onCodeType = new EventEmitter();
+        this.typeDebounce = this.onCodeType.pipe(debounceTime(100));
+        this.installationLocation = "/lib/monaco/vs";
+        this.tabSize = 2;
+        this.readOnly = false;
+        this.theme = "vs-dark";
+        this.fontFamily = "Droid Sans Mono";
+        this.fontSize = 14;
+        this.automaticLayout = true;
+        this.colorDecorators = true;
+        this.folding = true;
+        this.minimapEnabled = true;
+        this.minimap = {
+            enabled: true
+        };
+        this.scrollbar = {
+            alwaysConsumeMouseWheel: false,
+            // scrollByPage: true
+        };
+        this.smoothScrolling = true;
+        this.mouseWheelScrollSensitivity = 2;
+        this.scrollBeyondLastLine = false;
+        this.scrollBeyondLastColumn = 0;
+        this.lineNumbers = "on";
+        this.restSettings = {};
+        this.resize = () => {
+            this.editor?.layout();
+        };
+        this._sub = this.typeDebounce.subscribe(t => {
+            this.codeChange.next(this._code = this.editor.getValue());
+        });
+    }
+    ngOnInit() {
+        InstallMonacoUMD(this.installationLocation);
+    }
+    ngOnChanges(changes) {
+        // If we changed anything OTHER than code, reload the editor
+        if (Object.keys(changes).length > 1 || !changes['code']) {
+            if (this.editor) {
+                this.editor?.dispose();
+                this.createEditor();
+            }
+        }
+        if (changes['theme'])
+            window['monaco']?.editor.setTheme(this.theme);
+    }
+    async ngAfterViewInit() {
+        await InstallMonacoUMD();
+        this.createEditor();
+    }
+    ngOnDestroy() {
+        this.editor?.dispose();
+        this._sub?.unsubscribe();
+    }
+    createEditor() {
+        if (this.customLanguage) {
+            this.customLanguage.init(window['monaco']);
+        }
+        let editor = this.editor = window['monaco'].editor.create(this.viewContainer?.element?.nativeElement, this.settings);
+        // const autoTypings = await
+        MonacoAutoTypeImporter.create(editor, {
+            monaco: Monaco,
+        });
+        this.configureLanguageSupport();
+        if (this.code) {
+            editor.setValue(this.code);
+        }
+        editor.getModel().onDidChangeContent(() => this.onCodeType.emit());
+    }
+    configureLanguageSupport() {
+    }
+    download() {
+        const code = this.editor.getValue();
+        let blob = new Blob([code], { type: 'text/log' });
+        let elm = document.createElement('a');
+        let blobURL = URL.createObjectURL(blob);
+        // Set the data values.
+        elm.href = blobURL;
+        elm.download = this.filename;
+        document.body.appendChild(elm);
+        elm.click();
+        document.body.removeChild(elm);
+        elm.remove();
+        URL.revokeObjectURL(blobURL);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MonacoEditorComponent, deps: [{ token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MonacoEditorComponent, isStandalone: true, selector: "ngx-monaco-editor", inputs: { code: "code", customLanguage: "customLanguage", language: "language", installationLocation: "installationLocation", tabSize: "tabSize", readOnly: "readOnly", theme: "theme", fontFamily: "fontFamily", fontSize: "fontSize", automaticLayout: "automaticLayout", colorDecorators: "colorDecorators", folding: "folding", minimapEnabled: "minimapEnabled", minimap: "minimap", scrollbar: "scrollbar", smoothScrolling: "smoothScrolling", mouseWheelScrollSensitivity: "mouseWheelScrollSensitivity", scrollBeyondLastLine: "scrollBeyondLastLine", scrollBeyondLastColumn: "scrollBeyondLastColumn", lineNumbers: "lineNumbers", restSettings: "restSettings" }, outputs: { codeChange: "codeChange" }, host: { listeners: { "window:resize": "resize($event)" } }, usesOnChanges: true, ngImport: i0, template: '', isInline: true, styles: [":host{display:block;height:100%;max-height:100vh;max-width:100vw}\n"] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MonacoEditorComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ngx-monaco-editor', template: '', standalone: true, styles: [":host{display:block;height:100%;max-height:100vh;max-width:100vw}\n"] }]
+        }], ctorParameters: () => [{ type: i0.ViewContainerRef }], propDecorators: { code: [{
+                type: Input
+            }], codeChange: [{
+                type: Output
+            }], customLanguage: [{
+                type: Input
+            }], language: [{
+                type: Input
+            }], installationLocation: [{
+                type: Input
+            }], tabSize: [{
+                type: Input
+            }], readOnly: [{
+                type: Input
+            }], theme: [{
+                type: Input
+            }], fontFamily: [{
+                type: Input
+            }], fontSize: [{
+                type: Input
+            }], automaticLayout: [{
+                type: Input
+            }], colorDecorators: [{
+                type: Input
+            }], folding: [{
+                type: Input
+            }], minimapEnabled: [{
+                type: Input
+            }], minimap: [{
+                type: Input
+            }], scrollbar: [{
+                type: Input
+            }], smoothScrolling: [{
+                type: Input
+            }], mouseWheelScrollSensitivity: [{
+                type: Input
+            }], scrollBeyondLastLine: [{
+                type: Input
+            }], scrollBeyondLastColumn: [{
+                type: Input
+            }], lineNumbers: [{
+                type: Input
+            }], restSettings: [{
+                type: Input
+            }], resize: [{
+                type: HostListener,
+                args: ['window:resize', ['$event']]
+            }] } });
+export const InstallMonacoUMD = async (path) => {
+    if (window['monaco'])
+        return window['monaco'];
+    // Prevent duplicate injection
+    const scriptEls = document.querySelectorAll('body>script[monaco][defer][src]');
+    // Only perform installation if a path is specified.
+    if (path && scriptEls.length == 0) {
+        // Monaco has a UMD loader that requires this
+        // Merge with any pre-existing global require objects.
+        if (!window['require'])
+            window['require'] = {};
+        if (!window['require']['paths'])
+            window['require']['paths'] = {};
+        if (path.endsWith('/'))
+            path = path.slice(0, -1);
+        window['require']['paths'].vs = path;
+        const monacoFiles = [
+            'loader.js',
+            'editor/editor.main.nls.js',
+            'editor/editor.main.js',
+        ];
+        for (let i = 0; i < monacoFiles.length; i++) {
+            const script = document.createElement("script");
+            script.setAttribute("monaco", "");
+            script.setAttribute("defer", "");
+            script.setAttribute("src", path + '/' + monacoFiles[i]);
+            document.body.append(script);
+        }
+    }
+    // Return a promise that will resolve when monaco finishes loading
+    return await new Promise((res, rej) => {
+        let count = 0;
+        let i = window.setInterval(() => {
+            count++;
+            if (window['monaco'] != undefined) {
+                window.clearInterval(i);
+                res(true);
+            }
+            else if (count >= 100) {
+                window.clearInterval(i);
+                res(false);
+            }
+        }, 100);
+    });
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"monaco-editor.component.js","sourceRoot":"","sources":["../../../packages/common/monaco-editor/monaco-editor.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, Component, EventEmitter, HostListener, Input, OnDestroy, Output, SimpleChanges, ViewContainerRef } from '@angular/core';\r\n\r\nimport * as MonacoEditor from 'monaco-editor';\r\nimport { debounceTime } from 'rxjs';\r\nimport { MonacoAutoTypeImporter } from './ts-type-resolver/main';\r\n\r\nlet Monaco: typeof MonacoEditor;\r\n\r\n@Component({\r\n    selector: 'ngx-monaco-editor',\r\n    template: '',\r\n    styles: [`\r\n:host {\r\n    display: block;\r\n    height: 100%;\r\n    max-height: 100vh;\r\n    max-width: 100vw;\r\n}\r\n    `],\r\n    standalone: true\r\n})\r\nexport class MonacoEditorComponent implements AfterViewInit, OnDestroy {\r\n    isDirty = false;\r\n    editor: MonacoEditor.editor.IStandaloneCodeEditor;\r\n    filename: string;\r\n\r\n    private _code: string;\r\n    @Input() set code(value: string) {\r\n        if (value == this._code)\r\n            return;\r\n        if (typeof value != \"string\")\r\n            throw new TypeError(\"Value must be of type string\");\r\n\r\n        this._code = value;\r\n        this.editor?.setValue(this.code);\r\n    };\r\n    get code() { return this._code?.trim(); }\r\n    @Output() codeChange = new EventEmitter<string>();\r\n    private onCodeType = new EventEmitter<string>();\r\n    private typeDebounce = this.onCodeType.pipe(debounceTime(100));\r\n\r\n    @Input() customLanguage: { init: Function; };\r\n\r\n\r\n    private _language: string;\r\n    @Input() set language(value: string) {\r\n        this._language = {\r\n            'ts': \"typescript\",\r\n            'html': 'xml',\r\n            'scss': 'css'\r\n        }[value] || value || \"auto\";\r\n    }\r\n    get language() { return this._language; }\r\n\r\n    @Input() installationLocation = \"/lib/monaco/vs\";\r\n\r\n\r\n    @Input() tabSize = 2;\r\n    @Input() readOnly = false;\r\n    @Input() theme = \"vs-dark\";\r\n    @Input() fontFamily = \"Droid Sans Mono\";\r\n    @Input() fontSize = 14;\r\n\r\n    @Input() automaticLayout = true;\r\n    @Input() colorDecorators = true;\r\n    @Input() folding = true;\r\n\r\n    @Input() minimapEnabled = true;\r\n    @Input() minimap: MonacoEditor.editor.IEditorMinimapOptions = {\r\n        enabled: true\r\n    };\r\n    @Input() scrollbar: MonacoEditor.editor.IEditorScrollbarOptions = {\r\n        alwaysConsumeMouseWheel: false,\r\n        // scrollByPage: true\r\n    };\r\n    @Input() smoothScrolling = true;\r\n    @Input() mouseWheelScrollSensitivity = 2;\r\n    @Input() scrollBeyondLastLine = false;\r\n    @Input() scrollBeyondLastColumn = 0;\r\n\r\n    @Input() lineNumbers: MonacoEditor.editor.LineNumbersType = \"on\";\r\n\r\n    @Input() restSettings: MonacoEditor.editor.IStandaloneEditorConstructionOptions = {};\r\n\r\n    get settings() {\r\n        return {\r\n            ...this.restSettings,\r\n            theme: this.theme,\r\n            language: this.language,\r\n            tabSize: this.tabSize,\r\n            readOnly: this.readOnly,\r\n            fontFamily: this.fontFamily,\r\n            fontSize: this.fontSize,\r\n            automaticLayout: this.automaticLayout,\r\n            scrollBeyondLastLine: this.scrollBeyondLastLine,\r\n            colorDecorators: this.colorDecorators,\r\n            folding: this.folding,\r\n            scrollBeyondLastColumn: this.scrollBeyondLastColumn,\r\n            minimap: this.minimap,\r\n            scrollbar: this.scrollbar,\r\n            smoothScrolling: this.smoothScrolling,\r\n            mouseWheelScrollSensitivity: this.mouseWheelScrollSensitivity,\r\n            lineNumbers: this.lineNumbers\r\n        } as MonacoEditor.editor.IStandaloneEditorConstructionOptions;\r\n    }\r\n\r\n    private _sub;\r\n    constructor(private viewContainer: ViewContainerRef) {\r\n\r\n        this._sub = this.typeDebounce.subscribe(t => {\r\n            this.codeChange.next(this._code = this.editor.getValue());\r\n        });\r\n    }\r\n\r\n    ngOnInit() {\r\n        InstallMonacoUMD(this.installationLocation);\r\n    }\r\n\r\n    ngOnChanges(changes: SimpleChanges) {\r\n        // If we changed anything OTHER than code, reload the editor\r\n        if (Object.keys(changes).length > 1 || !changes['code']) {\r\n            if (this.editor) {\r\n                this.editor?.dispose();\r\n                this.createEditor();\r\n            }\r\n        }\r\n        if (changes['theme'])\r\n            window['monaco']?.editor.setTheme(this.theme);\r\n    }\r\n\r\n    async ngAfterViewInit() {\r\n        await InstallMonacoUMD();\r\n\r\n        this.createEditor();\r\n    }\r\n\r\n    ngOnDestroy(): void {\r\n        this.editor?.dispose();\r\n        this._sub?.unsubscribe();\r\n    }\r\n\r\n    private createEditor() {\r\n        if (this.customLanguage) {\r\n            this.customLanguage.init(window['monaco']);\r\n        }\r\n\r\n        let editor = this.editor = window['monaco'].editor.create(\r\n            this.viewContainer?.element?.nativeElement,\r\n            this.settings as any\r\n        );\r\n\r\n        // const autoTypings = await\r\n        MonacoAutoTypeImporter.create(editor, {\r\n            monaco: Monaco,\r\n        });\r\n\r\n        this.configureLanguageSupport();\r\n\r\n        if (this.code) {\r\n            editor.setValue(this.code);\r\n        }\r\n\r\n        editor.getModel().onDidChangeContent(() => this.onCodeType.emit());\r\n    }\r\n\r\n    private configureLanguageSupport() {\r\n\r\n    }\r\n\r\n    download() {\r\n        const code = this.editor.getValue();\r\n\r\n        let blob = new Blob([code], { type: 'text/log' });\r\n        let elm = document.createElement('a');\r\n        let blobURL = URL.createObjectURL(blob);\r\n\r\n        // Set the data values.\r\n        elm.href = blobURL;\r\n        elm.download = this.filename;\r\n\r\n        document.body.appendChild(elm);\r\n        elm.click();\r\n\r\n        document.body.removeChild(elm);\r\n        elm.remove();\r\n\r\n        URL.revokeObjectURL(blobURL);\r\n    }\r\n\r\n    @HostListener('window:resize', ['$event'])\r\n    resize = (): void => {\r\n        this.editor?.layout();\r\n    };\r\n}\r\n\r\nexport const InstallMonacoUMD = async (path?: string) => {\r\n    if (window['monaco']) return window['monaco'];\r\n\r\n    // Prevent duplicate injection\r\n    const scriptEls = document.querySelectorAll('body>script[monaco][defer][src]');\r\n\r\n    // Only perform installation if a path is specified.\r\n    if (path && scriptEls.length == 0) {\r\n        // Monaco has a UMD loader that requires this\r\n        // Merge with any pre-existing global require objects.\r\n        if (!window['require']) window['require'] = {} as any;\r\n        if (!window['require']['paths']) window['require']['paths'] = {};\r\n\r\n        if (path.endsWith('/'))\r\n            path = path.slice(0, -1);\r\n\r\n        window['require']['paths'].vs = path;\r\n\r\n        const monacoFiles = [\r\n            'loader.js',\r\n            'editor/editor.main.nls.js',\r\n            'editor/editor.main.js',\r\n        ];\r\n\r\n        for (let i = 0; i < monacoFiles.length; i++) {\r\n            const script = document.createElement(\"script\");\r\n            script.setAttribute(\"monaco\", \"\");\r\n            script.setAttribute(\"defer\", \"\");\r\n            script.setAttribute(\"src\", path + '/' + monacoFiles[i]);\r\n            document.body.append(script);\r\n        }\r\n    }\r\n\r\n    // Return a promise that will resolve when monaco finishes loading\r\n    return await new Promise((res, rej) => {\r\n        let count = 0;\r\n        let i = window.setInterval(() => {\r\n            count++;\r\n\r\n            if (window['monaco'] != undefined) {\r\n                window.clearInterval(i);\r\n                res(true);\r\n            }\r\n            else if (count >= 100) {\r\n                window.clearInterval(i);\r\n                res(false);\r\n            }\r\n        }, 100);\r\n    });\r\n};\r\n"]}

package/esm2022/monaco-editor/ts-type-resolver/dependency-parser.mjs

@@ -0,0 +1,91 @@
+import * as path from 'path-browserify';
+export class DependencyParser {
+    constructor() {
+        this.REGEX_NODE_MODULE = /^node:([\w\W\/]+)$/;
+    }
+    // https://github.com/lukasbach/monaco-editor-auto-typings/commit/fc046e7d9a2abbb5121ad8ab25195d8c1c277416
+    parseDependencies(source, parent) {
+        const importRegex = /import *.+ *from *['"](?<importPath>.+?)['"]/g;
+        const dynamicImportRegex = /await import ?\(['"](?<importPath>.+?)['"]\)/g;
+        const cjsRequireRegex = /require *\(['"](?<importPath>.+?)['"]\)/g;
+        const matches = [
+            ...source.matchAll(importRegex),
+            ...source.matchAll(dynamicImportRegex),
+            ...source.matchAll(cjsRequireRegex)
+        ];
+        const importPaths = matches.map(match => match.groups?.['importPath']);
+        const result = importPaths.map(imp => this.resolvePath(imp, parent));
+        return result;
+    }
+    resolvePath(importPath, parent) {
+        const nodeImport = importPath.match(this.REGEX_NODE_MODULE);
+        if (nodeImport) {
+            return {
+                kind: 'relative-in-package',
+                packageName: '@types/node',
+                importPath: `${nodeImport[1]}.d.ts`,
+                sourcePath: '',
+            };
+        }
+        if (typeof parent === 'string') {
+            if (importPath.startsWith('.')) {
+                return {
+                    kind: 'relative',
+                    importPath,
+                    sourcePath: parent,
+                };
+            }
+            else if (importPath.startsWith('@')) {
+                const segments = importPath.split('/');
+                return {
+                    kind: 'package',
+                    packageName: `${segments[0]}/${segments[1]}`,
+                    importPath: segments.slice(2).join('/'),
+                };
+            }
+            else {
+                const segments = importPath.split('/');
+                return {
+                    kind: 'package',
+                    packageName: segments[0],
+                    importPath: segments.slice(1).join('/'),
+                };
+            }
+        }
+        else {
+            switch (parent.kind) {
+                case 'package':
+                    throw Error('TODO?');
+                case 'relative':
+                    throw Error('TODO2?');
+                case 'relative-in-package':
+                    if (importPath.startsWith('.')) {
+                        return {
+                            kind: 'relative-in-package',
+                            packageName: parent.packageName,
+                            sourcePath: path.join(parent.sourcePath, parent.importPath),
+                            importPath: importPath,
+                        };
+                    }
+                    else if (importPath.startsWith('@')) {
+                        const segments = importPath.split('/');
+                        return {
+                            kind: 'package',
+                            packageName: `${segments[0]}/${segments[1]}`,
+                            importPath: segments.slice(2).join('/'),
+                        };
+                    }
+                    else {
+                        const segments = importPath.split('/');
+                        return {
+                            kind: 'package',
+                            packageName: segments[0],
+                            importPath: segments.slice(1).join('/'),
+                        };
+                    }
+            }
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dependency-parser.js","sourceRoot":"","sources":["../../../../packages/common/monaco-editor/ts-type-resolver/dependency-parser.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path-browserify';\nimport { ImportResourcePath } from './types';\n\nexport class DependencyParser {\n    private REGEX_NODE_MODULE = /^node:([\\w\\W\\/]+)$/;\n\n    // https://github.com/lukasbach/monaco-editor-auto-typings/commit/fc046e7d9a2abbb5121ad8ab25195d8c1c277416\n    public parseDependencies(source: string, parent: ImportResourcePath | string): ImportResourcePath[] {\n        const importRegex = /import *.+ *from *['\"](?<importPath>.+?)['\"]/g;\n        const dynamicImportRegex = /await import ?\\(['\"](?<importPath>.+?)['\"]\\)/g;\n        const cjsRequireRegex = /require *\\(['\"](?<importPath>.+?)['\"]\\)/g;\n\n        const matches = [\n            ...source.matchAll(importRegex),\n            ...source.matchAll(dynamicImportRegex),\n            ...source.matchAll(cjsRequireRegex)\n        ];\n        const importPaths = matches.map(match => match.groups?.['importPath']);\n        const result = importPaths.map(imp => this.resolvePath(imp, parent));\n\n        return result\n    }\n\n    private resolvePath(importPath: string, parent: ImportResourcePath | string): ImportResourcePath {\n        const nodeImport = importPath.match(this.REGEX_NODE_MODULE);\n        if (nodeImport) {\n            return {\n                kind: 'relative-in-package',\n                packageName: '@types/node',\n                importPath: `${nodeImport[1]}.d.ts`,\n                sourcePath: '',\n            };\n        }\n\n        if (typeof parent === 'string') {\n            if (importPath.startsWith('.')) {\n                return {\n                    kind: 'relative',\n                    importPath,\n                    sourcePath: parent,\n                };\n            }\n            else if (importPath.startsWith('@')) {\n                const segments = importPath.split('/');\n                return {\n                    kind: 'package',\n                    packageName: `${segments[0]}/${segments[1]}`,\n                    importPath: segments.slice(2).join('/'),\n                };\n            }\n            else {\n                const segments = importPath.split('/');\n                return {\n                    kind: 'package',\n                    packageName: segments[0],\n                    importPath: segments.slice(1).join('/'),\n                };\n            }\n        }\n        else {\n            switch (parent.kind) {\n                case 'package':\n                    throw Error('TODO?');\n                case 'relative':\n                    throw Error('TODO2?');\n                case 'relative-in-package':\n                    if (importPath.startsWith('.')) {\n                        return {\n                            kind: 'relative-in-package',\n                            packageName: parent.packageName,\n                            sourcePath: path.join(parent.sourcePath, parent.importPath),\n                            importPath: importPath,\n                        };\n                    }\n                    else if (importPath.startsWith('@')) {\n                        const segments = importPath.split('/');\n                        return {\n                            kind: 'package',\n                            packageName: `${segments[0]}/${segments[1]}`,\n                            importPath: segments.slice(2).join('/'),\n                        };\n                    }\n                    else {\n                        const segments = importPath.split('/');\n                        return {\n                            kind: 'package',\n                            packageName: segments[0],\n                            importPath: segments.slice(1).join('/'),\n                        };\n                    }\n            }\n        }\n        return null;\n    }\n}\n"]}

package/esm2022/monaco-editor/ts-type-resolver/dummy-source-cache.mjs

@@ -0,0 +1,15 @@
+export class DummySourceCache {
+    getFile(uri) {
+        return undefined;
+    }
+    async isFileAvailable(uri) {
+        return false;
+    }
+    storeFile(uri, content) {
+        return undefined;
+    }
+    clear() {
+        return undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHVtbXktc291cmNlLWNhY2hlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcGFja2FnZXMvY29tbW9uL21vbmFjby1lZGl0b3IvdHMtdHlwZS1yZXNvbHZlci9kdW1teS1zb3VyY2UtY2FjaGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxPQUFPLGdCQUFnQjtJQUNsQixPQUFPLENBQUMsR0FBVztRQUN0QixPQUFPLFNBQVMsQ0FBQztJQUNyQixDQUFDO0lBRU0sS0FBSyxDQUFDLGVBQWUsQ0FBQyxHQUFXO1FBQ3BDLE9BQU8sS0FBSyxDQUFDO0lBQ2pCLENBQUM7SUFFTSxTQUFTLENBQUMsR0FBVyxFQUFFLE9BQWU7UUFDekMsT0FBTyxTQUFTLENBQUM7SUFDckIsQ0FBQztJQUVNLEtBQUs7UUFDUixPQUFPLFNBQVMsQ0FBQztJQUNyQixDQUFDO0NBQ0oiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBTb3VyY2VDYWNoZSB9IGZyb20gJy4vdHlwZXMnO1xuXG5leHBvcnQgY2xhc3MgRHVtbXlTb3VyY2VDYWNoZSBpbXBsZW1lbnRzIFNvdXJjZUNhY2hlIHtcbiAgICBwdWJsaWMgZ2V0RmlsZSh1cmk6IHN0cmluZyk6IFByb21pc2U8c3RyaW5nIHwgdW5kZWZpbmVkPiB7XG4gICAgICAgIHJldHVybiB1bmRlZmluZWQ7XG4gICAgfVxuXG4gICAgcHVibGljIGFzeW5jIGlzRmlsZUF2YWlsYWJsZSh1cmk6IHN0cmluZyk6IFByb21pc2U8Ym9vbGVhbj4ge1xuICAgICAgICByZXR1cm4gZmFsc2U7XG4gICAgfVxuXG4gICAgcHVibGljIHN0b3JlRmlsZSh1cmk6IHN0cmluZywgY29udGVudDogc3RyaW5nKTogUHJvbWlzZTx2b2lkPiB7XG4gICAgICAgIHJldHVybiB1bmRlZmluZWQ7XG4gICAgfVxuXG4gICAgcHVibGljIGNsZWFyKCk6IFByb21pc2U8dm9pZD4ge1xuICAgICAgICByZXR1cm4gdW5kZWZpbmVkO1xuICAgIH1cbn1cbiJdfQ==