claude-flow-novice 2.3.1 → 2.3.3

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/basic-languages/freemarker2/freemarker2.contribution.js

@@ -0,0 +1,101 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.45.0(5e5af013f8d295555a7210df0d5f2cea0bf5dd56)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+
+// src/basic-languages/freemarker2/freemarker2.contribution.ts
+import { registerLanguage } from "../_.contribution.js";
+registerLanguage({
+  id: "freemarker2",
+  extensions: [".ftl", ".ftlh", ".ftlx"],
+  aliases: ["FreeMarker2", "Apache FreeMarker2"],
+  loader: () => {
+    if (false) {
+      return new Promise((resolve, reject) => {
+        __require(["vs/basic-languages/freemarker2/freemarker2"], resolve, reject);
+      }).then((m) => m.TagAngleInterpolationDollar);
+    } else {
+      return import("./freemarker2.js").then((m) => m.TagAutoInterpolationDollar);
+    }
+  }
+});
+registerLanguage({
+  id: "freemarker2.tag-angle.interpolation-dollar",
+  aliases: ["FreeMarker2 (Angle/Dollar)", "Apache FreeMarker2 (Angle/Dollar)"],
+  loader: () => {
+    if (false) {
+      return new Promise((resolve, reject) => {
+        __require(["vs/basic-languages/freemarker2/freemarker2"], resolve, reject);
+      }).then((m) => m.TagAngleInterpolationDollar);
+    } else {
+      return import("./freemarker2.js").then((m) => m.TagAngleInterpolationDollar);
+    }
+  }
+});
+registerLanguage({
+  id: "freemarker2.tag-bracket.interpolation-dollar",
+  aliases: ["FreeMarker2 (Bracket/Dollar)", "Apache FreeMarker2 (Bracket/Dollar)"],
+  loader: () => {
+    if (false) {
+      return new Promise((resolve, reject) => {
+        __require(["vs/basic-languages/freemarker2/freemarker2"], resolve, reject);
+      }).then((m) => m.TagBracketInterpolationDollar);
+    } else {
+      return import("./freemarker2.js").then((m) => m.TagBracketInterpolationDollar);
+    }
+  }
+});
+registerLanguage({
+  id: "freemarker2.tag-angle.interpolation-bracket",
+  aliases: ["FreeMarker2 (Angle/Bracket)", "Apache FreeMarker2 (Angle/Bracket)"],
+  loader: () => {
+    if (false) {
+      return new Promise((resolve, reject) => {
+        __require(["vs/basic-languages/freemarker2/freemarker2"], resolve, reject);
+      }).then((m) => m.TagAngleInterpolationBracket);
+    } else {
+      return import("./freemarker2.js").then((m) => m.TagAngleInterpolationBracket);
+    }
+  }
+});
+registerLanguage({
+  id: "freemarker2.tag-bracket.interpolation-bracket",
+  aliases: ["FreeMarker2 (Bracket/Bracket)", "Apache FreeMarker2 (Bracket/Bracket)"],
+  loader: () => {
+    if (false) {
+      return new Promise((resolve, reject) => {
+        __require(["vs/basic-languages/freemarker2/freemarker2"], resolve, reject);
+      }).then((m) => m.TagBracketInterpolationBracket);
+    } else {
+      return import("./freemarker2.js").then((m) => m.TagBracketInterpolationBracket);
+    }
+  }
+});
+registerLanguage({
+  id: "freemarker2.tag-auto.interpolation-dollar",
+  aliases: ["FreeMarker2 (Auto/Dollar)", "Apache FreeMarker2 (Auto/Dollar)"],
+  loader: () => {
+    if (false) {
+      return new Promise((resolve, reject) => {
+        __require(["vs/basic-languages/freemarker2/freemarker2"], resolve, reject);
+      }).then((m) => m.TagAutoInterpolationDollar);
+    } else {
+      return import("./freemarker2.js").then((m) => m.TagAutoInterpolationDollar);
+    }
+  }
+});
+registerLanguage({
+  id: "freemarker2.tag-auto.interpolation-bracket",
+  aliases: ["FreeMarker2 (Auto/Bracket)", "Apache FreeMarker2 (Auto/Bracket)"],
+  loader: () => {
+    if (false) {
+      return new Promise((resolve, reject) => {
+        __require(["vs/basic-languages/freemarker2/freemarker2"], resolve, reject);
+      }).then((m) => m.TagAutoInterpolationBracket);
+    } else {
+      return import("./freemarker2.js").then((m) => m.TagAutoInterpolationBracket);
+    }
+  }
+});

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/editor/browser/config/charWidthReader.js

