css-variable-lsp 1.0.0 → 1.0.1

package/client/node_modules/vscode-languageclient/lib/common/utils/async.js

@@ -1,276 +0,0 @@
-"use strict";
-/* --------------------------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License. See License.txt in the project root for license information.
- * ------------------------------------------------------------------------------------------ */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.forEach = exports.mapAsync = exports.map = exports.clearTestMode = exports.setTestMode = exports.Semaphore = exports.Delayer = void 0;
-const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
-class Delayer {
-    constructor(defaultDelay) {
-        this.defaultDelay = defaultDelay;
-        this.timeout = undefined;
-        this.completionPromise = undefined;
-        this.onSuccess = undefined;
-        this.task = undefined;
-    }
-    trigger(task, delay = this.defaultDelay) {
-        this.task = task;
-        if (delay >= 0) {
-            this.cancelTimeout();
-        }
-        if (!this.completionPromise) {
-            this.completionPromise = new Promise((resolve) => {
-                this.onSuccess = resolve;
-            }).then(() => {
-                this.completionPromise = undefined;
-                this.onSuccess = undefined;
-                var result = this.task();
-                this.task = undefined;
-                return result;
-            });
-        }
-        if (delay >= 0 || this.timeout === void 0) {
-            this.timeout = (0, vscode_languageserver_protocol_1.RAL)().timer.setTimeout(() => {
-                this.timeout = undefined;
-                this.onSuccess(undefined);
-            }, delay >= 0 ? delay : this.defaultDelay);
-        }
-        return this.completionPromise;
-    }
-    forceDelivery() {
-        if (!this.completionPromise) {
-            return undefined;
-        }
-        this.cancelTimeout();
-        let result = this.task();
-        this.completionPromise = undefined;
-        this.onSuccess = undefined;
-        this.task = undefined;
-        return result;
-    }
-    isTriggered() {
-        return this.timeout !== undefined;
-    }
-    cancel() {
-        this.cancelTimeout();
-        this.completionPromise = undefined;
-    }
-    cancelTimeout() {
-        if (this.timeout !== undefined) {
-            this.timeout.dispose();
-            this.timeout = undefined;
-        }
-    }
-}
-exports.Delayer = Delayer;
-class Semaphore {
-    constructor(capacity = 1) {
-        if (capacity <= 0) {
-            throw new Error('Capacity must be greater than 0');
-        }
-        this._capacity = capacity;
-        this._active = 0;
-        this._waiting = [];
-    }
-    lock(thunk) {
-        return new Promise((resolve, reject) => {
-            this._waiting.push({ thunk, resolve, reject });
-            this.runNext();
-        });
-    }
-    get active() {
-        return this._active;
-    }
-    runNext() {
-        if (this._waiting.length === 0 || this._active === this._capacity) {
-            return;
-        }
-        (0, vscode_languageserver_protocol_1.RAL)().timer.setImmediate(() => this.doRunNext());
-    }
-    doRunNext() {
-        if (this._waiting.length === 0 || this._active === this._capacity) {
-            return;
-        }
-        const next = this._waiting.shift();
-        this._active++;
-        if (this._active > this._capacity) {
-            throw new Error(`To many thunks active`);
-        }
-        try {
-            const result = next.thunk();
-            if (result instanceof Promise) {
-                result.then((value) => {
-                    this._active--;
-                    next.resolve(value);
-                    this.runNext();
-                }, (err) => {
-                    this._active--;
-                    next.reject(err);
-                    this.runNext();
-                });
-            }
-            else {
-                this._active--;
-                next.resolve(result);
-                this.runNext();
-            }
-        }
-        catch (err) {
-            this._active--;
-            next.reject(err);
-            this.runNext();
-        }
-    }
-}
-exports.Semaphore = Semaphore;
-let $test = false;
-function setTestMode() {
-    $test = true;
-}
-exports.setTestMode = setTestMode;
-function clearTestMode() {
-    $test = false;
-}
-exports.clearTestMode = clearTestMode;
-const defaultYieldTimeout = 15 /*ms*/;
-class Timer {
-    constructor(yieldAfter = defaultYieldTimeout) {
-        this.yieldAfter = $test === true ? Math.max(yieldAfter, 2) : Math.max(yieldAfter, defaultYieldTimeout);
-        this.startTime = Date.now();
-        this.counter = 0;
-        this.total = 0;
-        // start with a counter interval of 1.
-        this.counterInterval = 1;
-    }
-    start() {
-        this.counter = 0;
-        this.total = 0;
-        this.counterInterval = 1;
-        this.startTime = Date.now();
-    }
-    shouldYield() {
-        if (++this.counter >= this.counterInterval) {
-            const timeTaken = Date.now() - this.startTime;
-            const timeLeft = Math.max(0, this.yieldAfter - timeTaken);
-            this.total += this.counter;
-            this.counter = 0;
-            if (timeTaken >= this.yieldAfter || timeLeft <= 1) {
-                // Yield also if time left <= 1 since we compute the counter
-                // for max < 2 ms.
-                // Start with interval 1 again. We could do some calculation
-                // with using 80% of the last counter however other things (GC)
-                // affect the timing heavily since we have small timings (1 - 15ms).
-                this.counterInterval = 1;
-                this.total = 0;
-                return true;
-            }
-            else {
-                // Only increase the counter until we have spent <= 2 ms. Increasing
-                // the counter further is very fragile since timing is influenced
-                // by other things and can increase the counter too much. This will result
-                // that we yield in average after [14 - 16]ms.
-                switch (timeTaken) {
-                    case 0:
-                    case 1:
-                        this.counterInterval = this.total * 2;
-                        break;
-                }
-            }
-        }
-        return false;
-    }
-}
-async function map(items, func, token, options) {
-    if (items.length === 0) {
-        return [];
-    }
-    const result = new Array(items.length);
-    const timer = new Timer(options?.yieldAfter);
-    function convertBatch(start) {
-        timer.start();
-        for (let i = start; i < items.length; i++) {
-            result[i] = func(items[i]);
-            if (timer.shouldYield()) {
-                options?.yieldCallback && options.yieldCallback();
-                return i + 1;
-            }
-        }
-        return -1;
-    }
-    // Convert the first batch sync on the same frame.
-    let index = convertBatch(0);
-    while (index !== -1) {
-        if (token !== undefined && token.isCancellationRequested) {
-            break;
-        }
-        index = await new Promise((resolve) => {
-            (0, vscode_languageserver_protocol_1.RAL)().timer.setImmediate(() => {
-                resolve(convertBatch(index));
-            });
-        });
-    }
-    return result;
-}
-exports.map = map;
-async function mapAsync(items, func, token, options) {
-    if (items.length === 0) {
-        return [];
-    }
-    const result = new Array(items.length);
-    const timer = new Timer(options?.yieldAfter);
-    async function convertBatch(start) {
-        timer.start();
-        for (let i = start; i < items.length; i++) {
-            result[i] = await func(items[i], token);
-            if (timer.shouldYield()) {
-                options?.yieldCallback && options.yieldCallback();
-                return i + 1;
-            }
-        }
-        return -1;
-    }
-    let index = await convertBatch(0);
-    while (index !== -1) {
-        if (token !== undefined && token.isCancellationRequested) {
-            break;
-        }
-        index = await new Promise((resolve) => {
-            (0, vscode_languageserver_protocol_1.RAL)().timer.setImmediate(() => {
-                resolve(convertBatch(index));
-            });
-        });
-    }
-    return result;
-}
-exports.mapAsync = mapAsync;
-async function forEach(items, func, token, options) {
-    if (items.length === 0) {
-        return;
-    }
-    const timer = new Timer(options?.yieldAfter);
-    function runBatch(start) {
-        timer.start();
-        for (let i = start; i < items.length; i++) {
-            func(items[i]);
-            if (timer.shouldYield()) {
-                options?.yieldCallback && options.yieldCallback();
-                return i + 1;
-            }
-        }
-        return -1;
-    }
-    // Convert the first batch sync on the same frame.
-    let index = runBatch(0);
-    while (index !== -1) {
-        if (token !== undefined && token.isCancellationRequested) {
-            break;
-        }
-        index = await new Promise((resolve) => {
-            (0, vscode_languageserver_protocol_1.RAL)().timer.setImmediate(() => {
-                resolve(runBatch(index));
-            });
-        });
-    }
-}
-exports.forEach = forEach;

