monaco-editor11 1.1.0 → 1.1.2

package/dist/workers/usLayoutResolvedKeybinding.js

@@ -0,0 +1,175 @@
+import { KeyCodeUtils, IMMUTABLE_CODE_TO_KEY_CODE } from '../../../base/common/keyCodes.js';
+import { KeyCodeChord } from '../../../base/common/keybindings.js';
+import { BaseResolvedKeybinding } from './baseResolvedKeybinding.js';
+import { toEmptyArrayIfContainsNull } from './resolvedKeybindingItem.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * Do not instantiate. Use KeybindingService to get a ResolvedKeybinding seeded with information about the current kb layout.
+ */
+class USLayoutResolvedKeybinding extends BaseResolvedKeybinding {
+    constructor(chords, os) {
+        super(os, chords);
+    }
+    _keyCodeToUILabel(keyCode) {
+        if (this._os === 2 /* OperatingSystem.Macintosh */) {
+            switch (keyCode) {
+                case 15 /* KeyCode.LeftArrow */:
+                    return '←';
+                case 16 /* KeyCode.UpArrow */:
+                    return '↑';
+                case 17 /* KeyCode.RightArrow */:
+                    return '→';
+                case 18 /* KeyCode.DownArrow */:
+                    return '↓';
+            }
+        }
+        return KeyCodeUtils.toString(keyCode);
+    }
+    _getLabel(chord) {
+        if (chord.isDuplicateModifierCase()) {
+            return '';
+        }
+        return this._keyCodeToUILabel(chord.keyCode);
+    }
+    _getAriaLabel(chord) {
+        if (chord.isDuplicateModifierCase()) {
+            return '';
+        }
+        return KeyCodeUtils.toString(chord.keyCode);
+    }
+    _getElectronAccelerator(chord) {
+        return KeyCodeUtils.toElectronAccelerator(chord.keyCode);
+    }
+    _getUserSettingsLabel(chord) {
+        if (chord.isDuplicateModifierCase()) {
+            return '';
+        }
+        const result = KeyCodeUtils.toUserSettingsUS(chord.keyCode);
+        return (result ? result.toLowerCase() : result);
+    }
+    _getChordDispatch(chord) {
+        return USLayoutResolvedKeybinding.getDispatchStr(chord);
+    }
+    static getDispatchStr(chord) {
+        if (chord.isModifierKey()) {
+            return null;
+        }
+        let result = '';
+        if (chord.ctrlKey) {
+            result += 'ctrl+';
+        }
+        if (chord.shiftKey) {
+            result += 'shift+';
+        }
+        if (chord.altKey) {
+            result += 'alt+';
+        }
+        if (chord.metaKey) {
+            result += 'meta+';
+        }
+        result += KeyCodeUtils.toString(chord.keyCode);
+        return result;
+    }
+    _getSingleModifierChordDispatch(keybinding) {
+        if (keybinding.keyCode === 5 /* KeyCode.Ctrl */ && !keybinding.shiftKey && !keybinding.altKey && !keybinding.metaKey) {
+            return 'ctrl';
+        }
+        if (keybinding.keyCode === 4 /* KeyCode.Shift */ && !keybinding.ctrlKey && !keybinding.altKey && !keybinding.metaKey) {
+            return 'shift';
+        }
+        if (keybinding.keyCode === 6 /* KeyCode.Alt */ && !keybinding.ctrlKey && !keybinding.shiftKey && !keybinding.metaKey) {
+            return 'alt';
+        }
+        if (keybinding.keyCode === 57 /* KeyCode.Meta */ && !keybinding.ctrlKey && !keybinding.shiftKey && !keybinding.altKey) {
+            return 'meta';
+        }
+        return null;
+    }
+    /**
+     * *NOTE*: Check return value for `KeyCode.Unknown`.
+     */
+    static _scanCodeToKeyCode(scanCode) {
+        const immutableKeyCode = IMMUTABLE_CODE_TO_KEY_CODE[scanCode];
+        if (immutableKeyCode !== -1 /* KeyCode.DependsOnKbLayout */) {
+            return immutableKeyCode;
+        }
+        switch (scanCode) {
+            case 10 /* ScanCode.KeyA */: return 31 /* KeyCode.KeyA */;
+            case 11 /* ScanCode.KeyB */: return 32 /* KeyCode.KeyB */;
+            case 12 /* ScanCode.KeyC */: return 33 /* KeyCode.KeyC */;
+            case 13 /* ScanCode.KeyD */: return 34 /* KeyCode.KeyD */;
+            case 14 /* ScanCode.KeyE */: return 35 /* KeyCode.KeyE */;
+            case 15 /* ScanCode.KeyF */: return 36 /* KeyCode.KeyF */;
+            case 16 /* ScanCode.KeyG */: return 37 /* KeyCode.KeyG */;
+            case 17 /* ScanCode.KeyH */: return 38 /* KeyCode.KeyH */;
+            case 18 /* ScanCode.KeyI */: return 39 /* KeyCode.KeyI */;
+            case 19 /* ScanCode.KeyJ */: return 40 /* KeyCode.KeyJ */;
+            case 20 /* ScanCode.KeyK */: return 41 /* KeyCode.KeyK */;
+            case 21 /* ScanCode.KeyL */: return 42 /* KeyCode.KeyL */;
+            case 22 /* ScanCode.KeyM */: return 43 /* KeyCode.KeyM */;
+            case 23 /* ScanCode.KeyN */: return 44 /* KeyCode.KeyN */;
+            case 24 /* ScanCode.KeyO */: return 45 /* KeyCode.KeyO */;
+            case 25 /* ScanCode.KeyP */: return 46 /* KeyCode.KeyP */;
+            case 26 /* ScanCode.KeyQ */: return 47 /* KeyCode.KeyQ */;
+            case 27 /* ScanCode.KeyR */: return 48 /* KeyCode.KeyR */;
+            case 28 /* ScanCode.KeyS */: return 49 /* KeyCode.KeyS */;
+            case 29 /* ScanCode.KeyT */: return 50 /* KeyCode.KeyT */;
+            case 30 /* ScanCode.KeyU */: return 51 /* KeyCode.KeyU */;
+            case 31 /* ScanCode.KeyV */: return 52 /* KeyCode.KeyV */;
+            case 32 /* ScanCode.KeyW */: return 53 /* KeyCode.KeyW */;
+            case 33 /* ScanCode.KeyX */: return 54 /* KeyCode.KeyX */;
+            case 34 /* ScanCode.KeyY */: return 55 /* KeyCode.KeyY */;
+            case 35 /* ScanCode.KeyZ */: return 56 /* KeyCode.KeyZ */;
+            case 36 /* ScanCode.Digit1 */: return 22 /* KeyCode.Digit1 */;
+            case 37 /* ScanCode.Digit2 */: return 23 /* KeyCode.Digit2 */;
+            case 38 /* ScanCode.Digit3 */: return 24 /* KeyCode.Digit3 */;
+            case 39 /* ScanCode.Digit4 */: return 25 /* KeyCode.Digit4 */;
+            case 40 /* ScanCode.Digit5 */: return 26 /* KeyCode.Digit5 */;
+            case 41 /* ScanCode.Digit6 */: return 27 /* KeyCode.Digit6 */;
+            case 42 /* ScanCode.Digit7 */: return 28 /* KeyCode.Digit7 */;
+            case 43 /* ScanCode.Digit8 */: return 29 /* KeyCode.Digit8 */;
+            case 44 /* ScanCode.Digit9 */: return 30 /* KeyCode.Digit9 */;
+            case 45 /* ScanCode.Digit0 */: return 21 /* KeyCode.Digit0 */;
+            case 51 /* ScanCode.Minus */: return 88 /* KeyCode.Minus */;
+            case 52 /* ScanCode.Equal */: return 86 /* KeyCode.Equal */;
+            case 53 /* ScanCode.BracketLeft */: return 92 /* KeyCode.BracketLeft */;
+            case 54 /* ScanCode.BracketRight */: return 94 /* KeyCode.BracketRight */;
+            case 55 /* ScanCode.Backslash */: return 93 /* KeyCode.Backslash */;
+            case 56 /* ScanCode.IntlHash */: return 0 /* KeyCode.Unknown */; // missing
+            case 57 /* ScanCode.Semicolon */: return 85 /* KeyCode.Semicolon */;
+            case 58 /* ScanCode.Quote */: return 95 /* KeyCode.Quote */;
+            case 59 /* ScanCode.Backquote */: return 91 /* KeyCode.Backquote */;
+            case 60 /* ScanCode.Comma */: return 87 /* KeyCode.Comma */;
+            case 61 /* ScanCode.Period */: return 89 /* KeyCode.Period */;
+            case 62 /* ScanCode.Slash */: return 90 /* KeyCode.Slash */;
+            case 106 /* ScanCode.IntlBackslash */: return 97 /* KeyCode.IntlBackslash */;
+        }
+        return 0 /* KeyCode.Unknown */;
+    }
+    static _toKeyCodeChord(chord) {
+        if (!chord) {
+            return null;
+        }
+        if (chord instanceof KeyCodeChord) {
+            return chord;
+        }
+        const keyCode = this._scanCodeToKeyCode(chord.scanCode);
+        if (keyCode === 0 /* KeyCode.Unknown */) {
+            return null;
+        }
+        return new KeyCodeChord(chord.ctrlKey, chord.shiftKey, chord.altKey, chord.metaKey, keyCode);
+    }
+    static resolveKeybinding(keybinding, os) {
+        const chords = toEmptyArrayIfContainsNull(keybinding.chords.map(chord => this._toKeyCodeChord(chord)));
+        if (chords.length > 0) {
+            return [new USLayoutResolvedKeybinding(chords, os)];
+        }
+        return [];
+    }
+}
+
+export { USLayoutResolvedKeybinding };

