@codingame/monaco-vscode-api 1.78.4 → 1.78.5-next.0

package/dist/monaco.js

@@ -1,463 +1,29 @@
-import { Emitter, __decorate, Extensions$2, __param, IFileService, distinct, IUserDataProfilesService } from './polyfill.js';
-import { Extensions as Extensions$1 } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
-export { registerColor } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
-import { ExtensionsRegistry } from './extensionsRegistry.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { isString, isObject } from 'monaco-editor/esm/vs/base/common/types.js';
-import { joinPath, isEqualOrParent } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-export { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-import { Color } from 'monaco-editor/esm/vs/base/common/color.js';
-import { createInjectedClass } from './injection.js';
-import * as monaco from 'monaco-editor/esm/vs/editor/editor.api.js';
-import { Disposable, extensions } from './api2.js';
-import { Extensions as Extensions$3 } from 'monaco-editor/esm/vs/platform/jsonschemas/common/jsonContributionRegistry.js';
-import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { __decorate, __param } from './node_modules/tslib/tslib.es6.js';
 import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
-import { editorOptionsRegistry } from 'monaco-editor/esm/vs/editor/common/config/editorOptions.js';
-import { equals } from 'monaco-editor/esm/vs/base/common/arrays.js';
-import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
-import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
-import { Extensions as Extensions$4 } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { StandaloneDiffEditor, StandaloneEditor } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneCodeEditor.js';
-import { deepClone } from 'monaco-editor/esm/vs/base/common/objects.js';
+import { isObject } from 'monaco-editor/esm/vs/base/common/types.js';
+import { distinct, deepClone } from 'monaco-editor/esm/vs/base/common/objects.js';
 export { errorHandler } from 'monaco-editor/esm/vs/base/common/errors.js';
-export { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-export { FoldingController } from 'monaco-editor/esm/vs/editor/contrib/folding/browser/folding.js';
 export { FoldingModel, setCollapseStateForMatchingLines } from 'monaco-editor/esm/vs/editor/contrib/folding/browser/foldingModel.js';
+export { FoldingController } from 'monaco-editor/esm/vs/editor/contrib/folding/browser/folding.js';
+export { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+export { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions as Extensions$2 } from 'monaco-editor/esm/vs/platform/jsonschemas/common/jsonContributionRegistry.js';
 export { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
-const ConfigurationChangedEvent = monaco.editor.ConfigurationChangedEvent;
-class ValidatedEditorOptions {
-    constructor() {
-        this._values = [];
-    }
-    _read(option) {
-        return this._values[option];
-    }
-    get(id) {
-        return this._values[id];
-    }
-    _write(option, value) {
-        this._values[option] = value;
-    }
-}
-class ComputedEditorOptions {
-    constructor() {
-        this._values = [];
-    }
-    _read(id) {
-        if (id >= this._values.length) {
-            throw new Error('Cannot read uninitialized value');
-        }
-        return this._values[id];
-    }
-    get(id) {
-        return this._read(id);
-    }
-    _write(id, value) {
-        this._values[id] = value;
-    }
-}
-class EditorOptionsUtil {
-    static validateOptions(options) {
-        const result = ( (new ValidatedEditorOptions()));
-        for (const editorOption of editorOptionsRegistry) {
-            const value = (editorOption.name === '_never_' ? undefined : options[editorOption.name]);
-            result._write(editorOption.id, editorOption.validate(value));
-        }
-        return result;
-    }
-    static computeOptions(options, env) {
-        const result = ( (new ComputedEditorOptions()));
-        for (const editorOption of editorOptionsRegistry) {
-            result._write(editorOption.id, editorOption.compute(env, result, options._read(editorOption.id)));
-        }
-        return result;
-    }
-    static _deepEquals(a, b) {
-        if (typeof a !== 'object' || typeof b !== 'object' || !a || !b) {
-            return a === b;
-        }
-        if (Array.isArray(a) || Array.isArray(b)) {
-            return (Array.isArray(a) && Array.isArray(b) ? equals(a, b) : false);
-        }
-        if (( (Object.keys(a))).length !== ( (Object.keys(b))).length) {
-            return false;
-        }
-        for (const key in a) {
-            if (!EditorOptionsUtil._deepEquals(a[key], b[key])) {
-                return false;
-            }
-        }
-        return true;
-    }
-    static checkEquals(a, b) {
-        const result = [];
-        let somethingChanged = false;
-        for (const editorOption of editorOptionsRegistry) {
-            const changed = !EditorOptionsUtil._deepEquals(a._read(editorOption.id), b._read(editorOption.id));
-            result[editorOption.id] = changed;
-            if (changed) {
-                somethingChanged = true;
-            }
-        }
-        return (somethingChanged ?  (new ConfigurationChangedEvent(result)) : null);
-    }
-    static applyUpdate(options, update) {
-        let changed = false;
-        for (const editorOption of editorOptionsRegistry) {
-            if (update.hasOwnProperty(editorOption.name)) {
-                const result = editorOption.applyUpdate(options[editorOption.name], update[editorOption.name]);
-                options[editorOption.name] = result.newValue;
-                changed = changed || result.didChange;
-            }
-        }
-        return changed;
-    }
-}
-const configurationExtPoint$1 = ( (ExtensionsRegistry.registerExtensionPoint({
-    extensionPoint: 'jsonValidation',
-    defaultExtensionKind: ['workspace', 'web'],
-    jsonSchema: {
-        description: ( (localize('contributes.jsonValidation', 'Contributes json schema configuration.'))),
-        type: 'array',
-        defaultSnippets: [{ body: [{ fileMatch: '${1:file.json}', url: '${2:url}' }] }],
-        items: {
-            type: 'object',
-            defaultSnippets: [{ body: { fileMatch: '${1:file.json}', url: '${2:url}' } }],
-            properties: {
-                fileMatch: {
-                    type: ['string', 'array'],
-                    description: ( (localize(
-                        'contributes.jsonValidation.fileMatch',
-                        'The file pattern (or an array of patterns) to match, for example "package.json" or "*.launch". Exclusion patterns start with \'!\''
-                    ))),
-                    items: {
-                        type: ['string']
-                    }
-                },
-                url: {
-                    description: ( (localize(
-                        'contributes.jsonValidation.url',
-                        'A schema URL (\'http:\', \'https:\') or relative path to the extension folder (\'./\').'
-                    ))),
-                    type: 'string'
-                }
-            }
-        }
-    }
-})));
-class JSONValidationExtensionPoint {
-    constructor() {
-        configurationExtPoint$1.setHandler((extensions) => {
-            for (const extension of extensions) {
-                const extensionValue = extension.value;
-                const collector = extension.collector;
-                const extensionLocation = extension.description.extensionLocation;
-                if (!extensionValue || !Array.isArray(extensionValue)) {
-                    collector.error(( (localize('invalid.jsonValidation', "'configuration.jsonValidation' must be a array"))));
-                    return;
-                }
-                extensionValue.forEach(extension => {
-                    if (!isString(extension.fileMatch) && !(Array.isArray(extension.fileMatch) && extension.fileMatch.every(isString))) {
-                        collector.error(( (localize(
-                            'invalid.fileMatch',
-                            "'configuration.jsonValidation.fileMatch' must be defined as a string or an array of strings."
-                        ))));
-                        return;
-                    }
-                    const uri = extension.url;
-                    if (!isString(uri)) {
-                        collector.error(( (localize(
-                            'invalid.url',
-                            "'configuration.jsonValidation.url' must be a URL or relative path"
-                        ))));
-                        return;
-                    }
-                    if (uri.startsWith('./')) {
-                        try {
-                            const colorThemeLocation = joinPath(extensionLocation, uri);
-                            if (!isEqualOrParent(colorThemeLocation, extensionLocation)) {
-                                collector.warn(( (localize(
-                                    'invalid.path.1',
-                                    "Expected `contributes.{0}.url` ({1}) to be included inside extension's folder ({2}). This might make the extension non-portable.",
-                                    configurationExtPoint$1.name,
-                                     (colorThemeLocation.toString()),
-                                    extensionLocation.path
-                                ))));
-                            }
-                        }
-                        catch (e) {
-                            collector.error(( (localize(
-                                'invalid.url.fileschema',
-                                "'configuration.jsonValidation.url' is an invalid relative URL: {0}",
-                                e.message
-                            ))));
-                        }
-                    }
-                    else if (!/^[^:/?#]+:\/\//.test(uri)) {
-                        collector.error(( (localize(
-                            'invalid.url.schema',
-                            "'configuration.jsonValidation.url' must be an absolute URL or start with './'  to reference schemas located in the extension."
-                        ))));
-                        return;
-                    }
-                });
-            }
-        });
-    }
-}
-const colorRegistry = ( (Registry.as(Extensions$1.ColorContribution)));
-const colorReferenceSchema = colorRegistry.getColorReferenceSchema();
-const colorIdPattern = '^\\w+[.\\w+]*$';
-const configurationExtPoint = ( (ExtensionsRegistry.registerExtensionPoint({
-    extensionPoint: 'colors',
-    jsonSchema: {
-        description: ( (localize('contributes.color', 'Contributes extension defined themable colors'))),
-        type: 'array',
-        items: {
-            type: 'object',
-            properties: {
-                id: {
-                    type: 'string',
-                    description: ( (localize('contributes.color.id', 'The identifier of the themable color'))),
-                    pattern: colorIdPattern,
-                    patternErrorMessage: ( (localize(
-                        'contributes.color.id.format',
-                        'Identifiers must only contain letters, digits and dots and can not start with a dot'
-                    ))),
-                },
-                description: {
-                    type: 'string',
-                    description: ( (localize('contributes.color.description', 'The description of the themable color'))),
-                },
-                defaults: {
-                    type: 'object',
-                    properties: {
-                        light: {
-                            description: ( (localize(
-                                'contributes.defaults.light',
-                                'The default color for light themes. Either a color value in hex (#RRGGBB[AA]) or the identifier of a themable color which provides the default.'
-                            ))),
-                            type: 'string',
-                            anyOf: [
-                                colorReferenceSchema,
-                                { type: 'string', format: 'color-hex' }
-                            ]
-                        },
-                        dark: {
-                            description: ( (localize(
-                                'contributes.defaults.dark',
-                                'The default color for dark themes. Either a color value in hex (#RRGGBB[AA]) or the identifier of a themable color which provides the default.'
-                            ))),
-                            type: 'string',
-                            anyOf: [
-                                colorReferenceSchema,
-                                { type: 'string', format: 'color-hex' }
-                            ]
-                        },
-                        highContrast: {
-                            description: ( (localize(
-                                'contributes.defaults.highContrast',
-                                'The default color for high contrast dark themes. Either a color value in hex (#RRGGBB[AA]) or the identifier of a themable color which provides the default. If not provided, the `dark` color is used as default for high contrast dark themes.'
-                            ))),
-                            type: 'string',
-                            anyOf: [
-                                colorReferenceSchema,
-                                { type: 'string', format: 'color-hex' }
-                            ]
-                        },
-                        highContrastLight: {
-                            description: ( (localize(
-                                'contributes.defaults.highContrastLight',
-                                'The default color for high contrast light themes. Either a color value in hex (#RRGGBB[AA]) or the identifier of a themable color which provides the default. If not provided, the `light` color is used as default for high contrast light themes.'
-                            ))),
-                            type: 'string',
-                            anyOf: [
-                                colorReferenceSchema,
-                                { type: 'string', format: 'color-hex' }
-                            ]
-                        }
-                    },
-                    required: ['light', 'dark']
-                }
-            }
-        }
-    }
-})));
-class ColorExtensionPoint {
-    constructor() {
-        configurationExtPoint.setHandler((extensions, delta) => {
-            for (const extension of delta.added) {
-                const extensionValue = extension.value;
-                const collector = extension.collector;
-                if (!extensionValue || !Array.isArray(extensionValue)) {
-                    collector.error(( (localize('invalid.colorConfiguration', "'configuration.colors' must be a array"))));
-                    return;
-                }
-                const parseColorValue = (s, name) => {
-                    if (s.length > 0) {
-                        if (s[0] === '#') {
-                            return Color.Format.CSS.parseHex(s);
-                        }
-                        else {
-                            return s;
-                        }
-                    }
-                    collector.error(( (localize(
-                        'invalid.default.colorType',
-                        "{0} must be either a color value in hex (#RRGGBB[AA] or #RGB[A]) or the identifier of a themable color which provides the default.",
-                        name
-                    ))));
-                    return Color.red;
-                };
-                for (const colorContribution of extensionValue) {
-                    if (typeof colorContribution.id !== 'string' || colorContribution.id.length === 0) {
-                        collector.error(( (localize(
-                            'invalid.id',
-                            "'configuration.colors.id' must be defined and can not be empty"
-                        ))));
-                        return;
-                    }
-                    if (!colorContribution.id.match(colorIdPattern)) {
-                        collector.error(( (localize(
-                            'invalid.id.format',
-                            "'configuration.colors.id' must only contain letters, digits and dots and can not start with a dot"
-                        ))));
-                        return;
-                    }
-                    if (typeof colorContribution.description !== 'string' || colorContribution.id.length === 0) {
-                        collector.error(( (localize(
-                            'invalid.description',
-                            "'configuration.colors.description' must be defined and can not be empty"
-                        ))));
-                        return;
-                    }
-                    const defaults = colorContribution.defaults;
-                    if (!defaults || typeof defaults !== 'object' || typeof defaults.light !== 'string' || typeof defaults.dark !== 'string') {
-                        collector.error(( (localize(
-                            'invalid.defaults',
-                            "'configuration.colors.defaults' must be defined and must contain 'light' and 'dark'"
-                        ))));
-                        return;
-                    }
-                    if (defaults.highContrast && typeof defaults.highContrast !== 'string') {
-                        collector.error(( (localize(
-                            'invalid.defaults.highContrast',
-                            "If defined, 'configuration.colors.defaults.highContrast' must be a string."
-                        ))));
-                        return;
-                    }
-                    if (defaults.highContrastLight && typeof defaults.highContrastLight !== 'string') {
-                        collector.error(( (localize(
-                            'invalid.defaults.highContrastLight',
-                            "If defined, 'configuration.colors.defaults.highContrastLight' must be a string."
-                        ))));
-                        return;
-                    }
-                    colorRegistry.registerColor(colorContribution.id, {
-                        light: parseColorValue(defaults.light, 'configuration.colors.defaults.light'),
-                        dark: parseColorValue(defaults.dark, 'configuration.colors.defaults.dark'),
-                        hcDark: parseColorValue(defaults.highContrast ?? defaults.dark, 'configuration.colors.defaults.highContrast'),
-                        hcLight: parseColorValue(defaults.highContrastLight ?? defaults.light, 'configuration.colors.defaults.highContrastLight'),
-                    }, colorContribution.description);
-                }
-            }
-            for (const extension of delta.removed) {
-                const extensionValue = extension.value;
-                for (const colorContribution of extensionValue) {
-                    colorRegistry.deregisterColor(colorContribution.id);
-                }
-            }
-        });
-    }
-}
-const registry = ( Registry.as(Extensions$3.JSONContribution));
-function getDefaultSchemaAssociations() {
-    const userDataProfilesService = StandaloneServices.get(IUserDataProfilesService);
-    const profile = userDataProfilesService.defaultProfile;
-    return [{
-            fileMatch: [( profile.keybindingsResource.toString(true))],
-            uri: 'vscode://schemas/keybindings'
-        }, {
-            fileMatch: [( profile.settingsResource.toString(true))],
-            uri: 'vscode://schemas/settings/user'
-        }];
-}
-function getExtensionSchemaAssociations() {
-    const associations = [];
-    extensions.all.forEach(extension => {
-        const packageJSON = extension.packageJSON;
-        const jsonValidation = packageJSON?.contributes?.jsonValidation;
-        if (jsonValidation != null) {
-            if (Array.isArray(jsonValidation)) {
-                jsonValidation.forEach(jv => {
-                    let { fileMatch, url } = jv;
-                    if (typeof fileMatch === 'string') {
-                        fileMatch = [fileMatch];
-                    }
-                    if (Array.isArray(fileMatch) && typeof url === 'string') {
-                        let uri = url;
-                        if (uri[0] === '.' && uri[1] === '/') {
-                            uri = ( monaco.Uri.joinPath(extension.extensionUri, uri).toString());
-                        }
-                        fileMatch = ( fileMatch.map(fm => {
-                            if (fm[0] === '%') {
-                                fm = fm.replace(/%APP_SETTINGS_HOME%/, '/User');
-                                fm = fm.replace(/%MACHINE_SETTINGS_HOME%/, '/Machine');
-                                fm = fm.replace(/%APP_WORKSPACES_HOME%/, '/Workspaces');
-                            }
-                            else if (fm.match(/^(\w+:\/\/|\/|!)/) == null) {
-                                fm = '/' + fm;
-                            }
-                            return fm;
-                        }));
-                        associations.push({ fileMatch, uri });
-                    }
-                });
-            }
-        }
-    });
-    return associations;
-}
-const customSchemaChangeEmitter = new Emitter();
-function getJsonSchemas() {
-    return ( Object.entries(registry.getSchemaContributions().schemas)
-        .filter(([uri]) => uri !== 'vscode://schemas/vscode-extensions')
-        .map(([uri, schema]) => ({
-        uri,
-        schema
-    })));
-}
-const customJsonSchema = [];
-function registerJsonSchema(schema) {
-    customJsonSchema.push(schema);
-    customSchemaChangeEmitter.fire();
-    return new Disposable(() => {
-        const index = customJsonSchema.indexOf(schema);
-        if (index >= 0) {
-            customJsonSchema.splice(index, 1);
-            customSchemaChangeEmitter.fire();
-        }
-    });
-}
-function synchronizeJsonSchemas() {
-    function updateDiagnosticsOptions() {
-        monaco.languages.json.jsonDefaults.setDiagnosticsOptions({
-            ...monaco.languages.json.jsonDefaults.diagnosticsOptions,
-            schemas: [
-                ...getJsonSchemas(),
-                ...getDefaultSchemaAssociations(),
-                ...getExtensionSchemaAssociations()
-            ]
-        });
-    }
-    updateDiagnosticsOptions();
-    const changeEvent = Event.any(extensions.onDidChange, customSchemaChangeEmitter.event, registry.onDidChangeSchema);
-    return changeEvent(updateDiagnosticsOptions);
-}
+import { Extensions as Extensions$3 } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { EditorOptionsUtil } from './vscode/vs/editor/browser/config/editorConfiguration.js';
+export { registerColor } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { JSONValidationExtensionPoint } from './vscode/vs/workbench/api/common/jsonValidationExtensionPoint.js';
+import { Extensions as Extensions$1 } from './vscode/vs/workbench/common/contributions.js';
+import { ColorExtensionPoint } from './vscode/vs/workbench/services/themes/common/colorExtensionPoint.js';
+import { createInjectedClass } from './tools/injection.js';
+export { registerJsonSchema, synchronizeJsonSchemas } from './json.js';
 let ExtensionPoints = class ExtensionPoints {
     constructor(instantiationService) {
         this.instantiationService = instantiationService;
@@ -468,7 +34,7 @@ let ExtensionPoints = class ExtensionPoints {
 ExtensionPoints = __decorate([
     ( __param(0, IInstantiationService))
 ], ExtensionPoints);
-( Registry.as(Extensions$2.Workbench)).registerWorkbenchContribution(ExtensionPoints, 1 );
+( Registry.as(Extensions$1.Workbench)).registerWorkbenchContribution(ExtensionPoints, 1 );
 function computeConfiguration(configuration, isDiffEditor, overrides) {
     const editorConfiguration = isObject(configuration.editor) ? deepClone(configuration.editor) : Object.create(null);
     if (isDiffEditor && isObject(configuration.diffEditor)) {
@@ -548,7 +114,7 @@ const createConfiguredDiffEditor = (domElement, options, override) => {
     return instantiationService.createInstance(ConfiguredStandaloneDiffEditor, domElement, options);
 };
 const Extensions = {
-    ...Extensions$3,
-    ...Extensions$4
+    ...Extensions$2,
+    ...Extensions$3
 };
-export { Extensions, createConfiguredDiffEditor, createConfiguredEditor, createModelReference, deleteFile, registerJsonSchema, synchronizeJsonSchemas, writeFile };
+export { Extensions, createConfiguredDiffEditor, createConfiguredEditor, createModelReference, deleteFile, writeFile };

package/dist/node_modules/tslib/tslib.es6.js

@@ -0,0 +1,21 @@
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+function __classPrivateFieldGet(receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+}
+export { __classPrivateFieldGet, __classPrivateFieldSet, __decorate, __param };

package/dist/override/vs/workbench/browser/parts/editor/textEditor.js

@@ -0,0 +1,2 @@
+class AbstractTextEditor {}
+export { AbstractTextEditor };

package/dist/rollup-extension-directory-plugin.js

@@ -1,5 +1,5 @@
 import { createFilter, dataToEsm } from '@rollup/pluginutils';
-import { e as extractPathsFromExtensionManifest, p as parseJson, l as localizeManifest } from './extension-tools-b2d018a3.js';
+import { e as extractPathsFromExtensionManifest, p as parseJson, l as localizeManifest } from './extension-tools-b68a64de.js';
 import * as path from 'path';
 import * as fsPromise from 'fs/promises';
 import * as fs from 'fs';

package/dist/rollup-vsix-plugin.js

@@ -1,6 +1,6 @@
 import { createFilter, dataToEsm } from '@rollup/pluginutils';
 import * as yauzl from 'yauzl';
-import { p as parseJson, l as localizeManifest, e as extractPathsFromExtensionManifest } from './extension-tools-b2d018a3.js';
+import { p as parseJson, l as localizeManifest, e as extractPathsFromExtensionManifest } from './extension-tools-b68a64de.js';
 import * as path from 'path';
 
 function read(stream) {

package/dist/service-override/_46__46__47__46__46__47_vscode_47_vs_47_platform_47_audioCues_47_browser_47_media_47__42__46_mp3.js

@@ -0,0 +1,11 @@
+export { default as vs_platform_audioCues_browser_media_break_mp3 } from "../assets/break.mp3";
+export { default as vs_platform_audioCues_browser_media_diffLineDeleted_mp3 } from "../assets/diffLineDeleted.mp3";
+export { default as vs_platform_audioCues_browser_media_diffLineInserted_mp3 } from "../assets/diffLineInserted.mp3";
+export { default as vs_platform_audioCues_browser_media_diffLineModified_mp3 } from "../assets/diffLineModified.mp3";
+export { default as vs_platform_audioCues_browser_media_error_mp3 } from "../assets/error.mp3";
+export { default as vs_platform_audioCues_browser_media_foldedAreas_mp3 } from "../assets/foldedAreas.mp3";
+export { default as vs_platform_audioCues_browser_media_quickFixes_mp3 } from "../assets/quickFixes.mp3";
+export { default as vs_platform_audioCues_browser_media_taskCompleted_mp3 } from "../assets/taskCompleted.mp3";
+export { default as vs_platform_audioCues_browser_media_taskFailed_mp3 } from "../assets/taskFailed.mp3";
+export { default as vs_platform_audioCues_browser_media_terminalBell_mp3 } from "../assets/terminalBell.mp3";
+export { default as vs_platform_audioCues_browser_media_warning_mp3 } from "../assets/warning.mp3";

package/dist/service-override/audioCue.js

@@ -0,0 +1,13 @@
+import '../vscode-services/missing-services.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { IAudioCueService, AudioCueService } from 'monaco-editor/esm/vs/platform/audioCues/browser/audioCueService.js';
+import * as _46__46__47__46__46__47_vscode_47_vs_47_platform_47_audioCues_47_browser_47_media_47__42__46_mp3 from './_46__46__47__46__46__47_vscode_47_vs_47_platform_47_audioCues_47_browser_47_media_47__42__46_mp3.js';
+import { registerAssets } from '../assets.js';
+import '../vscode/vs/workbench/contrib/audioCues/browser/audioCues.contribution.js';
+registerAssets(_46__46__47__46__46__47_vscode_47_vs_47_platform_47_audioCues_47_browser_47_media_47__42__46_mp3);
+function getServiceOverride() {
+    return {
+        [( IAudioCueService.toString())]: new SyncDescriptor(AudioCueService)
+    };
+}
+export { getServiceOverride as default };