package/client/node_modules/vscode-languageclient/lib/common/utils/is.d.ts

@@ -1,12 +0,0 @@
-export declare function boolean(value: any): value is boolean;
-export declare function string(value: any): value is string;
-export declare function number(value: any): value is number;
-export declare function error(value: any): value is Error;
-export declare function func(value: any): value is Function;
-export declare function array<T>(value: any): value is T[];
-export declare function stringArray(value: any): value is string[];
-export declare function typedArray<T>(value: any, check: (value: any) => boolean): value is T[];
-export declare function thenable<T>(value: any): value is Thenable<T>;
-export declare function asPromise<T>(value: Promise<T>): Promise<T>;
-export declare function asPromise<T>(value: Thenable<T>): Promise<T>;
-export declare function asPromise<T>(value: T): Promise<T>;

package/client/node_modules/vscode-languageclient/lib/common/utils/is.js

@@ -1,57 +0,0 @@
-"use strict";
-/* --------------------------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License. See License.txt in the project root for license information.
- * ------------------------------------------------------------------------------------------ */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.asPromise = exports.thenable = exports.typedArray = exports.stringArray = exports.array = exports.func = exports.error = exports.number = exports.string = exports.boolean = void 0;
-function boolean(value) {
-    return value === true || value === false;
-}
-exports.boolean = boolean;
-function string(value) {
-    return typeof value === 'string' || value instanceof String;
-}
-exports.string = string;
-function number(value) {
-    return typeof value === 'number' || value instanceof Number;
-}
-exports.number = number;
-function error(value) {
-    return value instanceof Error;
-}
-exports.error = error;
-function func(value) {
-    return typeof value === 'function';
-}
-exports.func = func;
-function array(value) {
-    return Array.isArray(value);
-}
-exports.array = array;
-function stringArray(value) {
-    return array(value) && value.every(elem => string(elem));
-}
-exports.stringArray = stringArray;
-function typedArray(value, check) {
-    return Array.isArray(value) && value.every(check);
-}
-exports.typedArray = typedArray;
-function thenable(value) {
-    return value && func(value.then);
-}
-exports.thenable = thenable;
-function asPromise(value) {
-    if (value instanceof Promise) {
-        return value;
-    }
-    else if (thenable(value)) {
-        return new Promise((resolve, reject) => {
-            value.then((resolved) => resolve(resolved), (error) => reject(error));
-        });
-    }
-    else {
-        return Promise.resolve(value);
-    }
-}
-exports.asPromise = asPromise;