package/dist/workers/utils.js

@@ -0,0 +1,209 @@
+import { numberComparator } from '../../../../../../../base/common/arrays.js';
+import { findFirstMin } from '../../../../../../../base/common/arraysFind.js';
+import '../../../../../../../base/common/observableInternal/index.js';
+import { splitLines } from '../../../../../../../base/common/strings.js';
+import { observableCodeEditor } from '../../../../../../browser/observableCodeEditor.js';
+import { Rect } from '../../../../../../common/core/2d/rect.js';
+import { OffsetRange } from '../../../../../../common/core/ranges/offsetRange.js';
+import { Position } from '../../../../../../common/core/position.js';
+import { Range } from '../../../../../../common/core/range.js';
+import { TextReplacement, TextEdit } from '../../../../../../common/core/edits/textEdit.js';
+import { RangeMapping } from '../../../../../../common/diff/rangeMapping.js';
+import { indentOfLine } from '../../../../../../common/model/textModel.js';
+import { BugIndicatingError } from '../../../../../../../base/common/errors.js';
+import { DebugLocation } from '../../../../../../../base/common/observableInternal/debugLocation.js';
+import { derivedObservableWithCache } from '../../../../../../../base/common/observableInternal/utils/utils.js';
+import { derivedOpts, derived } from '../../../../../../../base/common/observableInternal/observables/derived.js';
+
+function maxContentWidthInRange(editor, range, reader) {
+    editor.layoutInfo.read(reader);
+    editor.value.read(reader);
+    const model = editor.model.read(reader);
+    if (!model) {
+        return 0;
+    }
+    let maxContentWidth = 0;
+    editor.scrollTop.read(reader);
+    for (let i = range.startLineNumber; i < range.endLineNumberExclusive; i++) {
+        const column = model.getLineMaxColumn(i);
+        let lineContentWidth = editor.editor.getOffsetForColumn(i, column);
+        if (lineContentWidth === -1) {
+            // approximation
+            const typicalHalfwidthCharacterWidth = editor.editor.getOption(59 /* EditorOption.fontInfo */).typicalHalfwidthCharacterWidth;
+            const approximation = column * typicalHalfwidthCharacterWidth;
+            lineContentWidth = approximation;
+        }
+        maxContentWidth = Math.max(maxContentWidth, lineContentWidth);
+    }
+    const lines = range.mapToLineArray(l => model.getLineContent(l));
+    if (maxContentWidth < 5 && lines.some(l => l.length > 0) && model.uri.scheme !== 'file') {
+        console.error('unexpected width');
+    }
+    return maxContentWidth;
+}
+function getOffsetForPos(editor, pos, reader) {
+    editor.layoutInfo.read(reader);
+    editor.value.read(reader);
+    const model = editor.model.read(reader);
+    if (!model) {
+        return 0;
+    }
+    editor.scrollTop.read(reader);
+    const lineContentWidth = editor.editor.getOffsetForColumn(pos.lineNumber, pos.column);
+    return lineContentWidth;
+}
+function getPrefixTrim(diffRanges, originalLinesRange, modifiedLines, editor, reader = undefined) {
+    const textModel = editor.getModel();
+    if (!textModel) {
+        return { prefixTrim: 0, prefixLeftOffset: 0 };
+    }
+    const replacementStart = diffRanges.map(r => r.isSingleLine() ? r.startColumn - 1 : 0);
+    const originalIndents = originalLinesRange.mapToLineArray(line => indentOfLine(textModel.getLineContent(line)));
+    const modifiedIndents = modifiedLines.filter(line => line !== '').map(line => indentOfLine(line));
+    const prefixTrim = Math.min(...replacementStart, ...originalIndents, ...modifiedIndents);
+    let prefixLeftOffset;
+    const startLineIndent = textModel.getLineIndentColumn(originalLinesRange.startLineNumber);
+    if (startLineIndent >= prefixTrim + 1) {
+        // We can use the editor to get the offset
+        // TODO go through other usages of getOffsetForColumn and come up with a robust reactive solution to read it
+        observableCodeEditor(editor).scrollTop.read(reader); // getOffsetForColumn requires the line number to be visible. This might change on scroll top.
+        prefixLeftOffset = editor.getOffsetForColumn(originalLinesRange.startLineNumber, prefixTrim + 1);
+    }
+    else if (modifiedLines.length > 0) {
+        // Content is not in the editor, we can use the content width to calculate the offset
+        prefixLeftOffset = getContentRenderWidth(modifiedLines[0].slice(0, prefixTrim), editor, textModel);
+    }
+    else {
+        // unable to approximate the offset
+        return { prefixTrim: 0, prefixLeftOffset: 0 };
+    }
+    return { prefixTrim, prefixLeftOffset };
+}
+function getContentRenderWidth(content, editor, textModel) {
+    const w = editor.getOption(59 /* EditorOption.fontInfo */).typicalHalfwidthCharacterWidth;
+    const tabSize = textModel.getOptions().tabSize * w;
+    const numTabs = content.split('\t').length - 1;
+    const numNoneTabs = content.length - numTabs;
+    return numNoneTabs * w + numTabs * tabSize;
+}
+function getEditorValidOverlayRect(editor) {
+    const contentLeft = editor.layoutInfoContentLeft;
+    const width = derived({ name: 'editor.validOverlay.width' }, r => {
+        const hasMinimapOnTheRight = editor.layoutInfoMinimap.read(r).minimapLeft !== 0;
+        const editorWidth = editor.layoutInfoWidth.read(r) - contentLeft.read(r);
+        if (hasMinimapOnTheRight) {
+            const minimapAndScrollbarWidth = editor.layoutInfoMinimap.read(r).minimapWidth + editor.layoutInfoVerticalScrollbarWidth.read(r);
+            return editorWidth - minimapAndScrollbarWidth;
+        }
+        return editorWidth;
+    });
+    const height = derived({ name: 'editor.validOverlay.height' }, r => editor.layoutInfoHeight.read(r) + editor.contentHeight.read(r));
+    return derived({ name: 'editor.validOverlay' }, r => Rect.fromLeftTopWidthHeight(contentLeft.read(r), 0, width.read(r), height.read(r)));
+}
+function applyEditToModifiedRangeMappings(rangeMapping, edit) {
+    const updatedMappings = [];
+    for (const m of rangeMapping) {
+        const updatedRange = edit.mapRange(m.modifiedRange);
+        updatedMappings.push(new RangeMapping(m.originalRange, updatedRange));
+    }
+    return updatedMappings;
+}
+function classNames(...classes) {
+    return classes.filter(c => typeof c === 'string').join(' ');
+}
+function offsetRangeToRange(columnOffsetRange, startPos) {
+    return new Range(startPos.lineNumber, startPos.column + columnOffsetRange.start, startPos.lineNumber, startPos.column + columnOffsetRange.endExclusive);
+}
+/**
+ * Calculates the indentation size (in spaces) of a given line,
+ * interpreting tabs as the specified tab size.
+ */
+function getIndentationSize(line, tabSize) {
+    let currentSize = 0;
+    loop: for (let i = 0, len = line.length; i < len; i++) {
+        switch (line.charCodeAt(i)) {
+            case 9 /* CharCode.Tab */:
+                currentSize += tabSize;
+                break;
+            case 32 /* CharCode.Space */:
+                currentSize++;
+                break;
+            default: break loop;
+        }
+    }
+    // if currentSize % tabSize !== 0,
+    // then there are spaces which are not part of the indentation
+    return currentSize - (currentSize % tabSize);
+}
+/**
+ * Calculates the number of characters at the start of a line that correspond to a given indentation size,
+ * taking into account both tabs and spaces.
+ */
+function indentSizeToIndentLength(line, indentSize, tabSize) {
+    let remainingSize = indentSize - (indentSize % tabSize);
+    let i = 0;
+    for (; i < line.length; i++) {
+        if (remainingSize === 0) {
+            break;
+        }
+        switch (line.charCodeAt(i)) {
+            case 9 /* CharCode.Tab */:
+                remainingSize -= tabSize;
+                break;
+            case 32 /* CharCode.Space */:
+                remainingSize--;
+                break;
+            default: throw new BugIndicatingError('Unexpected character found while calculating indent length');
+        }
+    }
+    return i;
+}
+function createReindentEdit(text, range, tabSize) {
+    const newLines = splitLines(text);
+    const edits = [];
+    const minIndentSize = findFirstMin(range.mapToLineArray(l => getIndentationSize(newLines[l - 1], tabSize)), numberComparator);
+    range.forEach(lineNumber => {
+        const indentLength = indentSizeToIndentLength(newLines[lineNumber - 1], minIndentSize, tabSize);
+        edits.push(new TextReplacement(offsetRangeToRange(new OffsetRange(0, indentLength), new Position(lineNumber, 1)), ''));
+    });
+    return new TextEdit(edits);
+}
+class PathBuilder {
+    constructor() {
+        this._data = '';
+    }
+    moveTo(point) {
+        this._data += `M ${point.x} ${point.y} `;
+        return this;
+    }
+    lineTo(point) {
+        this._data += `L ${point.x} ${point.y} `;
+        return this;
+    }
+    build() {
+        return this._data;
+    }
+}
+function mapOutFalsy(obs) {
+    const nonUndefinedObs = derivedObservableWithCache(undefined, (reader, lastValue) => obs.read(reader) || lastValue);
+    return derivedOpts({
+        debugName: () => `${obs.debugName}.mapOutFalsy`
+    }, reader => {
+        nonUndefinedObs.read(reader);
+        const val = obs.read(reader);
+        if (!val) {
+            return undefined;
+        }
+        return nonUndefinedObs;
+    });
+}
+function rectToProps(fn, debugLocation = DebugLocation.ofCaller()) {
+    return {
+        left: derived({ name: 'editor.validOverlay.left' }, reader => /** @description left */ fn(reader).left, debugLocation),
+        top: derived({ name: 'editor.validOverlay.top' }, reader => /** @description top */ fn(reader).top, debugLocation),
+        width: derived({ name: 'editor.validOverlay.width' }, reader => /** @description width */ fn(reader).right - fn(reader).left, debugLocation),
+        height: derived({ name: 'editor.validOverlay.height' }, reader => /** @description height */ fn(reader).bottom - fn(reader).top, debugLocation),
+    };
+}
+
+export { PathBuilder, applyEditToModifiedRangeMappings, classNames, createReindentEdit, getContentRenderWidth, getEditorValidOverlayRect, getOffsetForPos, getPrefixTrim, mapOutFalsy, maxContentWidthInRange, rectToProps };

