chrome-ai-bridge 1.0.3 → 1.0.5

package/build/node_modules/chrome-devtools-frontend/front_end/core/common/Base64.js

@@ -29,13 +29,31 @@ export function decode(input) {
     }
     return bytes;
 }
+/**
+ * Note: if input can be very large (larger than the max string size), callers should
+ * expect this to throw an error.
+ */
 export function encode(input) {
     return new Promise((resolve, reject) => {
         const reader = new FileReader();
-        reader.onerror = () => reject(new Error('failed to convert to base64'));
+        reader.onerror = () => reject(new Error('failed to convert to base64: internal error'));
         reader.onload = () => {
+            // The input was too large to encode as a string. The caller should anticipate
+            // this and use a workaround. See TimelinePanel.ts innerSaveToFile for an example.
+            // For more information, see crbug.com/436482118.
+            if (reader.result === '') {
+                reject(new Error('failed to convert to base64: input too large to encode as base64 string'));
+                return;
+            }
+            // This string can be very large, so take care to not double memory. `split`
+            // was used here before, which always results in new strings in V8. By using
+            // slice instead, we leverage the sliced string optimization in V8 and avoid
+            // doubling the memory requirement (even if temporarily: that is a potential
+            // source of OOM crashes given large enough input, such as is common with
+            // Performance traces).
             const blobAsUrl = reader.result;
-            const [, base64] = blobAsUrl.split(',', 2);
+            const index = blobAsUrl.indexOf(',');
+            const base64 = blobAsUrl.slice(index + 1);
             resolve(base64);
         };
         reader.readAsDataURL(new Blob([input]));

package/build/node_modules/chrome-devtools-frontend/front_end/core/common/Gzip.js

@@ -64,3 +64,14 @@ export function compressStream(stream) {
     const cs = new CompressionStream('gzip');
     return stream.pipeThrough(cs);
 }
+export function createMonitoredStream(stream, onProgress) {
+    let bytesRead = 0;
+    const progressTransformer = new TransformStream({
+        transform(chunk, controller) {
+            bytesRead += chunk.byteLength;
+            onProgress(bytesRead);
+            controller.enqueue(chunk);
+        }
+    });
+    return stream.pipeThrough(progressTransformer);
+}

package/build/node_modules/chrome-devtools-frontend/front_end/core/common/Object.js

@@ -57,7 +57,12 @@ export class ObjectWrapper {
         // new listeners.
         for (const listener of [...listeners]) {
             if (!listener.disposed) {
-                listener.listener.call(listener.thisObject, event);
+                try {
+                    listener.listener.call(listener.thisObject, event);
+                }
+                catch (err) {
+                    console.error(`Event listener for ${String(eventType)} throw an error:`, err);
+                }
             }
         }
     }

package/build/node_modules/chrome-devtools-frontend/front_end/core/common/ParsedURL.js

@@ -263,6 +263,9 @@ export class ParsedURL {
         return '';
     }
     static extractName(url) {
+        if (url.endsWith('/')) {
+            url = url.slice(0, -1);
+        }
         let index = url.lastIndexOf('/');
         const pathAndQuery = index !== -1 ? url.substr(index + 1) : url;
         index = pathAndQuery.indexOf('?');

package/build/node_modules/chrome-devtools-frontend/front_end/core/common/ResourceType.js

@@ -229,6 +229,12 @@ export class ResourceType {
         const regex = new RegExp('^application(.*json$|\/json\+.*)');
         return regex.test(contentType) ? 'application/json' : contentType;
     }
+    /**
+     * Checks whether the given MIME type represents JavaScript content.
+     */
+    static isJavaScriptMimeType(mimeType) {
+        return mimeType === 'application/javascript' || mimeType === 'text/javascript';
+    }
     /**
      * Adds suffixes iff the mimeType is 'text/javascript' to denote whether the JS is minified or from
      * a source map.

package/build/node_modules/chrome-devtools-frontend/front_end/core/common/Settings.js

@@ -162,18 +162,28 @@ export class Settings {
         return this.#registry;
     }
 }
-export const NOOP_STORAGE = {
-    register: () => { },
-    set: () => { },
-    get: () => Promise.resolve(''),
-    remove: () => { },
-    clear: () => { },
-};
+export class InMemoryStorage {
+    #store = new Map();
+    register(_setting) {
+    }
+    set(key, value) {
+        this.#store.set(key, value);
+    }
+    get(key) {
+        return this.#store.get(key);
+    }
+    remove(key) {
+        this.#store.delete(key);
+    }
+    clear() {
+        this.#store.clear();
+    }
+}
 export class SettingsStorage {
     object;
     backingStore;
     storagePrefix;
-    constructor(object, backingStore = NOOP_STORAGE, storagePrefix = '') {
+    constructor(object, backingStore = new InMemoryStorage(), storagePrefix = '') {
         this.object = object;
         this.backingStore = backingStore;
         this.storagePrefix = storagePrefix;

package/build/node_modules/chrome-devtools-frontend/front_end/core/host/InspectorFrontendHostStub.js

@@ -87,6 +87,9 @@ export class InspectorFrontendHostStub {
     setInjectedScriptForOrigin(_origin, _script) {
     }
     inspectedURLChanged(url) {
+        if (!('document' in globalThis)) {
+            return;
+        }
         document.title = i18nString(UIStrings.devtoolsS, { PH1: url.replace(/^https?:\/\//, '') });
     }
     copyText(text) {
@@ -297,9 +300,6 @@ export class InspectorFrontendHostStub {
             devToolsFlexibleLayout: {
                 verticalDrawerEnabled: true,
             },
-            devToolsStartingStyleDebugging: {
-                enabled: false,
-            },
         };
         if ('hostConfigForTesting' in globalThis) {
             const { hostConfigForTesting } = globalThis;

package/build/node_modules/chrome-devtools-frontend/front_end/core/host/ResourceLoader.js

@@ -169,7 +169,7 @@ async function fetchToString(url) {
 }
 function canBeRemoteFilePath(url) {
     try {
-        const urlObject = new URL(url);
+        const urlObject = new URL(new URL(url).toString()); // Normalize first.
         return urlObject.protocol === 'file:' && urlObject.host !== '';
     }
     catch {

package/build/node_modules/chrome-devtools-frontend/front_end/core/host/UserMetrics.js

@@ -225,6 +225,18 @@ export class UserMetrics {
     consoleInsightTeaserFirstChunkGenerated(timeInMilliseconds) {
         InspectorFrontendHostInstance.recordPerformanceHistogram('DevTools.Insights.TeaserFirstChunkGenerationTime', timeInMilliseconds);
     }
+    consoleInsightTeaserAbortedAfterFirstCharacter(timeInMilliseconds) {
+        InspectorFrontendHostInstance.recordPerformanceHistogram('DevTools.Insights.TeaserAfterFirstCharacterAbortionTime', timeInMilliseconds);
+    }
+    consoleInsightTeaserAbortedBeforeFirstCharacter(timeInMilliseconds) {
+        InspectorFrontendHostInstance.recordPerformanceHistogram('DevTools.Insights.TeaserBeforeFirstCharacterAbortionTime', timeInMilliseconds);
+    }
+    consoleInsightLongTeaserGenerated(timeInMilliseconds) {
+        InspectorFrontendHostInstance.recordPerformanceHistogram('DevTools.Insights.LongTeaserGenerationTime', timeInMilliseconds);
+    }
+    consoleInsightShortTeaserGenerated(timeInMilliseconds) {
+        InspectorFrontendHostInstance.recordPerformanceHistogram('DevTools.Insights.ShortTeaserGenerationTime', timeInMilliseconds);
+    }
 }
 /**
  * The numeric enum values are not necessarily continuous! It is possible that
@@ -436,7 +448,11 @@ export var Action;
     Action[Action["InsightTeaserGenerationErrored"] = 194] = "InsightTeaserGenerationErrored";
     Action[Action["AiCodeGenerationSuggestionDisplayed"] = 195] = "AiCodeGenerationSuggestionDisplayed";
     Action[Action["AiCodeGenerationSuggestionAccepted"] = 196] = "AiCodeGenerationSuggestionAccepted";
-    Action[Action["MAX_VALUE"] = 197] = "MAX_VALUE";
+    Action[Action["InsightTeaserModelDownloadStarted"] = 197] = "InsightTeaserModelDownloadStarted";
+    Action[Action["InsightTeaserModelDownloadCompleted"] = 198] = "InsightTeaserModelDownloadCompleted";
+    Action[Action["AiCodeGenerationError"] = 199] = "AiCodeGenerationError";
+    Action[Action["AiCodeGenerationRequestTriggered"] = 200] = "AiCodeGenerationRequestTriggered";
+    Action[Action["MAX_VALUE"] = 201] = "MAX_VALUE";
     /* eslint-enable @typescript-eslint/naming-convention */
 })(Action || (Action = {}));
 export var PanelCodes;

package/build/node_modules/chrome-devtools-frontend/front_end/core/platform/ArrayUtilities.js

@@ -197,3 +197,13 @@ export function nearestIndexFromEnd(arr, predicate) {
 export function arrayDoesNotContainNullOrUndefined(arr) {
     return !arr.includes(null) && !arr.includes(undefined);
 }
+export function assertArrayIsSorted(arr, compareFn) {
+    const comparator = compareFn || DEFAULT_COMPARATOR;
+    for (let i = 0; i < arr.length - 1; i++) {
+        const current = arr[i];
+        const next = arr[i + 1];
+        if (comparator(current, next) > 0) {
+            throw new Error(`Array is not sorted at index ${i}: ${JSON.stringify(current)} > ${JSON.stringify(next)}`);
+        }
+    }
+}

package/build/node_modules/chrome-devtools-frontend/front_end/core/platform/StringUtilities.js

@@ -325,26 +325,77 @@ export const compare = (a, b) => {
     }
     return 0;
 };
+/** Returns a string that has no more than maxLength characters. Actual graphemes are used, not bytes. */
 export const trimMiddle = (str, maxLength) => {
+    // Early return for the case where there are fewer bytes than the character limit.
     if (str.length <= maxLength) {
-        return String(str);
-    }
-    let leftHalf = maxLength >> 1;
-    let rightHalf = maxLength - leftHalf - 1;
-    if (str.codePointAt(str.length - rightHalf - 1) >= 0x10000) {
-        --rightHalf;
-        ++leftHalf;
+        return str;
+    }
+    const segmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+    // If the max length is so small it can't fit the ellipsis, just return the ellipsis.
+    const ellipsis = '…';
+    const ellipsisLength = 1;
+    if (maxLength <= ellipsisLength) {
+        return ellipsis;
+    }
+    // Calculate how many graphemes to keep on each side.
+    const freeSpace = maxLength - ellipsisLength;
+    const leftCount = Math.ceil(freeSpace / 2);
+    const rightCount = Math.floor(freeSpace / 2);
+    let currentGraphemeCount = 0;
+    let leftEndIndex = 0;
+    // Sliding Window Buffer
+    // We need to know where the "Right Half" starts. Since we can't iterate backwards,
+    // we keep track of the start index of the last N graphemes we've seen.
+    const rightIndexBuffer = [];
+    // This function would be significantly simpler if we created an array of all the
+    // segments upfront, but could result in poor performance for large input strings.
+    for (const { segment, index } of segmenter.segment(str)) {
+        currentGraphemeCount++;
+        // Mark the byte index where the "Left Half" ends
+        if (currentGraphemeCount === leftCount) {
+            leftEndIndex = index + segment.length;
+        }
+        // Maintain the buffer for the "Right Half"
+        if (rightCount > 0) {
+            rightIndexBuffer.push(index);
+            if (rightIndexBuffer.length > rightCount) {
+                rightIndexBuffer.shift(); // Remove the oldest index to keep buffer size constant.
+            }
+        }
     }
-    if (leftHalf > 0 && str.codePointAt(leftHalf - 1) >= 0x10000) {
-        --leftHalf;
+    // If the total grapheme count didn't exceed the limit, return the original string.
+    if (currentGraphemeCount <= maxLength) {
+        return str;
     }
-    return str.substr(0, leftHalf) + '…' + str.substr(str.length - rightHalf, rightHalf);
+    // The first item in our buffer is exactly 'rightCount' graphemes away from the end.
+    const rightStartIndex = rightCount > 0 ? rightIndexBuffer[0] : str.length;
+    return str.slice(0, leftEndIndex) + ellipsis + str.slice(rightStartIndex);
 };
+/** Returns a string that has no more than maxLength characters. Actual graphemes are used, not bytes. */
 export const trimEndWithMaxLength = (str, maxLength) => {
+    // Early return for the case where there are fewer bytes than the character limit.
     if (str.length <= maxLength) {
-        return String(str);
+        return str;
+    }
+    const ellipsis = '…';
+    const ellipsisLength = 1;
+    const segmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+    const iterator = segmenter.segment(str)[Symbol.iterator]();
+    let lastSegmentIndex = 0;
+    for (let i = 0; i <= maxLength - ellipsisLength; i++) {
+        const result = iterator.next();
+        if (result.done) {
+            return str;
+        }
+        lastSegmentIndex = result.value.index;
+    }
+    for (let i = 0; i < ellipsisLength; i++) {
+        if (iterator.next().done) {
+            return str;
+        }
     }
-    return str.substr(0, maxLength - 1) + '…';
+    return str.slice(0, lastSegmentIndex) + ellipsis;
 };
 export const escapeForRegExp = (str) => {
     return escapeCharacters(str, SPECIAL_REGEX_CHARACTERS);

package/build/node_modules/chrome-devtools-frontend/front_end/core/protocol_client/CDPConnection.js

@@ -14,4 +14,5 @@ export var CDPErrorStatus;
     CDPErrorStatus[CDPErrorStatus["SERVER_ERROR"] = -32000] = "SERVER_ERROR";
     CDPErrorStatus[CDPErrorStatus["SESSION_NOT_FOUND"] = -32001] = "SESSION_NOT_FOUND";
     CDPErrorStatus[CDPErrorStatus["DEVTOOLS_STUB_ERROR"] = -32015] = "DEVTOOLS_STUB_ERROR";
+    CDPErrorStatus[CDPErrorStatus["DEVTOOLS_REHYDRATION_ERROR"] = -32016] = "DEVTOOLS_REHYDRATION_ERROR";
 })(CDPErrorStatus || (CDPErrorStatus = {}));

package/build/node_modules/chrome-devtools-frontend/front_end/core/protocol_client/InspectorBackend.js

@@ -444,6 +444,7 @@ export class TargetBase {
 }
 /** These are not logged as console.error */
 const IGNORED_ERRORS = new Set([
+    CDPErrorStatus.DEVTOOLS_REHYDRATION_ERROR,
     CDPErrorStatus.DEVTOOLS_STUB_ERROR,
     CDPErrorStatus.SERVER_ERROR,
     CDPErrorStatus.SESSION_NOT_FOUND,
@@ -491,7 +492,9 @@ class AgentPrototype {
             if ('result' in response) {
                 return { ...response.result, getError: () => undefined };
             }
-            return { getError: () => undefined };
+            return {
+                getError: () => `Command ${method} returned neither result nor an error, params: ${JSON.stringify(request, undefined, 2)}`,
+            };
         });
     }
 }

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/CSSMatchedStyles.js

@@ -474,10 +474,10 @@ export class CSSMatchedStyles {
         // Now that we've built the arrays of NodeCascades for each pseudo type, convert them into
         // DOMInheritanceCascades.
         for (const [pseudoType, nodeCascade] of pseudoCascades.entries()) {
-            pseudoInheritanceCascades.set(pseudoType, new DOMInheritanceCascade(this, nodeCascade, this.#registeredProperties));
+            pseudoInheritanceCascades.set(pseudoType, new DOMInheritanceCascade(this, nodeCascade, this.#registeredProperties, this.#mainDOMCascade));
         }
         for (const [highlightName, nodeCascade] of customHighlightPseudoCascades.entries()) {
-            customHighlightPseudoInheritanceCascades.set(highlightName, new DOMInheritanceCascade(this, nodeCascade, this.#registeredProperties));
+            customHighlightPseudoInheritanceCascades.set(highlightName, new DOMInheritanceCascade(this, nodeCascade, this.#registeredProperties, this.#mainDOMCascade));
         }
         return [pseudoInheritanceCascades, customHighlightPseudoInheritanceCascades];
     }
@@ -730,18 +730,18 @@ export class CSSMatchedStyles {
     }
 }
 class NodeCascade {
+    isHighlightPseudoCascade;
     #matchedStyles;
     styles;
     #isInherited;
-    #isHighlightPseudoCascade;
     propertiesState = new Map();
     activeProperties = new Map();
     #node;
     constructor(matchedStyles, styles, node, isInherited, isHighlightPseudoCascade = false) {
+        this.isHighlightPseudoCascade = isHighlightPseudoCascade;
         this.#matchedStyles = matchedStyles;
         this.styles = styles;
         this.#isInherited = isInherited;
-        this.#isHighlightPseudoCascade = isHighlightPseudoCascade;
         this.#node = node;
     }
     computeActiveProperties() {
@@ -760,9 +760,17 @@ class NodeCascade {
             for (const property of style.allProperties()) {
                 // Do not pick non-inherited properties from inherited styles.
                 const metadata = cssMetadata();
-                // All properties are inherited for highlight pseudos.
-                if (this.#isInherited && !this.#isHighlightPseudoCascade && !metadata.isPropertyInherited(property.name)) {
-                    continue;
+                if (this.#isInherited) {
+                    if (this.isHighlightPseudoCascade) {
+                        // All properties are inherited for highlight pseudos, but custom
+                        // variables do not come from the inherited pseudo elements.
+                        if (property.name.startsWith('--')) {
+                            continue;
+                        }
+                    }
+                    else if (!metadata.isPropertyInherited(property.name)) {
+                        continue;
+                    }
                 }
                 // When a property does not have a range in an otherwise ranged CSSStyleDeclaration,
                 // we consider it as a non-leading property (see computeLeadingProperties()), and most
@@ -920,13 +928,24 @@ class DOMInheritanceCascade {
     #nodeCascades;
     #registeredProperties;
     #matchedStyles;
-    constructor(matchedStyles, nodeCascades, registeredProperties) {
+    #fallbackCascade = null;
+    #styles = [];
+    constructor(matchedStyles, nodeCascades, registeredProperties, fallbackCascade = null) {
         this.#nodeCascades = nodeCascades;
         this.#matchedStyles = matchedStyles;
         this.#registeredProperties = registeredProperties;
+        this.#fallbackCascade = fallbackCascade;
         for (const nodeCascade of nodeCascades) {
             for (const style of nodeCascade.styles) {
                 this.#styleToNodeCascade.set(style, nodeCascade);
+                this.#styles.push(style);
+            }
+        }
+        if (fallbackCascade) {
+            for (const [style, nodeCascade] of fallbackCascade.#styleToNodeCascade) {
+                if (!this.#styles.includes(style)) {
+                    this.#styleToNodeCascade.set(style, nodeCascade);
+                }
             }
         }
     }
@@ -981,6 +1000,9 @@ class DOMInheritanceCascade {
                 }
             }
         }
+        if (this.#fallbackCascade && (!nodeCascade.isHighlightPseudoCascade || property.name.startsWith('--'))) {
+            return this.#fallbackCascade.resolveProperty(property.name, property.ownerStyle);
+        }
         return null;
     }
     #findPropertyInParentCascadeIfInherited(property) {
@@ -1224,7 +1246,7 @@ class DOMInheritanceCascade {
         }
     }
     styles() {
-        return Array.from(this.#styleToNodeCascade.keys());
+        return this.#styles;
     }
     propertyState(property) {
         this.ensureInitialized();
@@ -1289,6 +1311,19 @@ class DOMInheritanceCascade {
             const initialValue = rule.initialValue();
             accumulatedCSSVariables.set(rule.propertyName(), initialValue !== null ? { value: initialValue, declaration: new CSSValueSource(rule) } : null);
         }
+        if (this.#fallbackCascade) {
+            this.#fallbackCascade.ensureInitialized();
+            for (const [cascade, available] of this.#fallbackCascade.#availableCSSVariables) {
+                this.#availableCSSVariables.set(cascade, available);
+            }
+            for (const [cascade, computed] of this.#fallbackCascade.#computedCSSVariables) {
+                this.#computedCSSVariables.set(cascade, computed);
+            }
+            for (const [key, value] of this.#fallbackCascade.#availableCSSVariables.get(this.#fallbackCascade.#nodeCascades[0]) ??
+                []) {
+                accumulatedCSSVariables.set(key, value);
+            }
+        }
         for (let i = this.#nodeCascades.length - 1; i >= 0; --i) {
             const nodeCascade = this.#nodeCascades[i];
             const variableNames = [];

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/CSSMetadata.js

@@ -526,7 +526,7 @@ const extraPropertyValues = new Map([
     ['background-repeat', new Set(['repeat', 'repeat-x', 'repeat-y', 'no-repeat', 'space', 'round'])],
     ['content', new Set(['normal', 'close-quote', 'no-close-quote', 'no-open-quote', 'open-quote'])],
     ['baseline-shift', new Set(['baseline'])],
-    ['max-height', new Set(['min-content', 'max-content', '-webkit-fill-available', 'fit-content'])],
+    ['max-height', new Set(['min-content', 'max-content', '-webkit-fill-available', 'fit-content', 'stretch'])],
     ['color', new Set(['black'])],
     ['background-color', new Set(['white'])],
     ['box-shadow', new Set(['inset'])],
@@ -600,7 +600,7 @@ const extraPropertyValues = new Map([
         ]),
     ],
     ['zoom', new Set(['normal'])],
-    ['max-width', new Set(['min-content', 'max-content', '-webkit-fill-available', 'fit-content'])],
+    ['max-width', new Set(['min-content', 'max-content', '-webkit-fill-available', 'fit-content', 'stretch'])],
     ['-webkit-font-smoothing', new Set(['antialiased', 'subpixel-antialiased'])],
     [
         'border',
@@ -991,7 +991,7 @@ const extraPropertyValues = new Map([
         ]),
     ],
     ['flex-flow', new Set(['nowrap', 'row', 'row-reverse', 'column', 'column-reverse', 'wrap', 'wrap-reverse'])],
-    ['height', new Set(['-webkit-fill-available'])],
+    ['height', new Set(['-webkit-fill-available', 'stretch'])],
     ['inline-size', new Set(['-webkit-fill-available', 'min-content', 'max-content', 'fit-content'])],
     [
         'list-style',
@@ -1058,9 +1058,9 @@ const extraPropertyValues = new Map([
     ['max-block-size', new Set(['-webkit-fill-available', 'min-content', 'max-content', 'fit-content'])],
     ['max-inline-size', new Set(['-webkit-fill-available', 'min-content', 'max-content', 'fit-content'])],
     ['min-block-size', new Set(['-webkit-fill-available', 'min-content', 'max-content', 'fit-content'])],
-    ['min-height', new Set(['-webkit-fill-available', 'min-content', 'max-content', 'fit-content'])],
+    ['min-height', new Set(['-webkit-fill-available', 'min-content', 'max-content', 'fit-content', 'stretch'])],
     ['min-inline-size', new Set(['-webkit-fill-available', 'min-content', 'max-content', 'fit-content'])],
-    ['min-width', new Set(['-webkit-fill-available', 'min-content', 'max-content', 'fit-content'])],
+    ['min-width', new Set(['-webkit-fill-available', 'min-content', 'max-content', 'fit-content', 'stretch'])],
     ['object-position', new Set(['top', 'bottom', 'left', 'right', 'center'])],
     ['shape-outside', new Set(['border-box', 'content-box', 'padding-box', 'margin-box'])],
     [
@@ -1222,7 +1222,7 @@ const extraPropertyValues = new Map([
     ['-webkit-text-stroke-width', new Set(['medium', 'thick', 'thin'])],
     ['-webkit-transform-origin-x', new Set(['left', 'right', 'center'])],
     ['-webkit-transform-origin-y', new Set(['top', 'bottom', 'center'])],
-    ['width', new Set(['-webkit-fill-available'])],
+    ['width', new Set(['-webkit-fill-available', 'stretch'])],
     ['contain-intrinsic-width', new Set(['auto none', 'auto 100px'])],
     ['contain-intrinsic-height', new Set(['auto none', 'auto 100px'])],
     ['contain-intrinsic-size', new Set(['auto none', 'auto 100px'])],

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/CSSModel.js

@@ -317,7 +317,7 @@ export class CSSModel extends SDKModel {
             isGrid,
             isSubgrid,
             isGridLanes,
-            isContainer,
+            containerType: isContainer ? containerType : undefined,
             hasScroll,
         };
     }