@jbrowse/plugin-spreadsheet-view 2.17.0 → 3.0.0

package/dist/SpreadsheetView/importAdapters/isNumber.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNumber = isNumber;
+function isNumber(num) {
+    if (typeof num === 'number') {
+        return num - num === 0;
+    }
+    else if (typeof num === 'string' && num.trim() !== '') {
+        return Number.isFinite(+num);
+    }
+    else {
+        return false;
+    }
+}

package/dist/SpreadsheetView/importAdapters/util.d.ts

@@ -0,0 +1,2 @@
+export declare function parseStrand(strand?: string): 1 | -1 | undefined;
+export declare function bufferToLines(buffer: Uint8Array): string[];

package/dist/SpreadsheetView/importAdapters/util.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStrand = parseStrand;
+exports.bufferToLines = bufferToLines;
+function parseStrand(strand) {
+    if (strand === '+') {
+        return 1;
+    }
+    else if (strand === '-') {
+        return -1;
+    }
+    else {
+        return undefined;
+    }
+}
+function bufferToLines(buffer) {
+    return new TextDecoder('utf8')
+        .decode(buffer)
+        .split(/\n|\r\n|\r/)
+        .map(f => f.trim())
+        .filter(f => !!f);
+}

package/dist/SpreadsheetView/index.d.ts

@@ -1,3 +1,3 @@
-import PluginManager from '@jbrowse/core/PluginManager';
+import type PluginManager from '@jbrowse/core/PluginManager';
 export default function SpreadsheetViewF(pluginManager: PluginManager): void;
-export { type SpreadsheetViewModel, type SpreadsheetViewStateModel, } from './models/SpreadsheetView';
+export type { SpreadsheetViewModel, SpreadsheetViewStateModel, } from './SpreadsheetViewModel';

package/dist/SpreadsheetView/index.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -29,13 +39,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = SpreadsheetViewF;
 const react_1 = require("react");
 const pluggableElementTypes_1 = require("@jbrowse/core/pluggableElementTypes");