@@ -0,0 +1,102 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { $window } from '../../../base/browser/window.js';
+import { applyFontInfo } from './domFontInfo.js';
+export class CharWidthRequest {
+    constructor(chr, type) {
+        this.chr = chr;
+        this.type = type;
+        this.width = 0;
+    }
+    fulfill(width) {
+        this.width = width;
+    }
+}
+class DomCharWidthReader {
+    constructor(bareFontInfo, requests) {
+        this._bareFontInfo = bareFontInfo;
+        this._requests = requests;
+        this._container = null;
+        this._testElements = null;
+    }
+    read() {
+        // Create a test container with all these test elements
+        this._createDomElements();
+        // Add the container to the DOM
+        $window.document.body.appendChild(this._container);
+        // Read character widths
+        this._readFromDomElements();
+        // Remove the container from the DOM
+        $window.document.body.removeChild(this._container);
+        this._container = null;
+        this._testElements = null;
+    }
+    _createDomElements() {
+        const container = document.createElement('div');
+        container.style.position = 'absolute';
+        container.style.top = '-50000px';
+        container.style.width = '50000px';
+        const regularDomNode = document.createElement('div');
+        applyFontInfo(regularDomNode, this._bareFontInfo);
+        container.appendChild(regularDomNode);
+        const boldDomNode = document.createElement('div');
+        applyFontInfo(boldDomNode, this._bareFontInfo);
+        boldDomNode.style.fontWeight = 'bold';
+        container.appendChild(boldDomNode);
+        const italicDomNode = document.createElement('div');
+        applyFontInfo(italicDomNode, this._bareFontInfo);
+        italicDomNode.style.fontStyle = 'italic';
+        container.appendChild(italicDomNode);
+        const testElements = [];
+        for (const request of this._requests) {
+            let parent;
+            if (request.type === 0 /* CharWidthRequestType.Regular */) {
+                parent = regularDomNode;
+            }
+            if (request.type === 2 /* CharWidthRequestType.Bold */) {
+                parent = boldDomNode;
+            }
+            if (request.type === 1 /* CharWidthRequestType.Italic */) {
+                parent = italicDomNode;
+            }
+            parent.appendChild(document.createElement('br'));
+            const testElement = document.createElement('span');
+            DomCharWidthReader._render(testElement, request);
+            parent.appendChild(testElement);
+            testElements.push(testElement);
+        }
+        this._container = container;
+        this._testElements = testElements;
+    }
+    static _render(testElement, request) {
+        if (request.chr === ' ') {
+            let htmlString = '\u00a0';
+            // Repeat character 256 (2^8) times
+            for (let i = 0; i < 8; i++) {
+                htmlString += htmlString;
+            }
+            testElement.innerText = htmlString;
+        }
+        else {
+            let testString = request.chr;
+            // Repeat character 256 (2^8) times
+            for (let i = 0; i < 8; i++) {
+                testString += testString;
+            }
+            testElement.textContent = testString;
+        }
+    }
+    _readFromDomElements() {
+        for (let i = 0, len = this._requests.length; i < len; i++) {
+            const request = this._requests[i];
+            const testElement = this._testElements[i];
+            request.fulfill(testElement.offsetWidth / 256);
+        }
+    }
+}
+export function readCharWidths(bareFontInfo, requests) {
+    const reader = new DomCharWidthReader(bareFontInfo, requests);
+    reader.read();
+}

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/editor/browser/config/domFontInfo.js