package/dist/workers/utilsCancellation.js

@@ -0,0 +1,63 @@
+import { CancellationError } from '../../errors.js';
+import '../../cancellation.js';
+import { autorun } from '../reactions/autorun.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+function waitForState(observable, predicate, isError, cancellationToken) {
+    if (!predicate) {
+        predicate = state => state !== null && state !== undefined;
+    }
+    return new Promise((resolve, reject) => {
+        let isImmediateRun = true;
+        let shouldDispose = false;
+        const stateObs = observable.map(state => {
+            /** @description waitForState.state */
+            return {
+                isFinished: predicate(state),
+                error: isError ? isError(state) : false,
+                state
+            };
+        });
+        const d = autorun(reader => {
+            /** @description waitForState */
+            const { isFinished, error, state } = stateObs.read(reader);
+            if (isFinished || error) {
+                if (isImmediateRun) {
+                    // The variable `d` is not initialized yet
+                    shouldDispose = true;
+                }
+                else {
+                    d.dispose();
+                }
+                if (error) {
+                    reject(error === true ? state : error);
+                }
+                else {
+                    resolve(state);
+                }
+            }
+        });
+        if (cancellationToken) {
+            const dc = cancellationToken.onCancellationRequested(() => {
+                d.dispose();
+                dc.dispose();
+                reject(new CancellationError());
+            });
+            if (cancellationToken.isCancellationRequested) {
+                d.dispose();
+                dc.dispose();
+                reject(new CancellationError());
+                return;
+            }
+        }
+        isImmediateRun = false;
+        if (shouldDispose) {
+            d.dispose();
+        }
+    });
+}
+
+export { waitForState };