-const SpreadsheetView_1 = __importDefault(require("./models/SpreadsheetView"));
+const SpreadsheetViewModel_1 = __importDefault(require("./SpreadsheetViewModel"));
 function SpreadsheetViewF(pluginManager) {
     pluginManager.addViewType(() => {
         return new pluggableElementTypes_1.ViewType({
             name: 'SpreadsheetView',
             displayName: 'Spreadsheet view',
-            stateModel: SpreadsheetView_1.default,
+            stateModel: (0, SpreadsheetViewModel_1.default)(),
             ReactComponent: (0, react_1.lazy)(() => Promise.resolve().then(() => __importStar(require('./components/SpreadsheetView')))),
         });
     });

package/dist/SpreadsheetView/util.d.ts

@@ -0,0 +1,7 @@
+import type { AbstractSessionModel } from '@jbrowse/core/util';
+export declare function locationLinkClick({ assemblyName, session, locString, spreadsheetViewId, }: {
+    assemblyName: string;
+    session: AbstractSessionModel;
+    locString: string;
+    spreadsheetViewId: string;
+}): Promise<void>;

package/dist/SpreadsheetView/util.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.locationLinkClick = locationLinkClick;
+function locationLinkClick({ assemblyName, session, locString, spreadsheetViewId, }) {
+    const newViewId = `${spreadsheetViewId}_${assemblyName}`;
+    let view = session.views.find(v => v.id === newViewId);
+    if (!view) {
+        view = session.addView('LinearGenomeView', {
+            id: newViewId,
+        });
+    }
+    return view.navToLocString(locString, assemblyName);
+}

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import PluginManager from '@jbrowse/core/PluginManager';
 import Plugin from '@jbrowse/core/Plugin';
+import type PluginManager from '@jbrowse/core/PluginManager';
 export default class SpreadsheetViewPlugin extends Plugin {
     name: string;
     install(pluginManager: PluginManager): void;

package/dist/index.js

@@ -5,11 +5,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const Plugin_1 = __importDefault(require("@jbrowse/core/Plugin"));
 const util_1 = require("@jbrowse/core/util");
-// icons
 const ViewComfy_1 = __importDefault(require("@mui/icons-material/ViewComfy"));
-// locals
-const SpreadsheetView_1 = __importDefault(require("./SpreadsheetView"));
 const LaunchSpreadsheetView_1 = __importDefault(require("./LaunchSpreadsheetView"));
+const SpreadsheetView_1 = __importDefault(require("./SpreadsheetView"));
 class SpreadsheetViewPlugin extends Plugin_1.default {
     constructor() {
         super(...arguments);

package/esm/LaunchSpreadsheetView/index.d.ts

@@ -1,2 +1,2 @@
-import PluginManager from '@jbrowse/core/PluginManager';
+import type PluginManager from '@jbrowse/core/PluginManager';
 export default function LaunchSpreadsheetViewF(pluginManager: PluginManager): void;

package/esm/LaunchSpreadsheetView/index.js

@@ -1,7 +1,5 @@
 export default function LaunchSpreadsheetViewF(pluginManager) {
-    pluginManager.addToExtensionPoint('LaunchView-SpreadsheetView', 
-    // @ts-expect-error
-    async ({ session, assembly, uri, fileType, }) => {
+    pluginManager.addToExtensionPoint('LaunchView-SpreadsheetView', async ({ session, assembly, uri, fileType, }) => {
         var _a, _b;
         const view = session.addView('SpreadsheetView');
         const exts = uri.split('.');

package/esm/SpreadsheetView/ImportWizard.d.ts

@@ -0,0 +1,51 @@
+import type { FileLocation } from '@jbrowse/core/util';
+import type { Instance } from 'mobx-state-tree';
+export default function stateModelFactory(): import("mobx-state-tree").IModelType<{
+    fileType: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
+    hasColumnNameLine: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+    columnNameLineNumber: import("mobx-state-tree").IType<number | undefined, number, number>;
+    selectedAssemblyName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
+    cachedFileLocation: import("mobx-state-tree").IType<FileLocation | undefined, FileLocation | undefined, FileLocation | undefined>;
+}, {
+    fileTypes: string[];
+    fileSource: any;
+    error: unknown;
+    loading: boolean;
+} & {
+    readonly isReadyToOpen: any;
+    readonly fileName: any;
+    readonly requiresUnzip: any;
+    isValidRefName(refName: string, assemblyName?: string): boolean;
+    tracksForAssembly(selectedAssembly: string): {
+        track: {
+            [x: string]: any;
+        } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+            setSubschema(slotName: string, data: Record<string, unknown>): Record<string, unknown> | ({
+                [x: string]: any;
+            } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+                setSubschema(slotName: string, data: Record<string, unknown>): Record<string, unknown> | ({
+                    [x: string]: any;
+                } & import("mobx-state-tree/dist/internal").NonEmptyObject & any & import("mobx-state-tree").IStateTreeNode<import("@jbrowse/core/configuration").AnyConfigurationSchemaType>);
+            } & import("mobx-state-tree").IStateTreeNode<import("@jbrowse/core/configuration").AnyConfigurationSchemaType>);
+        } & import("mobx-state-tree").IStateTreeNode<import("@jbrowse/core/configuration").AnyConfigurationSchemaType>;
+        label: string;
+        assemblyNames: any;
+        type: string;
+        loc: FileLocation;
+    }[];
+} & {
+    setSelectedAssemblyName(s: string): void;
+    setFileSource(newSource: unknown): void;
+    setColumnNameLineNumber(newnumber: number): void;
+    setFileType(typeName: string): void;
+    setError(error: unknown): void;
+    setLoading(arg: boolean): void;
+    cancelButton(): void;
+    setCachedFileHandle(arg: FileLocation): void;
+} & {
+    import(assemblyName: string): Promise<void>;
+} & {
+    afterAttach(): void;
+}, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
+export type ImportWizardStateModel = ReturnType<typeof stateModelFactory>;
+export type ImportWizardModel = Instance<ImportWizardStateModel>;

package/esm/SpreadsheetView/ImportWizard.js

@@ -0,0 +1,214 @@
+import { readConfObject } from '@jbrowse/core/configuration';
+import { getEnv, getSession } from '@jbrowse/core/util';
+import { openLocation } from '@jbrowse/core/util/io';
+import { getTrackName } from '@jbrowse/core/util/tracks';
+import { getParent, types } from 'mobx-state-tree';
+const IMPORT_SIZE_LIMIT = 100000000;
+const fileTypes = ['VCF', 'BED', 'BEDPE', 'STAR-Fusion'];
+const fileTypeParsers = {
+    VCF: () => import('./importAdapters/VcfImport').then(r => r.parseVcfBuffer),
+    BED: () => import('./importAdapters/BedImport').then(r => r.parseBedBuffer),
+    BEDPE: () => import('./importAdapters/BedpeImport').then(r => r.parseBedPEBuffer),
+    'STAR-Fusion': () => import('./importAdapters/STARFusionImport').then(r => r.parseSTARFusionBuffer),
+};
+function getType(adapter) {
+    if (adapter.vcfLocation || adapter.vcfGzLocation) {
+        return 'VCF';
+    }
+    else if (adapter.bedLocation || adapter.bedGzLocation) {
+        return 'BED';
+    }
+    else if (adapter.bedpeLocation) {
+        return 'BEDPE';
+    }
+    else {
+        return undefined;
+    }
+}
+function getAdapterLoc(adapter) {
+    return (adapter.vcfLocation ||
+        adapter.vcfGzLocation ||
+        adapter.bedLocation ||
+        adapter.bedGzLocation ||
+        adapter.bedpeLocation);
+}
+const fileTypesRegexp = new RegExp(`\\.(${fileTypes.join('|')})(\\.gz)?$`, 'i');
+function x() { }
+export default function stateModelFactory() {
+    return types
+        .model('SpreadsheetImportWizard', {
+        fileType: types.optional(types.enumeration(fileTypes), 'VCF'),
+        hasColumnNameLine: true,
+        columnNameLineNumber: 1,
+        selectedAssemblyName: types.maybe(types.string),
+        cachedFileLocation: types.frozen(),
+    })
+        .volatile(() => ({
+        fileTypes,
+        fileSource: undefined,
+        error: undefined,
+        loading: false,
+    }))
+        .views(self => ({
+        get isReadyToOpen() {
+            return (self.fileSource &&
+                (self.fileSource.blobId ||
+                    self.fileSource.localPath ||
+                    self.fileSource.uri));
+        },
+        get fileName() {
+            return (self.fileSource.uri ||
+                self.fileSource.localPath ||
+                (self.fileSource.blobId && self.fileSource.name));
+        },
+        get requiresUnzip() {
+            return this.fileName.endsWith('gz');
+        },
+        isValidRefName(refName, assemblyName) {
+            const { assemblyManager } = getSession(self);
+            return !assemblyName
+                ? false
+                : assemblyManager.isValidRefName(refName, assemblyName);
+        },
+        tracksForAssembly(selectedAssembly) {
+            const session = getSession(self);
+            const { tracks = [], sessionTracks = [] } = session;
+            const allTracks = [
+                ...tracks,
+                ...sessionTracks,
+            ];
+            return allTracks
+                .map(track => {
+                const assemblyNames = readConfObject(track, 'assemblyNames');
+                const adapter = readConfObject(track, 'adapter');
+                const category = readConfObject(track, 'category').join(',');
+                const loc = getAdapterLoc(adapter);
+                return assemblyNames.includes(selectedAssembly) && loc
+                    ? {
+                        track,
+                        label: [
+                            category ? `[${category}]` : '',
+                            getTrackName(track, session),
+                        ]
+                            .filter(f => !!f)
+                            .join(' '),
+                        assemblyNames,
+                        type: getType(adapter) || 'UNKNOWN',
+                        loc,
+                    }
+                    : undefined;
+            })
+                .filter(f => !!f)
+                .sort((a, b) => a.label.localeCompare(b.label));
+        },
+    }))
+        .actions(self => ({
+        setSelectedAssemblyName(s) {
+            self.selectedAssemblyName = s;
+        },
+        setFileSource(newSource) {
+            var _a;
+            self.fileSource = newSource;
+            self.error = undefined;
+            if (self.fileSource) {
+                const name = self.fileName;
+                if (name) {
+                    const firstMatch = (_a = fileTypesRegexp.exec(name)) === null || _a === void 0 ? void 0 : _a[1];
+                    if (firstMatch) {
+                        self.fileType =
+                            firstMatch === 'tsv' && name.includes('star-fusion')
+                                ? 'STAR-Fusion'
+                                : firstMatch.toUpperCase();
+                    }
+                }
+            }
+        },
+        setColumnNameLineNumber(newnumber) {
+            if (newnumber > 0) {
+                self.columnNameLineNumber = newnumber;
+            }
+        },
+        setFileType(typeName) {
+            self.fileType = typeName;
+        },
+        setError(error) {
+            self.error = error;
+        },
+        setLoading(arg) {
+            self.loading = arg;
+        },
+        cancelButton() {
+            self.error = undefined;
+            getParent(self).setDisplayMode();
+        },
+        setCachedFileHandle(arg) {
+            self.cachedFileLocation = arg;
+        },
+    }))
+        .actions(self => ({
+        async import(assemblyName) {
+            if (!self.fileSource) {
+                return;
+            }
+            self.selectedAssemblyName = assemblyName;
+            const type = self.fileType;
+            const typeParser = await fileTypeParsers[type]();
+            const { fetchAndMaybeUnzip } = await import('@jbrowse/core/util');
+            const { pluginManager } = getEnv(self);
+            const filehandle = openLocation(self.fileSource, pluginManager);
+            self.setLoading(true);
+            try {
+                const stat = await filehandle.stat();
+                if (stat.size > IMPORT_SIZE_LIMIT) {
+                    self.setError(`File is too big. Tabular files are limited to at most ${(IMPORT_SIZE_LIMIT / 1000).toLocaleString()}kb.`);
+                    return;
+                }
+            }
+            catch (e) {
+                console.warn(e);
+            }
+            finally {
+                self.setLoading(false);
+            }
+            self.setLoading(true);
+            try {
+                if (self.fileSource.uri) {
+                    self.setCachedFileHandle({
+                        uri: self.fileSource.uri,
+                        baseUri: self.fileSource.baseUri,
+                        locationType: 'UriLocation',
+                    });
+                }
+                const data = await fetchAndMaybeUnzip(filehandle);
+                getParent(self).displaySpreadsheet({
+                    ...typeParser(data),
+                    assemblyName,
+                });
+            }
+            catch (e) {
+                console.error(e);
+                self.setError(e);
+            }
+            finally {
+                self.setLoading(false);
+            }
+        },
+    }))
+        .actions(self => ({
+        afterAttach() {
+            ;
+            (async () => {
+                try {
+                    if (self.cachedFileLocation && self.selectedAssemblyName) {
+                        self.setFileSource(self.cachedFileLocation);
+                        await self.import(self.selectedAssemblyName);
+                    }
+                }
+                catch (e) {
+                    console.error(e);
+                    getSession(self).notifyError(`${e}`, e);
+                }
+            })();
+        },
+    }));
+}

package/esm/SpreadsheetView/SpreadsheetModel.d.ts

@@ -0,0 +1,78 @@
+import type { SimpleFeatureSerialized } from '@jbrowse/core/util';
+import type { Instance } from 'mobx-state-tree';
+export interface Row {
+    feature?: SimpleFeatureSerialized;
+    cellData?: Record<string, unknown>;
+    cells?: {
+        text: unknown;
+    }[];
+}
+export interface RowSet {
+    rows: Row[];
+}
+export default function stateModelFactory(): import("mobx-state-tree").IModelType<{
+    rowSet: import("mobx-state-tree").IType<RowSet | undefined, RowSet | undefined, RowSet | undefined>;
+    columns: import("mobx-state-tree").IType<{
+        name: string;
+    }[], {
+        name: string;
+    }[], {
+        name: string;
+    }[]>;
+    assemblyName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
+    visibleColumns: import("mobx-state-tree").IType<Record<string, boolean>, Record<string, boolean>, Record<string, boolean>>;
+}, {
+    visibleRowFlags: Record<number, boolean> | undefined;
+} & {
+    readonly rows: {
+        id: number;
+        feature: SimpleFeatureSerialized | undefined;
+    }[] | undefined;
+    readonly initialized: boolean | undefined;
+} & {
+    readonly dataGridColumns: ({
+        field: string;
+        width: number;
+        type: "number" | undefined;
+    } | {
+        field: string;
+        width: number;
+        renderCell: ({ row }: import("@mui/x-data-grid").GridRenderCellParams<{
+            id: number;
+            feature: SimpleFeatureSerialized | undefined;
+        }, any, any, import("@mui/x-data-grid").GridTreeNodeWithRender>) => import("react/jsx-runtime").JSX.Element | "N/A";
+        type?: undefined;
+        valueGetter?: undefined;
+        valueFormatter?: undefined;
+    } | {
+        field: string;
+        type: "number";
+        width: number;
+        valueGetter: (_val: unknown, row: {
+            feature?: SimpleFeatureSerialized;
+        }) => number | undefined;
+        valueFormatter: (arg: never) => string;
+        renderCell?: undefined;
+    })[] | undefined;
+} & {
+    readonly visibleRows: {
+        id: number;
+        feature: SimpleFeatureSerialized | undefined;
+    }[] | undefined;
+} & {
+    setVisibleRows(arg?: Record<number, boolean>): void;
+    setVisibleColumns(arg: Record<string, boolean>): void;
+}, import("mobx-state-tree").ModelCreationType<import("mobx-state-tree/dist/internal").ExtractCFromProps<{
+    rowSet: import("mobx-state-tree").IType<RowSet | undefined, RowSet | undefined, RowSet | undefined>;
+    columns: import("mobx-state-tree").IType<{
+        name: string;
+    }[], {
+        name: string;
+    }[], {
+        name: string;
+    }[]>;
+    assemblyName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
+    visibleColumns: import("mobx-state-tree").IType<Record<string, boolean>, Record<string, boolean>, Record<string, boolean>>;
+}>>, import("mobx-state-tree")._NotCustomized>;
+export type SpreadsheetStateModel = ReturnType<typeof stateModelFactory>;
+export type SpreadsheetModel = Instance<SpreadsheetStateModel>;

package/esm/SpreadsheetView/SpreadsheetModel.js

@@ -0,0 +1,113 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { assembleLocStringFast, getSession, measureGridWidth, toLocale, } from '@jbrowse/core/util';
+import { types } from 'mobx-state-tree';
+import LocationCell from './components/LocationCell';
+export default function stateModelFactory() {
+    return types
+        .model('Spreadsheet', {
+        rowSet: types.frozen(),
+        columns: types.frozen(),
+        assemblyName: types.maybe(types.string),
+        visibleColumns: types.frozen(),
+    })
+        .volatile(() => ({
+        visibleRowFlags: undefined,
+    }))
+        .views(self => ({
+        get rows() {
+            var _a;
+            return (_a = self.rowSet) === null || _a === void 0 ? void 0 : _a.rows.map((row, i) => ({
+                id: i,
+                feature: row.feature,
+                ...Object.fromEntries(self.columns.map((c, idx) => {
+                    var _a, _b, _c, _d;
+                    return [
+                        c.name,
+                        (_b = (_a = row.cellData) === null || _a === void 0 ? void 0 : _a[c.name]) !== null && _b !== void 0 ? _b : (_d = (_c = row.cells) === null || _c === void 0 ? void 0 : _c[idx]) === null || _d === void 0 ? void 0 : _d.text,
+                    ];
+                })),
+            }));
+        },
+        get initialized() {
+            var _a;
+            const session = getSession(self);
+            const name = self.assemblyName;
+            return (self.rowSet &&
+                (name ? (_a = session.assemblyManager.get(name)) === null || _a === void 0 ? void 0 : _a.initialized : false));
+        },
+    }))
+        .views(self => ({
+        get dataGridColumns() {
+            const { rows } = self;
+            return rows
+                ? [
+                    {
+                        field: 'Location',
+                        width: measureGridWidth(rows.map(row => row.feature ? assembleLocStringFast(row.feature) : 0)) + 40,
+                        renderCell: ({ row }) => {
+                            const { feature } = row;
+                            return feature ? (_jsx(LocationCell, { model: self, feature: feature })) : ('N/A');
+                        },
+                    },
+                    {
+                        field: 'Length',
+                        type: 'number',
+                        width: measureGridWidth(rows.map(row => {
+                            const { feature } = row;
+                            return feature ? feature.end - feature.start : 0;
+                        })),
+                        valueGetter: (_val, row) => {
+                            const { feature } = row;
+                            return feature ? feature.end - feature.start : undefined;
+                        },
+                        valueFormatter: arg => toLocale(arg),
+                    },
+                    ...self.columns.map(f => ({
+                        field: f.name,
+                        width: measureGridWidth([...rows.map(r => r[f.name]), f.name], { minWidth: 20 }),
+                        type: typeof rows[0][f.name] === 'number'
+                            ? 'number'
+                            : undefined,
+                    })),
+                ]
+                : undefined;
+        },
+    }))
+        .views(self => ({
+        get visibleRows() {
+            var _a;
+            const { visibleRowFlags } = self;
+            return visibleRowFlags
+                ? (_a = self.rows) === null || _a === void 0 ? void 0 : _a.filter((_f, idx) => !!visibleRowFlags[idx])
+                : self.rows;
+        },
+    }))
+        .actions(self => ({
+        setVisibleRows(arg) {
+            self.visibleRowFlags = arg;
+        },
+        setVisibleColumns(arg) {
+            self.visibleColumns = arg;
+        },
+    }))
+        .preProcessSnapshot(snap => {
+        return snap
+            ? {
+                ...snap,
+                columns: snap.columns.filter(f => !f.isDerived),
+                rowSet: snap.rowSet
+                    ? {
+                        ...snap.rowSet,
+                        rows: snap.rowSet.rows.map(r => {
+                            var _a, _b;
+                            return ({
+                                ...r,
+                                feature: (_a = r.feature) !== null && _a !== void 0 ? _a : (_b = r.extendedData) === null || _b === void 0 ? void 0 : _b.vcfFeature,
+                            });
+                        }),
+                    }
+                    : undefined,
+            }
+            : snap;
+    });
+}