@@ -0,0 +1,25 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { FastDomNode } from '../../../base/browser/fastDomNode.js';
+export function applyFontInfo(domNode, fontInfo) {
+    if (domNode instanceof FastDomNode) {
+        domNode.setFontFamily(fontInfo.getMassagedFontFamily());
+        domNode.setFontWeight(fontInfo.fontWeight);
+        domNode.setFontSize(fontInfo.fontSize);
+        domNode.setFontFeatureSettings(fontInfo.fontFeatureSettings);
+        domNode.setFontVariationSettings(fontInfo.fontVariationSettings);
+        domNode.setLineHeight(fontInfo.lineHeight);
+        domNode.setLetterSpacing(fontInfo.letterSpacing);
+    }
+    else {
+        domNode.style.fontFamily = fontInfo.getMassagedFontFamily();
+        domNode.style.fontWeight = fontInfo.fontWeight;
+        domNode.style.fontSize = fontInfo.fontSize + 'px';
+        domNode.style.fontFeatureSettings = fontInfo.fontFeatureSettings;
+        domNode.style.fontVariationSettings = fontInfo.fontVariationSettings;
+        domNode.style.lineHeight = fontInfo.lineHeight + 'px';
+        domNode.style.letterSpacing = fontInfo.letterSpacing + 'px';
+    }
+}

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/editor/browser/config/editorConfiguration.js