package/dist/workers/uuid.js

@@ -0,0 +1,53 @@
+const generateUuid = (function () {
+    // use `randomUUID` if possible
+    if (typeof crypto.randomUUID === 'function') {
+        // see https://developer.mozilla.org/en-US/docs/Web/API/Window/crypto
+        // > Although crypto is available on all windows, the returned Crypto object only has one
+        // > usable feature in insecure contexts: the getRandomValues() method.
+        // > In general, you should use this API only in secure contexts.
+        return crypto.randomUUID.bind(crypto);
+    }
+    // prep-work
+    const _data = new Uint8Array(16);
+    const _hex = [];
+    for (let i = 0; i < 256; i++) {
+        _hex.push(i.toString(16).padStart(2, '0'));
+    }
+    return function generateUuid() {
+        // get data
+        crypto.getRandomValues(_data);
+        // set version bits
+        _data[6] = (_data[6] & 0x0f) | 0x40;
+        _data[8] = (_data[8] & 0x3f) | 0x80;
+        // print as string
+        let i = 0;
+        let result = '';
+        result += _hex[_data[i++]];
+        result += _hex[_data[i++]];
+        result += _hex[_data[i++]];
+        result += _hex[_data[i++]];
+        result += '-';
+        result += _hex[_data[i++]];
+        result += _hex[_data[i++]];
+        result += '-';
+        result += _hex[_data[i++]];
+        result += _hex[_data[i++]];
+        result += '-';
+        result += _hex[_data[i++]];
+        result += _hex[_data[i++]];
+        result += '-';
+        result += _hex[_data[i++]];
+        result += _hex[_data[i++]];
+        result += _hex[_data[i++]];
+        result += _hex[_data[i++]];
+        result += _hex[_data[i++]];
+        result += _hex[_data[i++]];
+        return result;
+    };
+})();
+/** Namespace should be 3 letter. */
+function prefixedUuid(namespace) {
+    return `${namespace}-${generateUuid()}`;
+}
+
+export { generateUuid, prefixedUuid };