package/client/node_modules/vscode-languageclient/lib/common/utils/uuid.d.ts

@@ -1,22 +0,0 @@
-/**
- * Represents a UUID as defined by rfc4122.
- */
-export interface UUID {
-    /**
-     * @returns the canonical representation in sets of hexadecimal numbers separated by dashes.
-     */
-    asHex(): string;
-    equals(other: UUID): boolean;
-}
-/**
- * An empty UUID that contains only zeros.
- */
-export declare const empty: UUID;
-export declare function v4(): UUID;
-export declare function isUUID(value: string): boolean;
-/**
- * Parses a UUID that is of the format xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.
- * @param value A uuid string.
- */
-export declare function parse(value: string): UUID;
-export declare function generateUuid(): string;

package/client/node_modules/vscode-languageclient/lib/common/utils/uuid.js

@@ -1,97 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateUuid = exports.parse = exports.isUUID = exports.v4 = exports.empty = void 0;
-class ValueUUID {
-    constructor(_value) {
-        this._value = _value;
-        // empty
-    }
-    asHex() {
-        return this._value;
-    }
-    equals(other) {
-        return this.asHex() === other.asHex();
-    }
-}
-class V4UUID extends ValueUUID {
-    static _oneOf(array) {
-        return array[Math.floor(array.length * Math.random())];
-    }
-    static _randomHex() {
-        return V4UUID._oneOf(V4UUID._chars);
-    }
-    constructor() {
-        super([
-            V4UUID._randomHex(),
-            V4UUID._randomHex(),
-            V4UUID._randomHex(),
-            V4UUID._randomHex(),
-            V4UUID._randomHex(),
-            V4UUID._randomHex(),
-            V4UUID._randomHex(),
-            V4UUID._randomHex(),
-            '-',
-            V4UUID._randomHex(),
-            V4UUID._randomHex(),
-            V4UUID._randomHex(),
-            V4UUID._randomHex(),
-            '-',
-            '4',
-            V4UUID._randomHex(),
-            V4UUID._randomHex(),
-            V4UUID._randomHex(),
-            '-',
-            V4UUID._oneOf(V4UUID._timeHighBits),
-            V4UUID._randomHex(),
-            V4UUID._randomHex(),
-            V4UUID._randomHex(),
-            '-',
-            V4UUID._randomHex(),
-            V4UUID._randomHex(),
-            V4UUID._randomHex(),
-            V4UUID._randomHex(),
-            V4UUID._randomHex(),
-            V4UUID._randomHex(),
-            V4UUID._randomHex(),
-            V4UUID._randomHex(),
-            V4UUID._randomHex(),
-            V4UUID._randomHex(),
-            V4UUID._randomHex(),
-            V4UUID._randomHex(),
-        ].join(''));
-    }
-}
-V4UUID._chars = ['0', '1', '2', '3', '4', '5', '6', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'];
-V4UUID._timeHighBits = ['8', '9', 'a', 'b'];
-/**
- * An empty UUID that contains only zeros.
- */
-exports.empty = new ValueUUID('00000000-0000-0000-0000-000000000000');
-function v4() {
-    return new V4UUID();
-}
-exports.v4 = v4;
-const _UUIDPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-function isUUID(value) {
-    return _UUIDPattern.test(value);
-}
-exports.isUUID = isUUID;
-/**
- * Parses a UUID that is of the format xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.
- * @param value A uuid string.
- */
-function parse(value) {
-    if (!isUUID(value)) {
-        throw new Error('invalid uuid');
-    }
-    return new ValueUUID(value);
-}
-exports.parse = parse;
-function generateUuid() {
-    return v4().asHex();
-}
-exports.generateUuid = generateUuid;

package/client/node_modules/vscode-languageclient/lib/common/workspaceFolder.d.ts

@@ -1,30 +0,0 @@
-import { WorkspaceFolder as VWorkspaceFolder, WorkspaceFoldersChangeEvent as VWorkspaceFoldersChangeEvent } from 'vscode';
-import { DynamicFeature, RegistrationData, FeatureClient, NextSignature, FeatureState } from './features';
-import { ClientCapabilities, InitializeParams, ServerCapabilities, WorkspaceFoldersRequest, RegistrationType } from 'vscode-languageserver-protocol';
-export declare function arrayDiff<T>(left: ReadonlyArray<T>, right: ReadonlyArray<T>): T[];
-export type WorkspaceFolderMiddleware = {
-    workspaceFolders?: WorkspaceFoldersRequest.MiddlewareSignature;
-    didChangeWorkspaceFolders?: NextSignature<VWorkspaceFoldersChangeEvent, Promise<void>>;
-};
-type WorkspaceFolderWorkspaceMiddleware = {
-    workspace?: WorkspaceFolderMiddleware;
-};
-export declare class WorkspaceFoldersFeature implements DynamicFeature<void> {
-    private readonly _client;
-    private readonly _listeners;
-    private _initialFolders;
-    constructor(client: FeatureClient<WorkspaceFolderWorkspaceMiddleware>);
-    getState(): FeatureState;
-    get registrationType(): RegistrationType<void>;
-    fillInitializeParams(params: InitializeParams): void;
-    protected initializeWithFolders(currentWorkspaceFolders: ReadonlyArray<VWorkspaceFolder> | undefined): void;
-    fillClientCapabilities(capabilities: ClientCapabilities): void;
-    initialize(capabilities: ServerCapabilities): void;
-    protected sendInitialEvent(currentWorkspaceFolders: ReadonlyArray<VWorkspaceFolder> | undefined): void;
-    private doSendEvent;
-    register(data: RegistrationData<undefined>): void;
-    unregister(id: string): void;
-    clear(): void;
-    private asProtocol;
-}
-export {};

package/client/node_modules/vscode-languageclient/lib/common/workspaceFolder.js

@@ -1,148 +0,0 @@
-"use strict";
-/* --------------------------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License. See License.txt in the project root for license information.
- * ------------------------------------------------------------------------------------------ */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WorkspaceFoldersFeature = exports.arrayDiff = void 0;
-const UUID = require("./utils/uuid");
-const vscode_1 = require("vscode");
-const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
-function access(target, key) {
-    if (target === undefined || target === null) {
-        return undefined;
-    }
-    return target[key];
-}
-function arrayDiff(left, right) {
-    return left.filter(element => right.indexOf(element) < 0);
-}
-exports.arrayDiff = arrayDiff;
-class WorkspaceFoldersFeature {
-    constructor(client) {
-        this._client = client;
-        this._listeners = new Map();
-    }
-    getState() {
-        return { kind: 'workspace', id: this.registrationType.method, registrations: this._listeners.size > 0 };
-    }
-    get registrationType() {
-        return vscode_languageserver_protocol_1.DidChangeWorkspaceFoldersNotification.type;
-    }
-    fillInitializeParams(params) {
-        const folders = vscode_1.workspace.workspaceFolders;
-        this.initializeWithFolders(folders);
-        if (folders === void 0) {
-            params.workspaceFolders = null;
-        }
-        else {
-            params.workspaceFolders = folders.map(folder => this.asProtocol(folder));
-        }
-    }
-    initializeWithFolders(currentWorkspaceFolders) {
-        this._initialFolders = currentWorkspaceFolders;
-    }
-    fillClientCapabilities(capabilities) {
-        capabilities.workspace = capabilities.workspace || {};
-        capabilities.workspace.workspaceFolders = true;
-    }
-    initialize(capabilities) {
-        const client = this._client;
-        client.onRequest(vscode_languageserver_protocol_1.WorkspaceFoldersRequest.type, (token) => {
-            const workspaceFolders = () => {
-                const folders = vscode_1.workspace.workspaceFolders;
-                if (folders === undefined) {
-                    return null;
-                }
-                const result = folders.map((folder) => {
-                    return this.asProtocol(folder);
-                });
-                return result;
-            };
-            const middleware = client.middleware.workspace;
-            return middleware && middleware.workspaceFolders
-                ? middleware.workspaceFolders(token, workspaceFolders)
-                : workspaceFolders(token);
-        });
-        const value = access(access(access(capabilities, 'workspace'), 'workspaceFolders'), 'changeNotifications');
-        let id;
-        if (typeof value === 'string') {
-            id = value;
-        }
-        else if (value === true) {
-            id = UUID.generateUuid();
-        }
-        if (id) {
-            this.register({ id: id, registerOptions: undefined });
-        }
-    }
-    sendInitialEvent(currentWorkspaceFolders) {
-        let promise;
-        if (this._initialFolders && currentWorkspaceFolders) {
-            const removed = arrayDiff(this._initialFolders, currentWorkspaceFolders);
-            const added = arrayDiff(currentWorkspaceFolders, this._initialFolders);
-            if (added.length > 0 || removed.length > 0) {
-                promise = this.doSendEvent(added, removed);
-            }
-        }
-        else if (this._initialFolders) {
-            promise = this.doSendEvent([], this._initialFolders);
-        }
-        else if (currentWorkspaceFolders) {
-            promise = this.doSendEvent(currentWorkspaceFolders, []);
-        }
-        if (promise !== undefined) {
-            promise.catch((error) => {
-                this._client.error(`Sending notification ${vscode_languageserver_protocol_1.DidChangeWorkspaceFoldersNotification.type.method} failed`, error);
-            });
-        }
-    }
-    doSendEvent(addedFolders, removedFolders) {
-        let params = {
-            event: {
-                added: addedFolders.map(folder => this.asProtocol(folder)),
-                removed: removedFolders.map(folder => this.asProtocol(folder))
-            }
-        };
-        return this._client.sendNotification(vscode_languageserver_protocol_1.DidChangeWorkspaceFoldersNotification.type, params);
-    }
-    register(data) {
-        let id = data.id;
-        let client = this._client;
-        let disposable = vscode_1.workspace.onDidChangeWorkspaceFolders((event) => {
-            let didChangeWorkspaceFolders = (event) => {
-                return this.doSendEvent(event.added, event.removed);
-            };
-            let middleware = client.middleware.workspace;
-            const promise = middleware && middleware.didChangeWorkspaceFolders
-                ? middleware.didChangeWorkspaceFolders(event, didChangeWorkspaceFolders)
-                : didChangeWorkspaceFolders(event);
-            promise.catch((error) => {
-                this._client.error(`Sending notification ${vscode_languageserver_protocol_1.DidChangeWorkspaceFoldersNotification.type.method} failed`, error);
-            });
-        });
-        this._listeners.set(id, disposable);
-        this.sendInitialEvent(vscode_1.workspace.workspaceFolders);
-    }
-    unregister(id) {
-        let disposable = this._listeners.get(id);
-        if (disposable === void 0) {
-            return;
-        }
-        this._listeners.delete(id);
-        disposable.dispose();
-    }
-    clear() {
-        for (let disposable of this._listeners.values()) {
-            disposable.dispose();
-        }
-        this._listeners.clear();
-    }
-    asProtocol(workspaceFolder) {
-        if (workspaceFolder === void 0) {
-            return null;
-        }
-        return { uri: this._client.code2ProtocolConverter.asUri(workspaceFolder.uri), name: workspaceFolder.name };
-    }
-}
-exports.WorkspaceFoldersFeature = WorkspaceFoldersFeature;

package/client/node_modules/vscode-languageclient/lib/common/workspaceSymbol.d.ts

@@ -1,19 +0,0 @@
-import { Disposable, CancellationToken, ProviderResult, SymbolInformation as VSymbolInformation, WorkspaceSymbolProvider } from 'vscode';
-import { ClientCapabilities, ServerCapabilities, WorkspaceSymbolRegistrationOptions } from 'vscode-languageserver-protocol';
-import { FeatureClient, WorkspaceFeature } from './features';
-export interface ProvideWorkspaceSymbolsSignature {
-    (this: void, query: string, token: CancellationToken): ProviderResult<VSymbolInformation[]>;
-}
-export interface ResolveWorkspaceSymbolSignature {
-    (this: void, item: VSymbolInformation, token: CancellationToken): ProviderResult<VSymbolInformation>;
-}
-export interface WorkspaceSymbolMiddleware {
-    provideWorkspaceSymbols?: (this: void, query: string, token: CancellationToken, next: ProvideWorkspaceSymbolsSignature) => ProviderResult<VSymbolInformation[]>;
-    resolveWorkspaceSymbol?: (this: void, item: VSymbolInformation, token: CancellationToken, next: ResolveWorkspaceSymbolSignature) => ProviderResult<VSymbolInformation>;
-}
-export declare class WorkspaceSymbolFeature extends WorkspaceFeature<WorkspaceSymbolRegistrationOptions, WorkspaceSymbolProvider, WorkspaceSymbolMiddleware> {
-    constructor(client: FeatureClient<WorkspaceSymbolMiddleware>);
-    fillClientCapabilities(capabilities: ClientCapabilities): void;
-    initialize(capabilities: ServerCapabilities): void;
-    protected registerLanguageProvider(options: WorkspaceSymbolRegistrationOptions): [Disposable, WorkspaceSymbolProvider];
-}