@@ -0,0 +1,280 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import * as browser from '../../../base/browser/browser.js';
+import * as arrays from '../../../base/common/arrays.js';
+import { Emitter } from '../../../base/common/event.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import * as objects from '../../../base/common/objects.js';
+import * as platform from '../../../base/common/platform.js';
+import { ElementSizeObserver } from './elementSizeObserver.js';
+import { FontMeasurements } from './fontMeasurements.js';
+import { migrateOptions } from './migrateOptions.js';
+import { TabFocus } from './tabFocus.js';
+import { ComputeOptionsMemory, ConfigurationChangedEvent, editorOptionsRegistry } from '../../common/config/editorOptions.js';
+import { EditorZoom } from '../../common/config/editorZoom.js';
+import { BareFontInfo } from '../../common/config/fontInfo.js';
+import { IAccessibilityService } from '../../../platform/accessibility/common/accessibility.js';
+let EditorConfiguration = class EditorConfiguration extends Disposable {
+    constructor(isSimpleWidget, options, container, _accessibilityService) {
+        super();
+        this._accessibilityService = _accessibilityService;
+        this._onDidChange = this._register(new Emitter());
+        this.onDidChange = this._onDidChange.event;
+        this._onDidChangeFast = this._register(new Emitter());
+        this.onDidChangeFast = this._onDidChangeFast.event;
+        this._isDominatedByLongLines = false;
+        this._viewLineCount = 1;
+        this._lineNumbersDigitCount = 1;
+        this._reservedHeight = 0;
+        this._glyphMarginDecorationLaneCount = 1;
+        this._computeOptionsMemory = new ComputeOptionsMemory();
+        this.isSimpleWidget = isSimpleWidget;
+        this._containerObserver = this._register(new ElementSizeObserver(container, options.dimension));
+        this._rawOptions = deepCloneAndMigrateOptions(options);
+        this._validatedOptions = EditorOptionsUtil.validateOptions(this._rawOptions);
+        this.options = this._computeOptions();
+        if (this.options.get(13 /* EditorOption.automaticLayout */)) {
+            this._containerObserver.startObserving();
+        }
+        this._register(EditorZoom.onDidChangeZoomLevel(() => this._recomputeOptions()));
+        this._register(TabFocus.onDidChangeTabFocus(() => this._recomputeOptions()));
+        this._register(this._containerObserver.onDidChange(() => this._recomputeOptions()));
+        this._register(FontMeasurements.onDidChange(() => this._recomputeOptions()));
+        this._register(browser.PixelRatio.onDidChange(() => this._recomputeOptions()));
+        this._register(this._accessibilityService.onDidChangeScreenReaderOptimized(() => this._recomputeOptions()));
+    }
+    _recomputeOptions() {
+        const newOptions = this._computeOptions();
+        const changeEvent = EditorOptionsUtil.checkEquals(this.options, newOptions);
+        if (changeEvent === null) {
+            // nothing changed!
+            return;
+        }
+        this.options = newOptions;
+        this._onDidChangeFast.fire(changeEvent);
+        this._onDidChange.fire(changeEvent);
+    }
+    _computeOptions() {
+        const partialEnv = this._readEnvConfiguration();
+        const bareFontInfo = BareFontInfo.createFromValidatedSettings(this._validatedOptions, partialEnv.pixelRatio, this.isSimpleWidget);
+        const fontInfo = this._readFontInfo(bareFontInfo);
+        const env = {
+            memory: this._computeOptionsMemory,
+            outerWidth: partialEnv.outerWidth,
+            outerHeight: partialEnv.outerHeight - this._reservedHeight,
+            fontInfo: fontInfo,
+            extraEditorClassName: partialEnv.extraEditorClassName,
+            isDominatedByLongLines: this._isDominatedByLongLines,
+            viewLineCount: this._viewLineCount,
+            lineNumbersDigitCount: this._lineNumbersDigitCount,
+            emptySelectionClipboard: partialEnv.emptySelectionClipboard,
+            pixelRatio: partialEnv.pixelRatio,
+            tabFocusMode: TabFocus.getTabFocusMode(),
+            accessibilitySupport: partialEnv.accessibilitySupport,
+            glyphMarginDecorationLaneCount: this._glyphMarginDecorationLaneCount
+        };
+        return EditorOptionsUtil.computeOptions(this._validatedOptions, env);
+    }
+    _readEnvConfiguration() {
+        return {
+            extraEditorClassName: getExtraEditorClassName(),
+            outerWidth: this._containerObserver.getWidth(),
+            outerHeight: this._containerObserver.getHeight(),
+            emptySelectionClipboard: browser.isWebKit || browser.isFirefox,
+            pixelRatio: browser.PixelRatio.value,
+            accessibilitySupport: (this._accessibilityService.isScreenReaderOptimized()
+                ? 2 /* AccessibilitySupport.Enabled */
+                : this._accessibilityService.getAccessibilitySupport())
+        };
+    }
+    _readFontInfo(bareFontInfo) {
+        return FontMeasurements.readFontInfo(bareFontInfo);
+    }
+    getRawOptions() {
+        return this._rawOptions;
+    }
+    updateOptions(_newOptions) {
+        const newOptions = deepCloneAndMigrateOptions(_newOptions);
+        const didChange = EditorOptionsUtil.applyUpdate(this._rawOptions, newOptions);
+        if (!didChange) {
+            return;
+        }
+        this._validatedOptions = EditorOptionsUtil.validateOptions(this._rawOptions);
+        this._recomputeOptions();
+    }
+    observeContainer(dimension) {
+        this._containerObserver.observe(dimension);
+    }
+    setIsDominatedByLongLines(isDominatedByLongLines) {
+        if (this._isDominatedByLongLines === isDominatedByLongLines) {
+            return;
+        }
+        this._isDominatedByLongLines = isDominatedByLongLines;
+        this._recomputeOptions();
+    }
+    setModelLineCount(modelLineCount) {
+        const lineNumbersDigitCount = digitCount(modelLineCount);
+        if (this._lineNumbersDigitCount === lineNumbersDigitCount) {
+            return;
+        }
+        this._lineNumbersDigitCount = lineNumbersDigitCount;
+        this._recomputeOptions();
+    }
+    setViewLineCount(viewLineCount) {
+        if (this._viewLineCount === viewLineCount) {
+            return;
+        }
+        this._viewLineCount = viewLineCount;
+        this._recomputeOptions();
+    }
+    setReservedHeight(reservedHeight) {
+        if (this._reservedHeight === reservedHeight) {
+            return;
+        }
+        this._reservedHeight = reservedHeight;
+        this._recomputeOptions();
+    }
+    setGlyphMarginDecorationLaneCount(decorationLaneCount) {
+        if (this._glyphMarginDecorationLaneCount === decorationLaneCount) {
+            return;
+        }
+        this._glyphMarginDecorationLaneCount = decorationLaneCount;
+        this._recomputeOptions();
+    }
+};
+EditorConfiguration = __decorate([
+    __param(3, IAccessibilityService)
+], EditorConfiguration);
+export { EditorConfiguration };
+function digitCount(n) {
+    let r = 0;
+    while (n) {
+        n = Math.floor(n / 10);
+        r++;
+    }
+    return r ? r : 1;
+}
+function getExtraEditorClassName() {
+    let extra = '';
+    if (!browser.isSafari && !browser.isWebkitWebView) {
+        // Use user-select: none in all browsers except Safari and native macOS WebView
+        extra += 'no-user-select ';
+    }
+    if (browser.isSafari) {
+        // See https://github.com/microsoft/vscode/issues/108822
+        extra += 'no-minimap-shadow ';
+        extra += 'enable-user-select ';
+    }
+    if (platform.isMacintosh) {
+        extra += 'mac ';
+    }
+    return extra;
+}
+class ValidatedEditorOptions {
+    constructor() {
+        this._values = [];
+    }
+    _read(option) {
+        return this._values[option];
+    }
+    get(id) {
+        return this._values[id];
+    }
+    _write(option, value) {
+        this._values[option] = value;
+    }
+}
+export 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) ? arrays.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);
+    }
+    /**
+     * Returns true if something changed.
+     * Modifies `options`.
+    */
+    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;
+    }
+}
+function deepCloneAndMigrateOptions(_options) {
+    const options = objects.deepClone(_options);
+    migrateOptions(options);
+    return options;
+}

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/editor/browser/config/elementSizeObserver.js