package/dist/workers/validation.js

@@ -0,0 +1,159 @@
+import { mapFilter } from './arrays.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class ValidatorBase {
+    validateOrThrow(content) {
+        const result = this.validate(content);
+        if (result.error) {
+            throw new Error(result.error.message);
+        }
+        return result.content;
+    }
+}
+class TypeofValidator extends ValidatorBase {
+    constructor(type) {
+        super();
+        this.type = type;
+    }
+    validate(content) {
+        if (typeof content !== this.type) {
+            return { content: undefined, error: { message: `Expected ${this.type}, but got ${typeof content}` } };
+        }
+        return { content: content, error: undefined };
+    }
+    getJSONSchema() {
+        return { type: this.type };
+    }
+}
+const vStringValidator = new TypeofValidator('string');
+function vString() { return vStringValidator; }
+new TypeofValidator('number');
+const vBooleanValidator = new TypeofValidator('boolean');
+function vBoolean() { return vBooleanValidator; }
+new TypeofValidator('object');
+class UndefinedValidator extends ValidatorBase {
+    validate(content) {
+        if (content !== undefined) {
+            return { content: undefined, error: { message: `Expected undefined, but got ${typeof content}` } };
+        }
+        return { content: undefined, error: undefined };
+    }
+    getJSONSchema() {
+        return {};
+    }
+}
+function vUndefined() {
+    return new UndefinedValidator();
+}
+class Optional {
+    constructor(validator) {
+        this.validator = validator;
+    }
+}
+function vOptionalProp(validator) {
+    return new Optional(validator);
+}
+class ObjValidator extends ValidatorBase {
+    constructor(properties) {
+        super();
+        this.properties = properties;
+    }
+    validate(content) {
+        if (typeof content !== 'object' || content === null) {
+            return { content: undefined, error: { message: 'Expected object' } };
+        }
+        // eslint-disable-next-line local/code-no-dangerous-type-assertions
+        const result = {};
+        for (const key in this.properties) {
+            const prop = this.properties[key];
+            // eslint-disable-next-line local/code-no-any-casts, @typescript-eslint/no-explicit-any
+            const fieldValue = content[key];
+            const isOptional = prop instanceof Optional;
+            const validator = isOptional ? prop.validator : prop;
+            if (isOptional && fieldValue === undefined) {
+                // Optional field not provided, skip validation
+                continue;
+            }
+            const { content: value, error } = validator.validate(fieldValue);
+            if (error) {
+                return { content: undefined, error: { message: `Error in property '${key}': ${error.message}` } };
+            }
+            // eslint-disable-next-line local/code-no-any-casts, @typescript-eslint/no-explicit-any
+            result[key] = value;
+        }
+        return { content: result, error: undefined };
+    }
+    getJSONSchema() {
+        const requiredFields = [];
+        const schemaProperties = {};
+        for (const [key, prop] of Object.entries(this.properties)) {
+            const isOptional = prop instanceof Optional;
+            const validator = isOptional ? prop.validator : prop;
+            schemaProperties[key] = validator.getJSONSchema();
+            if (!isOptional) {
+                requiredFields.push(key);
+            }
+        }
+        const schema = {
+            type: 'object',
+            properties: schemaProperties,
+            ...(requiredFields.length > 0 ? { required: requiredFields } : {})
+        };
+        return schema;
+    }
+}
+function vObj(properties) {
+    return new ObjValidator(properties);
+}
+class UnionValidator extends ValidatorBase {
+    constructor(validators) {
+        super();
+        this.validators = validators;
+    }
+    validate(content) {
+        let lastError;
+        for (const validator of this.validators) {
+            const { content: value, error } = validator.validate(content);
+            if (!error) {
+                // eslint-disable-next-line local/code-no-any-casts, @typescript-eslint/no-explicit-any
+                return { content: value, error: undefined };
+            }
+            lastError = error;
+        }
+        return { content: undefined, error: lastError };
+    }
+    getJSONSchema() {
+        return {
+            oneOf: mapFilter(this.validators, validator => {
+                if (validator instanceof UndefinedValidator) {
+                    return undefined;
+                }
+                return validator.getJSONSchema();
+            }),
+        };
+    }
+}
+function vUnion(...validators) {
+    return new UnionValidator(validators);
+}
+class UseRefSchemaValidator extends ValidatorBase {
+    constructor(_ref, _validator) {
+        super();
+        this._ref = _ref;
+        this._validator = _validator;
+    }
+    validate(content) {
+        return this._validator.validate(content);
+    }
+    getJSONSchema() {
+        return { $ref: this._ref };
+    }
+}
+function vWithJsonSchemaRef(ref, validator) {
+    return new UseRefSchemaValidator(ref, validator);
+}
+
+export { Optional, ValidatorBase, vBoolean, vObj, vOptionalProp, vString, vUndefined, vUnion, vWithJsonSchemaRef };

package/dist/workers/vb.contribution.js

@@ -0,0 +1,8 @@
+import { registerLanguage } from '../_.contribution.js';
+
+registerLanguage({
+  id: "vb",
+  extensions: [".vb"],
+  aliases: ["Visual Basic", "vb"],
+  loader: () => import('./vb.js')
+});