@@ -0,0 +1,99 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { Emitter } from '../../../base/common/event.js';
+import { getWindow, scheduleAtNextAnimationFrame } from '../../../base/browser/dom.js';
+export class ElementSizeObserver extends Disposable {
+    constructor(referenceDomElement, dimension) {
+        super();
+        this._onDidChange = this._register(new Emitter());
+        this.onDidChange = this._onDidChange.event;
+        this._referenceDomElement = referenceDomElement;
+        this._width = -1;
+        this._height = -1;
+        this._resizeObserver = null;
+        this.measureReferenceDomElement(false, dimension);
+    }
+    dispose() {
+        this.stopObserving();
+        super.dispose();
+    }
+    getWidth() {
+        return this._width;
+    }
+    getHeight() {
+        return this._height;
+    }
+    startObserving() {
+        if (!this._resizeObserver && this._referenceDomElement) {
+            // We want to react to the resize observer only once per animation frame
+            // The first time the resize observer fires, we will react to it immediately.
+            // Otherwise we will postpone to the next animation frame.
+            // We'll use `observeContentRect` to store the content rect we received.
+            let observeContentRect = null;
+            const observeNow = () => {
+                if (observeContentRect) {
+                    this.observe({ width: observeContentRect.width, height: observeContentRect.height });
+                }
+                else {
+                    this.observe();
+                }
+            };
+            let shouldObserve = false;
+            let alreadyObservedThisAnimationFrame = false;
+            const update = () => {
+                if (shouldObserve && !alreadyObservedThisAnimationFrame) {
+                    try {
+                        shouldObserve = false;
+                        alreadyObservedThisAnimationFrame = true;
+                        observeNow();
+                    }
+                    finally {
+                        scheduleAtNextAnimationFrame(getWindow(this._referenceDomElement), () => {
+                            alreadyObservedThisAnimationFrame = false;
+                            update();
+                        });
+                    }
+                }
+            };
+            this._resizeObserver = new ResizeObserver((entries) => {
+                observeContentRect = (entries && entries[0] && entries[0].contentRect ? entries[0].contentRect : null);
+                shouldObserve = true;
+                update();
+            });
+            this._resizeObserver.observe(this._referenceDomElement);
+        }
+    }
+    stopObserving() {
+        if (this._resizeObserver) {
+            this._resizeObserver.disconnect();
+            this._resizeObserver = null;
+        }
+    }
+    observe(dimension) {
+        this.measureReferenceDomElement(true, dimension);
+    }
+    measureReferenceDomElement(emitEvent, dimension) {
+        let observedWidth = 0;
+        let observedHeight = 0;
+        if (dimension) {
+            observedWidth = dimension.width;
+            observedHeight = dimension.height;
+        }
+        else if (this._referenceDomElement) {
+            observedWidth = this._referenceDomElement.clientWidth;
+            observedHeight = this._referenceDomElement.clientHeight;
+        }
+        observedWidth = Math.max(5, observedWidth);
+        observedHeight = Math.max(5, observedHeight);
+        if (this._width !== observedWidth || this._height !== observedHeight) {
+            this._width = observedWidth;
+            this._height = observedHeight;
+            if (emitEvent) {
+                this._onDidChange.fire();
+            }
+        }
+    }
+}