(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.PydioCoreActions = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
/*
 * Copyright 2007-2017 Charles du Jeu - Abstrium SAS <team (at) pyd.io>
 * This file is part of Pydio.
 *
 * Pydio is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Pydio is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.
 *
 * The latest code can be found at <https://pydio.com>.
 */

'use strict';

exports.__esModule = true;

var _globals = require('../globals');

exports['default'] = function () {

    if (_globals.global.Notification) {
        alert(_globals.MessageHash["notification_center.12"]);
        _globals.global.Notification.requestPermission(function (grant) {
            ['default', 'granted', 'denied'].indexOf(grant) === true;
        });
    } else {
        _globals.global.alert(_globals.MessageHash["notification_center.13"]);
    }
};

module.exports = exports['default'];

},{"../globals":12}],2:[function(require,module,exports){
/*
 * Copyright 2007-2017 Charles du Jeu - Abstrium SAS <team (at) pyd.io>
 * This file is part of Pydio.
 *
 * Pydio is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Pydio is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.
 *
 * The latest code can be found at <https://pydio.com>.
 */

'use strict';

exports.__esModule = true;

var _globals = require('../globals');

exports['default'] = function () {

    _globals.pydio.UI.openComponentInModal('PydioCoreActions', 'PasswordDialog', {
        locked: _globals.pydio.user && _globals.pydio.user.lock === 'pass_change'
    });
};

module.exports = exports['default'];

},{"../globals":12}],3:[function(require,module,exports){
/*
 * Copyright 2007-2017 Charles du Jeu - Abstrium SAS <team (at) pyd.io>
 * This file is part of Pydio.
 *
 * Pydio is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Pydio is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.
 *
 * The latest code can be found at <https://pydio.com>.
 */

'use strict';

exports.__esModule = true;
var PydioApi = require('pydio/http/api');

exports['default'] = function () {
  PydioApi.getClient().request({ get_action: 'clear_plugins_cache' });
};

module.exports = exports['default'];

},{"pydio/http/api":"pydio/http/api"}],4:[function(require,module,exports){
/*
 * Copyright 2007-2017 Charles du Jeu - Abstrium SAS <team (at) pyd.io>
 * This file is part of Pydio.
 *
 * Pydio is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Pydio is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.
 *
 * The latest code can be found at <https://pydio.com>.
 */

'use strict';

exports.__esModule = true;

var _globals = require('../globals');

var PydioApi = require('pydio/http/api');

exports['default'] = function (manager, args) {
    var selection = args[0];
    if (selection.getUniqueNode) {
        selection = selection.getUniqueNode();
    }
    if (selection && selection.getMetadata && selection.getMetadata().get("alert_id")) {
        var elMeta = selection.getMetadata();
        var params = {
            get_action: 'dismiss_user_alert',
            alert_id: elMeta.get('alert_id')
        };
        if (elMeta.get("event_occurence")) {
            params['occurrences'] = elMeta.get("event_occurence");
        }
        PydioApi.getClient().request(params, function () {
            _globals.pydio.notify("server_message:tree/reload_user_feed");
        });
    }
};

module.exports = exports['default'];

},{"../globals":12,"pydio/http/api":"pydio/http/api"}],5:[function(require,module,exports){
/*
 * Copyright 2007-2017 Charles du Jeu - Abstrium SAS <team (at) pyd.io>
 * This file is part of Pydio.
 *
 * Pydio is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Pydio is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.
 *
 * The latest code can be found at <https://pydio.com>.
 */

'use strict';

exports.__esModule = true;

var _globals = require('../globals');

var PydioApi = require('pydio/http/api');

exports['default'] = function () {

    var crtDir = _globals.pydio.getContextHolder().getContextNode().getPath();
    if (!_globals.pydio.getUserSelection().isEmpty()) {
        crtDir = _globals.pydio.getUserSelection().getUniqueNode().getPath();
    }
    PydioApi.getClient().request({
        get_action: "index",
        file: crtDir
    }, function (transport) {});
};

module.exports = exports['default'];

},{"../globals":12,"pydio/http/api":"pydio/http/api"}],6:[function(require,module,exports){
"use strict";

/*
 * Copyright 2007-2017 Charles du Jeu - Abstrium SAS <team (at) pyd.io>
 * This file is part of Pydio.
 *
 * Pydio is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Pydio is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.
 *
 * The latest code can be found at <https://pydio.com>.
 */

},{}],7:[function(require,module,exports){
/*
 * Copyright 2007-2017 Charles du Jeu - Abstrium SAS <team (at) pyd.io>
 * This file is part of Pydio.
 *
 * Pydio is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Pydio is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.
 *
 * The latest code can be found at <https://pydio.com>.
 */

'use strict';

exports.__esModule = true;

var _globals = require('../globals');

var PydioApi = require('pydio/http/api');

exports['default'] = function () {
    var selection = _globals.pydio.getContextHolder();
    if (selection.isEmpty() || !selection.isUnique()) {
        return;
    }
    var node = selection.getUniqueNode();
    var isBookmarked = node.getMetadata().get('ajxp_bookmarked') === 'true';
    PydioApi.getClient().request({
        get_action: 'get_bookmarks',
        bm_action: isBookmarked ? 'delete_bookmark' : 'add_bookmark',
        bm_path: node.getPath()
    }, function (t) {
        selection.requireNodeReload(node);
    });
};

module.exports = exports['default'];

},{"../globals":12,"pydio/http/api":"pydio/http/api"}],8:[function(require,module,exports){
/*
 * Copyright 2007-2017 Charles du Jeu - Abstrium SAS <team (at) pyd.io>
 * This file is part of Pydio.
 *
 * Pydio is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Pydio is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.
 *
 * The latest code can be found at <https://pydio.com>.
 */

'use strict';

exports.__esModule = true;

var _globals = require('../globals');

exports['default'] = function () {
  _globals.pydio.UI.openComponentInModal('PydioCoreActions', 'CreateRepositoryDialog');
};

module.exports = exports['default'];

},{"../globals":12}],9:[function(require,module,exports){
/*
 * Copyright 2007-2017 Charles du Jeu - Abstrium SAS <team (at) pyd.io>
 * This file is part of Pydio.
 *
 * Pydio is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Pydio is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.
 *
 * The latest code can be found at <https://pydio.com>.
 */

'use strict';

exports.__esModule = true;

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

var React = require('react');

var _require$requireLib = require('pydio').requireLib('boot');

var ActionDialogMixin = _require$requireLib.ActionDialogMixin;
var CancelButtonProviderMixin = _require$requireLib.CancelButtonProviderMixin;
var SubmitButtonProviderMixin = _require$requireLib.SubmitButtonProviderMixin;
var Loader = _require$requireLib.Loader;

var PydioApi = require('pydio/http/api');
var XMLUtils = require('pydio/util/xml');

var _require = require('material-ui');

var Divider = _require.Divider;
var List = _require.List;
var ListItem = _require.ListItem;
var FlatButton = _require.FlatButton;

/**
 * Dialog for letting users create a workspace
 */
exports['default'] = React.createClass({
    displayName: 'CreateRepositoryDialog',

    mixins: [ActionDialogMixin, CancelButtonProviderMixin, SubmitButtonProviderMixin],

    getDefaultProps: function getDefaultProps() {
        return {
            dialogTitleId: '418',
            dialogIsModal: true,
            dialogScrollBody: true,
            dialogPadding: 0
        };
    },

    getInitialState: function getInitialState() {
        return { xmlDefinitions: null, templateId: null, formParameters: null, formValues: {}, formLoaded: false, formValid: false };
    },

    getButtons: function getButtons() {
        var updater = arguments.length <= 0 || arguments[0] === undefined ? null : arguments[0];

        if (updater !== null) {
            this._updater = updater;
        }
        var _state = this.state;
        var templateId = _state.templateId;
        var formValid = _state.formValid;

        var buttons = [];
        if (templateId) {
            buttons.push(React.createElement(FlatButton, { style: { float: 'left' }, label: '<<', onTouchTap: this.resetTemplate.bind(this) }));
        }
        buttons.push(React.createElement(FlatButton, { label: 'Cancel', onTouchTap: this.props.onDismiss }));
        buttons.push(React.createElement(FlatButton, { secondary: true, label: 'OK', disabled: !formValid, onTouchTap: this.submit.bind(this) }));
        return buttons;
    },

    componentDidMount: function componentDidMount() {
        var _this = this;

        require('pydio').requireLib('form', true).then(function () {
            _this.setState({ formLoaded: true });
        });

        PydioApi.getClient().request({ get_action: 'get_user_templates_definition' }, function (transport) {
            _this.setState({ xmlDefinitions: transport.responseXML });
        });
        return;
    },

    submit: function submit() {
        var _this2 = this;

        var _state2 = this.state;
        var xmlDefinitions = _state2.xmlDefinitions;
        var templateId = _state2.templateId;
        var formParameters = _state2.formParameters;
        var formValues = _state2.formValues;
        var formLoaded = _state2.formLoaded;

        var _require$requireLib2 = require('pydio').requireLib('form');

        var Manager = _require$requireLib2.Manager;

        var parameters = Manager.parseParameters(xmlDefinitions, '//template[@repository_id="' + templateId + '"]/param');
        var postValues = Manager.getValuesForPOST(parameters, formValues, 'DRIVER_OPTION_');
        if (postValues['DRIVER_OPTION_DISPLAY']) {
            postValues['DISPLAY'] = postValues['DRIVER_OPTION_DISPLAY'];
            delete postValues['DRIVER_OPTION_DISPLAY'], delete postValues['DRIVER_OPTION_DISPLAY_ajxptype'];
        } else {
            postValues['DISPLAY'] = "NEW REPOSITORY TEST";
        }
        PydioApi.getClient().request(_extends({
            get_action: 'user_create_repository',
            template_id: templateId
        }, postValues), function (transport) {
            _this2.dismiss();
        });
    },

    chooseTemplate: function chooseTemplate(templateId) {
        var _this3 = this;

        var _require$requireLib3 = require('pydio').requireLib('form');

        var Manager = _require$requireLib3.Manager;
        var xmlDefinitions = this.state.xmlDefinitions;

        var parameters = Manager.parseParameters(xmlDefinitions, '//template[@repository_id="' + templateId + '"]/param');
        var displayParamIndex = parameters.findIndex(function (p) {
            return p.name === 'DISPLAY';
        });
        if (displayParamIndex > -1) {
            var displayParam = parameters[displayParamIndex];
            parameters.splice(displayParamIndex, 1);
            parameters.unshift(displayParam);
        }
        this.setState({
            templateId: templateId,
            formParameters: parameters
        }, function () {
            _this3._updater(_this3.getButtons());
        });
    },

    resetTemplate: function resetTemplate() {
        var _this4 = this;

        this.setState({
            templateId: null,
            formParameters: null,
            formValues: {},
            formValid: false
        }, function () {
            _this4._updater(_this4.getButtons());
        });
    },

    onFormValidStatusChange: function onFormValidStatusChange(newValidValue, failedFields) {
        var _this5 = this;

        this.setState({ formValid: newValidValue }, function () {
            _this5._updater(_this5.getButtons());
        });
    },

    render: function render() {
        var _this6 = this;

        var _state3 = this.state;
        var xmlDefinitions = _state3.xmlDefinitions;
        var templateId = _state3.templateId;
        var formParameters = _state3.formParameters;
        var formValues = _state3.formValues;
        var formLoaded = _state3.formLoaded;
        var MessageHash = this.props.pydio.MessageHash;

        if (!xmlDefinitions || !formLoaded) {
            return React.createElement(Loader, null);
        }
        if (!templateId) {
            var templates = XMLUtils.XPathSelectNodes(xmlDefinitions, "//template");
            var items = [];

            var _loop = function (i) {
                var label = templates[i].getAttribute('repository_label');
                var tplId = templates[i].getAttribute('repository_id');
                items.push(React.createElement(ListItem, { key: tplId, primaryText: label, onTouchTap: function () {
                        return _this6.chooseTemplate(tplId);
                    } }));
                if (i < templates.length - 1) {
                    items.push(React.createElement(Divider, { key: tplId + '-divider' }));
                }
            };

            for (var i = 0; i < templates.length; i++) {
                _loop(i);
            }
            return React.createElement(
                'div',
                { style: { width: '100%' } },
                React.createElement(
                    'p',
                    { style: { padding: 16, paddingBottom: 0, marginBottom: 0, color: 'rgba(0,0,0,.43)' } },
                    MessageHash['420']
                ),
                React.createElement(
                    List,
                    null,
                    items
                )
            );
        }

        var _require$requireLib4 = require('pydio').requireLib('form');

        var FormPanel = _require$requireLib4.FormPanel;

        return React.createElement(
            'div',
            { style: { width: '100%' } },
            React.createElement(FormPanel, {
                depth: -2,
                parameters: formParameters,
                values: formValues,
                onChange: function (newValues) {
                    _this6.setState({ formValues: newValues });
                },
                onValidStatusChange: this.onFormValidStatusChange.bind(this)
            })
        );

        return React.createElement('div', null);
    }

});
module.exports = exports['default'];

},{"material-ui":"material-ui","pydio":"pydio","pydio/http/api":"pydio/http/api","pydio/util/xml":"pydio/util/xml","react":"react"}],10:[function(require,module,exports){
/*
 * Copyright 2007-2017 Charles du Jeu - Abstrium SAS <team (at) pyd.io>
 * This file is part of Pydio.
 *
 * Pydio is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Pydio is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.
 *
 * The latest code can be found at <https://pydio.com>.
 */

'use strict';

exports.__esModule = true;

var _globals = require('../globals');

var _materialUi = require('material-ui');

var React = require('react');
var PydioApi = require('pydio/http/api');
var BootUI = require('pydio/http/resources-manager').requireLib('boot');
var ActionDialogMixin = BootUI.ActionDialogMixin;
var SubmitButtonProviderMixin = BootUI.SubmitButtonProviderMixin;
var CancelButtonProviderMixin = BootUI.CancelButtonProviderMixin;
var AsyncComponent = BootUI.AsyncComponent;

var PasswordDialog = React.createClass({
    displayName: 'PasswordDialog',

    mixins: [ActionDialogMixin],
    getInitialState: function getInitialState() {
        return { passValid: false };
    },
    getDefaultProps: function getDefaultProps() {
        return {
            dialogTitle: _globals.pydio.MessageHash[194],
            dialogIsModal: true,
            dialogSize: 'sm'
        };
    },
    getButtons: function getButtons() {
        var _this = this;

        var updater = arguments.length <= 0 || arguments[0] === undefined ? null : arguments[0];

        if (updater) this._updater = updater;
        var buttons = [];
        if (!this.props.locked) {
            buttons.push(React.createElement(_materialUi.FlatButton, { label: this.props.pydio.MessageHash[49], onTouchTap: function () {
                    return _this.dismiss();
                } }));
        }
        buttons.push(React.createElement(_materialUi.FlatButton, { label: this.props.pydio.MessageHash[48], onTouchTap: this.submit.bind(this), disabled: !this.state.passValid }));
        return buttons;
    },

    submit: function submit() {
        if (!this.state.passValid) {
            return false;
        }
        this.refs.passwordForm.instance.post((function (value) {
            if (value) this.dismiss();
        }).bind(this));
    },
    passValidStatusChange: function passValidStatusChange(status) {
        var _this2 = this;

        this.setState({ passValid: status }, function () {
            _this2._updater(_this2.getButtons());
        });
    },

    render: function render() {

        return React.createElement(AsyncComponent, {
            namespace: 'UserAccount',
            componentName: 'PasswordForm',
            pydio: this.props.pydio,
            ref: 'passwordForm',
            onValidStatusChange: this.passValidStatusChange
        });
    }

});

exports['default'] = PasswordDialog;
module.exports = exports['default'];

},{"../globals":12,"material-ui":"material-ui","pydio/http/api":"pydio/http/api","pydio/http/resources-manager":"pydio/http/resources-manager","react":"react"}],11:[function(require,module,exports){
/*
 * Copyright 2007-2017 Charles du Jeu - Abstrium SAS <team (at) pyd.io>
 * This file is part of Pydio.
 *
 * Pydio is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Pydio is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.
 *
 * The latest code can be found at <https://pydio.com>.
 */

'use strict';

exports.__esModule = true;
var React = require('react');
var PydioApi = require('pydio/http/api');
var BootUI = require('pydio/http/resources-manager').requireLib('boot');
var ActionDialogMixin = BootUI.ActionDialogMixin;
var SubmitButtonProviderMixin = BootUI.SubmitButtonProviderMixin;
var Loader = BootUI.Loader;

var SplashDialog = React.createClass({
    displayName: 'SplashDialog',

    mixins: [ActionDialogMixin, SubmitButtonProviderMixin],

    getDefaultProps: function getDefaultProps() {
        return {
            dialogTitle: '',
            dialogSize: 'lg',
            dialogIsModal: false,
            dialogPadding: false,
            dialogScrollBody: true
        };
    },
    submit: function submit() {
        this.dismiss();
    },

    getInitialState: function getInitialState() {
        return { aboutContent: null };
    },

    componentDidMount: function componentDidMount() {

        PydioApi.getClient().request({
            get_action: 'display_doc',
            doc_file: 'CREDITS'
        }, (function (transport) {
            this.setState({
                aboutContent: transport.responseText
            });
        }).bind(this));
    },

    render: function render() {
        var _this = this;

        if (!this.state.aboutContent) {
            return React.createElement(Loader, { style: { minHeight: 200 } });
        } else {
            var ct = function ct() {
                return { __html: _this.state.aboutContent };
            };
            return React.createElement('div', { style: { fontSize: 13, padding: '0 10px' }, dangerouslySetInnerHTML: ct() });
        }
    }

});

exports['default'] = SplashDialog;
module.exports = exports['default'];

},{"pydio/http/api":"pydio/http/api","pydio/http/resources-manager":"pydio/http/resources-manager","react":"react"}],12:[function(require,module,exports){
/*
 * Copyright 2007-2017 Charles du Jeu - Abstrium SAS <team (at) pyd.io>
 * This file is part of Pydio.
 *
 * Pydio is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Pydio is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.
 *
 * The latest code can be found at <https://pydio.com>.
 */

"use strict";

exports.__esModule = true;
var global = window;
var pydio = global.pydio;
var MessageHash = pydio.MessageHash;
exports.global = global;
exports.pydio = pydio;
exports.MessageHash = MessageHash;

},{}],13:[function(require,module,exports){
/*
 * Copyright 2007-2017 Charles du Jeu - Abstrium SAS <team (at) pyd.io>
 * This file is part of Pydio.
 *
 * Pydio is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Pydio is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.
 *
 * The latest code can be found at <https://pydio.com>.
 */

'use strict';

exports.__esModule = true;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

var _dialogSplashDialog = require('./dialog/SplashDialog');

var _dialogSplashDialog2 = _interopRequireDefault(_dialogSplashDialog);

var _dialogPasswordDialog = require('./dialog/PasswordDialog');

var _dialogPasswordDialog2 = _interopRequireDefault(_dialogPasswordDialog);

var _dialogCreateRepositoryDialog = require('./dialog/CreateRepositoryDialog');

var _dialogCreateRepositoryDialog2 = _interopRequireDefault(_dialogCreateRepositoryDialog);

var Callbacks = {
    switchLanguage: require('./callbacks/switchLanguage'),
    userCreateRepository: require('./callbacks/userCreateRepository'),
    changePass: require('./callbacks/changePass'),
    launchIndexation: require('./callbacks/launchIndexation'),
    toggleBookmark: require('./callbacks/toggleBookmark'),
    clearPluginsCache: require('./callbacks/clearPluginsCache'),
    dismissUserAlert: require('./callbacks/dismissUserAlert'),
    activateDesktopNotifications: require('./callbacks/activateDesktopNotifications')
};

var Navigation = {
    splash: require('./navigation/splash'),
    up: require('./navigation/up'),
    refresh: require('./navigation/refresh'),
    externalSelection: require('./navigation/externalSelection'),
    openGoPro: require('./navigation/openGoPro'),
    switchToSettings: require('./navigation/switchToSettings')
};

exports.Callbacks = Callbacks;
exports.Navigation = Navigation;
exports.SplashDialog = _dialogSplashDialog2['default'];
exports.PasswordDialog = _dialogPasswordDialog2['default'];
exports.CreateRepositoryDialog = _dialogCreateRepositoryDialog2['default'];

},{"./callbacks/activateDesktopNotifications":1,"./callbacks/changePass":2,"./callbacks/clearPluginsCache":3,"./callbacks/dismissUserAlert":4,"./callbacks/launchIndexation":5,"./callbacks/switchLanguage":6,"./callbacks/toggleBookmark":7,"./callbacks/userCreateRepository":8,"./dialog/CreateRepositoryDialog":9,"./dialog/PasswordDialog":10,"./dialog/SplashDialog":11,"./navigation/externalSelection":14,"./navigation/openGoPro":15,"./navigation/refresh":16,"./navigation/splash":17,"./navigation/switchToSettings":18,"./navigation/up":19}],14:[function(require,module,exports){
/*
 * Copyright 2007-2017 Charles du Jeu - Abstrium SAS <team (at) pyd.io>
 * This file is part of Pydio.
 *
 * Pydio is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Pydio is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.
 *
 * The latest code can be found at <https://pydio.com>.
 */

'use strict';

exports.__esModule = true;

var _globals = require('../globals');

exports['default'] = function () {

    var userSelection = _globals.pydio.getUserSelection();
    if (userSelection.isUnique() && !userSelection.hasDir()) {
        var fileName = userSelection.getUniqueFileName();
        var selectorData = _globals.pydio.getController().selectorData;
        if (selectorData.get('type') == "ckeditor") {
            var ckData = selectorData.get('data');
            if (ckData['CKEditorFuncNum']) {
                var imagePath = fileName;
                if (ckData['relative_path']) {
                    imagePath = ckData['relative_path'] + fileName;
                }
                _globals.global.opener.CKEDITOR.tools.callFunction(ckData['CKEditorFuncNum'], imagePath);
                _globals.global.close();
            }
        }
    }
};

module.exports = exports['default'];

},{"../globals":12}],15:[function(require,module,exports){
/*
 * Copyright 2007-2017 Charles du Jeu - Abstrium SAS <team (at) pyd.io>
 * This file is part of Pydio.
 *
 * Pydio is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Pydio is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.
 *
 * The latest code can be found at <https://pydio.com>.
 */

'use strict';

exports.__esModule = true;

var _globals = require('../globals');

exports['default'] = function () {
  _globals.global.open('https://pydio.com/en/go-pro?referrer=settings');
};

module.exports = exports['default'];

},{"../globals":12}],16:[function(require,module,exports){
/*
 * Copyright 2007-2017 Charles du Jeu - Abstrium SAS <team (at) pyd.io>
 * This file is part of Pydio.
 *
 * Pydio is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Pydio is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.
 *
 * The latest code can be found at <https://pydio.com>.
 */

'use strict';

exports.__esModule = true;

var _globals = require('../globals');

exports['default'] = function () {

  _globals.pydio.fireContextRefresh();
};

module.exports = exports['default'];

},{"../globals":12}],17:[function(require,module,exports){
/*
 * Copyright 2007-2017 Charles du Jeu - Abstrium SAS <team (at) pyd.io>
 * This file is part of Pydio.
 *
 * Pydio is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Pydio is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.
 *
 * The latest code can be found at <https://pydio.com>.
 */

'use strict';

exports.__esModule = true;

var _globals = require('../globals');

exports['default'] = function () {

  _globals.pydio.UI.openComponentInModal('PydioCoreActions', 'SplashDialog');
};

module.exports = exports['default'];

},{"../globals":12}],18:[function(require,module,exports){
/*
 * Copyright 2007-2017 Charles du Jeu - Abstrium SAS <team (at) pyd.io>
 * This file is part of Pydio.
 *
 * Pydio is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Pydio is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.
 *
 * The latest code can be found at <https://pydio.com>.
 */

'use strict';

exports.__esModule = true;

var _globals = require('../globals');

exports['default'] = function () {

    if (!_globals.pydio.repositoryId || _globals.pydio.repositoryId != "ajxp_conf") {
        _globals.pydio.triggerRepositoryChange('ajxp_conf');
    }
};

module.exports = exports['default'];

},{"../globals":12}],19:[function(require,module,exports){
/*
 * Copyright 2007-2017 Charles du Jeu - Abstrium SAS <team (at) pyd.io>
 * This file is part of Pydio.
 *
 * Pydio is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Pydio is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.
 *
 * The latest code can be found at <https://pydio.com>.
 */

'use strict';

exports.__esModule = true;

var _globals = require('../globals');

exports['default'] = function () {

  _globals.pydio.fireContextUp();
};

module.exports = exports['default'];

},{"../globals":12}]},{},[13])(13)
});

//# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","res/build/ui/CoreActions/callbacks/activateDesktopNotifications.js","res/build/ui/CoreActions/callbacks/changePass.js","res/build/ui/CoreActions/callbacks/clearPluginsCache.js","res/build/ui/CoreActions/callbacks/dismissUserAlert.js","res/build/ui/CoreActions/callbacks/launchIndexation.js","res/build/ui/CoreActions/callbacks/switchLanguage.js","res/build/ui/CoreActions/callbacks/toggleBookmark.js","res/build/ui/CoreActions/callbacks/userCreateRepository.js","res/build/ui/CoreActions/dialog/CreateRepositoryDialog.js","res/build/ui/CoreActions/dialog/PasswordDialog.js","res/build/ui/CoreActions/dialog/SplashDialog.js","res/build/ui/CoreActions/globals.js","res/build/ui/CoreActions/index.js","res/build/ui/CoreActions/navigation/externalSelection.js","res/build/ui/CoreActions/navigation/openGoPro.js","res/build/ui/CoreActions/navigation/refresh.js","res/build/ui/CoreActions/navigation/splash.js","res/build/ui/CoreActions/navigation/switchToSettings.js","res/build/ui/CoreActions/navigation/up.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","/*\n * Copyright 2007-2017 Charles du Jeu - Abstrium SAS <team (at) pyd.io>\n * This file is part of Pydio.\n *\n * Pydio is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Affero General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * Pydio is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU Affero General Public License for more details.\n *\n * You should have received a copy of the GNU Affero General Public License\n * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.\n *\n * The latest code can be found at <https://pydio.com>.\n */\n\n'use strict';\n\nexports.__esModule = true;\n\nvar _globals = require('../globals');\n\nexports['default'] = function () {\n\n    if (_globals.global.Notification) {\n        alert(_globals.MessageHash[\"notification_center.12\"]);\n        _globals.global.Notification.requestPermission(function (grant) {\n            ['default', 'granted', 'denied'].indexOf(grant) === true;\n        });\n    } else {\n        _globals.global.alert(_globals.MessageHash[\"notification_center.13\"]);\n    }\n};\n\nmodule.exports = exports['default'];\n","/*\n * Copyright 2007-2017 Charles du Jeu - Abstrium SAS <team (at) pyd.io>\n * This file is part of Pydio.\n *\n * Pydio is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Affero General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * Pydio is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU Affero General Public License for more details.\n *\n * You should have received a copy of the GNU Affero General Public License\n * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.\n *\n * The latest code can be found at <https://pydio.com>.\n */\n\n'use strict';\n\nexports.__esModule = true;\n\nvar _globals = require('../globals');\n\nexports['default'] = function () {\n\n    _globals.pydio.UI.openComponentInModal('PydioCoreActions', 'PasswordDialog', {\n        locked: _globals.pydio.user && _globals.pydio.user.lock === 'pass_change'\n    });\n};\n\nmodule.exports = exports['default'];\n","/*\n * Copyright 2007-2017 Charles du Jeu - Abstrium SAS <team (at) pyd.io>\n * This file is part of Pydio.\n *\n * Pydio is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Affero General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * Pydio is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU Affero General Public License for more details.\n *\n * You should have received a copy of the GNU Affero General Public License\n * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.\n *\n * The latest code can be found at <https://pydio.com>.\n */\n\n'use strict';\n\nexports.__esModule = true;\nvar PydioApi = require('pydio/http/api');\n\nexports['default'] = function () {\n  PydioApi.getClient().request({ get_action: 'clear_plugins_cache' });\n};\n\nmodule.exports = exports['default'];\n","/*\n * Copyright 2007-2017 Charles du Jeu - Abstrium SAS <team (at) pyd.io>\n * This file is part of Pydio.\n *\n * Pydio is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Affero General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * Pydio is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU Affero General Public License for more details.\n *\n * You should have received a copy of the GNU Affero General Public License\n * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.\n *\n * The latest code can be found at <https://pydio.com>.\n */\n\n'use strict';\n\nexports.__esModule = true;\n\nvar _globals = require('../globals');\n\nvar PydioApi = require('pydio/http/api');\n\nexports['default'] = function (manager, args) {\n    var selection = args[0];\n    if (selection.getUniqueNode) {\n        selection = selection.getUniqueNode();\n    }\n    if (selection && selection.getMetadata && selection.getMetadata().get(\"alert_id\")) {\n        var elMeta = selection.getMetadata();\n        var params = {\n            get_action: 'dismiss_user_alert',\n            alert_id: elMeta.get('alert_id')\n        };\n        if (elMeta.get(\"event_occurence\")) {\n            params['occurrences'] = elMeta.get(\"event_occurence\");\n        }\n        PydioApi.getClient().request(params, function () {\n            _globals.pydio.notify(\"server_message:tree/reload_user_feed\");\n        });\n    }\n};\n\nmodule.exports = exports['default'];\n","/*\n * Copyright 2007-2017 Charles du Jeu - Abstrium SAS <team (at) pyd.io>\n * This file is part of Pydio.\n *\n * Pydio is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Affero General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * Pydio is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU Affero General Public License for more details.\n *\n * You should have received a copy of the GNU Affero General Public License\n * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.\n *\n * The latest code can be found at <https://pydio.com>.\n */\n\n'use strict';\n\nexports.__esModule = true;\n\nvar _globals = require('../globals');\n\nvar PydioApi = require('pydio/http/api');\n\nexports['default'] = function () {\n\n    var crtDir = _globals.pydio.getContextHolder().getContextNode().getPath();\n    if (!_globals.pydio.getUserSelection().isEmpty()) {\n        crtDir = _globals.pydio.getUserSelection().getUniqueNode().getPath();\n    }\n    PydioApi.getClient().request({\n        get_action: \"index\",\n        file: crtDir\n    }, function (transport) {});\n};\n\nmodule.exports = exports['default'];\n","\"use strict\";\n\n/*\n * Copyright 2007-2017 Charles du Jeu - Abstrium SAS <team (at) pyd.io>\n * This file is part of Pydio.\n *\n * Pydio is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Affero General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * Pydio is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU Affero General Public License for more details.\n *\n * You should have received a copy of the GNU Affero General Public License\n * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.\n *\n * The latest code can be found at <https://pydio.com>.\n */\n","/*\n * Copyright 2007-2017 Charles du Jeu - Abstrium SAS <team (at) pyd.io>\n * This file is part of Pydio.\n *\n * Pydio is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Affero General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * Pydio is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU Affero General Public License for more details.\n *\n * You should have received a copy of the GNU Affero General Public License\n * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.\n *\n * The latest code can be found at <https://pydio.com>.\n */\n\n'use strict';\n\nexports.__esModule = true;\n\nvar _globals = require('../globals');\n\nvar PydioApi = require('pydio/http/api');\n\nexports['default'] = function () {\n    var selection = _globals.pydio.getContextHolder();\n    if (selection.isEmpty() || !selection.isUnique()) {\n        return;\n    }\n    var node = selection.getUniqueNode();\n    var isBookmarked = node.getMetadata().get('ajxp_bookmarked') === 'true';\n    PydioApi.getClient().request({\n        get_action: 'get_bookmarks',\n        bm_action: isBookmarked ? 'delete_bookmark' : 'add_bookmark',\n        bm_path: node.getPath()\n    }, function (t) {\n        selection.requireNodeReload(node);\n    });\n};\n\nmodule.exports = exports['default'];\n","/*\n * Copyright 2007-2017 Charles du Jeu - Abstrium SAS <team (at) pyd.io>\n * This file is part of Pydio.\n *\n * Pydio is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Affero General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * Pydio is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU Affero General Public License for more details.\n *\n * You should have received a copy of the GNU Affero General Public License\n * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.\n *\n * The latest code can be found at <https://pydio.com>.\n */\n\n'use strict';\n\nexports.__esModule = true;\n\nvar _globals = require('../globals');\n\nexports['default'] = function () {\n  _globals.pydio.UI.openComponentInModal('PydioCoreActions', 'CreateRepositoryDialog');\n};\n\nmodule.exports = exports['default'];\n","/*\n * Copyright 2007-2017 Charles du Jeu - Abstrium SAS <team (at) pyd.io>\n * This file is part of Pydio.\n *\n * Pydio is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Affero General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * Pydio is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU Affero General Public License for more details.\n *\n * You should have received a copy of the GNU Affero General Public License\n * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.\n *\n * The latest code can be found at <https://pydio.com>.\n */\n\n'use strict';\n\nexports.__esModule = true;\n\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nvar React = require('react');\n\nvar _require$requireLib = require('pydio').requireLib('boot');\n\nvar ActionDialogMixin = _require$requireLib.ActionDialogMixin;\nvar CancelButtonProviderMixin = _require$requireLib.CancelButtonProviderMixin;\nvar SubmitButtonProviderMixin = _require$requireLib.SubmitButtonProviderMixin;\nvar Loader = _require$requireLib.Loader;\n\nvar PydioApi = require('pydio/http/api');\nvar XMLUtils = require('pydio/util/xml');\n\nvar _require = require('material-ui');\n\nvar Divider = _require.Divider;\nvar List = _require.List;\nvar ListItem = _require.ListItem;\nvar FlatButton = _require.FlatButton;\n\n/**\n * Dialog for letting users create a workspace\n */\nexports['default'] = React.createClass({\n    displayName: 'CreateRepositoryDialog',\n\n    mixins: [ActionDialogMixin, CancelButtonProviderMixin, SubmitButtonProviderMixin],\n\n    getDefaultProps: function getDefaultProps() {\n        return {\n            dialogTitleId: '418',\n            dialogIsModal: true,\n            dialogScrollBody: true,\n            dialogPadding: 0\n        };\n    },\n\n    getInitialState: function getInitialState() {\n        return { xmlDefinitions: null, templateId: null, formParameters: null, formValues: {}, formLoaded: false, formValid: false };\n    },\n\n    getButtons: function getButtons() {\n        var updater = arguments.length <= 0 || arguments[0] === undefined ? null : arguments[0];\n\n        if (updater !== null) {\n            this._updater = updater;\n        }\n        var _state = this.state;\n        var templateId = _state.templateId;\n        var formValid = _state.formValid;\n\n        var buttons = [];\n        if (templateId) {\n            buttons.push(React.createElement(FlatButton, { style: { float: 'left' }, label: '<<', onTouchTap: this.resetTemplate.bind(this) }));\n        }\n        buttons.push(React.createElement(FlatButton, { label: 'Cancel', onTouchTap: this.props.onDismiss }));\n        buttons.push(React.createElement(FlatButton, { secondary: true, label: 'OK', disabled: !formValid, onTouchTap: this.submit.bind(this) }));\n        return buttons;\n    },\n\n    componentDidMount: function componentDidMount() {\n        var _this = this;\n\n        require('pydio').requireLib('form', true).then(function () {\n            _this.setState({ formLoaded: true });\n        });\n\n        PydioApi.getClient().request({ get_action: 'get_user_templates_definition' }, function (transport) {\n            _this.setState({ xmlDefinitions: transport.responseXML });\n        });\n        return;\n    },\n\n    submit: function submit() {\n        var _this2 = this;\n\n        var _state2 = this.state;\n        var xmlDefinitions = _state2.xmlDefinitions;\n        var templateId = _state2.templateId;\n        var formParameters = _state2.formParameters;\n        var formValues = _state2.formValues;\n        var formLoaded = _state2.formLoaded;\n\n        var _require$requireLib2 = require('pydio').requireLib('form');\n\n        var Manager = _require$requireLib2.Manager;\n\n        var parameters = Manager.parseParameters(xmlDefinitions, '//template[@repository_id=\"' + templateId + '\"]/param');\n        var postValues = Manager.getValuesForPOST(parameters, formValues, 'DRIVER_OPTION_');\n        if (postValues['DRIVER_OPTION_DISPLAY']) {\n            postValues['DISPLAY'] = postValues['DRIVER_OPTION_DISPLAY'];\n            delete postValues['DRIVER_OPTION_DISPLAY'], delete postValues['DRIVER_OPTION_DISPLAY_ajxptype'];\n        } else {\n            postValues['DISPLAY'] = \"NEW REPOSITORY TEST\";\n        }\n        PydioApi.getClient().request(_extends({\n            get_action: 'user_create_repository',\n            template_id: templateId\n        }, postValues), function (transport) {\n            _this2.dismiss();\n        });\n    },\n\n    chooseTemplate: function chooseTemplate(templateId) {\n        var _this3 = this;\n\n        var _require$requireLib3 = require('pydio').requireLib('form');\n\n        var Manager = _require$requireLib3.Manager;\n        var xmlDefinitions = this.state.xmlDefinitions;\n\n        var parameters = Manager.parseParameters(xmlDefinitions, '//template[@repository_id=\"' + templateId + '\"]/param');\n        var displayParamIndex = parameters.findIndex(function (p) {\n            return p.name === 'DISPLAY';\n        });\n        if (displayParamIndex > -1) {\n            var displayParam = parameters[displayParamIndex];\n            parameters.splice(displayParamIndex, 1);\n            parameters.unshift(displayParam);\n        }\n        this.setState({\n            templateId: templateId,\n            formParameters: parameters\n        }, function () {\n            _this3._updater(_this3.getButtons());\n        });\n    },\n\n    resetTemplate: function resetTemplate() {\n        var _this4 = this;\n\n        this.setState({\n            templateId: null,\n            formParameters: null,\n            formValues: {},\n            formValid: false\n        }, function () {\n            _this4._updater(_this4.getButtons());\n        });\n    },\n\n    onFormValidStatusChange: function onFormValidStatusChange(newValidValue, failedFields) {\n        var _this5 = this;\n\n        this.setState({ formValid: newValidValue }, function () {\n            _this5._updater(_this5.getButtons());\n        });\n    },\n\n    render: function render() {\n        var _this6 = this;\n\n        var _state3 = this.state;\n        var xmlDefinitions = _state3.xmlDefinitions;\n        var templateId = _state3.templateId;\n        var formParameters = _state3.formParameters;\n        var formValues = _state3.formValues;\n        var formLoaded = _state3.formLoaded;\n        var MessageHash = this.props.pydio.MessageHash;\n\n        if (!xmlDefinitions || !formLoaded) {\n            return React.createElement(Loader, null);\n        }\n        if (!templateId) {\n            var templates = XMLUtils.XPathSelectNodes(xmlDefinitions, \"//template\");\n            var items = [];\n\n            var _loop = function (i) {\n                var label = templates[i].getAttribute('repository_label');\n                var tplId = templates[i].getAttribute('repository_id');\n                items.push(React.createElement(ListItem, { key: tplId, primaryText: label, onTouchTap: function () {\n                        return _this6.chooseTemplate(tplId);\n                    } }));\n                if (i < templates.length - 1) {\n                    items.push(React.createElement(Divider, { key: tplId + '-divider' }));\n                }\n            };\n\n            for (var i = 0; i < templates.length; i++) {\n                _loop(i);\n            }\n            return React.createElement(\n                'div',\n                { style: { width: '100%' } },\n                React.createElement(\n                    'p',\n                    { style: { padding: 16, paddingBottom: 0, marginBottom: 0, color: 'rgba(0,0,0,.43)' } },\n                    MessageHash['420']\n                ),\n                React.createElement(\n                    List,\n                    null,\n                    items\n                )\n            );\n        }\n\n        var _require$requireLib4 = require('pydio').requireLib('form');\n\n        var FormPanel = _require$requireLib4.FormPanel;\n\n        return React.createElement(\n            'div',\n            { style: { width: '100%' } },\n            React.createElement(FormPanel, {\n                depth: -2,\n                parameters: formParameters,\n                values: formValues,\n                onChange: function (newValues) {\n                    _this6.setState({ formValues: newValues });\n                },\n                onValidStatusChange: this.onFormValidStatusChange.bind(this)\n            })\n        );\n\n        return React.createElement('div', null);\n    }\n\n});\nmodule.exports = exports['default'];\n","/*\n * Copyright 2007-2017 Charles du Jeu - Abstrium SAS <team (at) pyd.io>\n * This file is part of Pydio.\n *\n * Pydio is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Affero General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * Pydio is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU Affero General Public License for more details.\n *\n * You should have received a copy of the GNU Affero General Public License\n * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.\n *\n * The latest code can be found at <https://pydio.com>.\n */\n\n'use strict';\n\nexports.__esModule = true;\n\nvar _globals = require('../globals');\n\nvar _materialUi = require('material-ui');\n\nvar React = require('react');\nvar PydioApi = require('pydio/http/api');\nvar BootUI = require('pydio/http/resources-manager').requireLib('boot');\nvar ActionDialogMixin = BootUI.ActionDialogMixin;\nvar SubmitButtonProviderMixin = BootUI.SubmitButtonProviderMixin;\nvar CancelButtonProviderMixin = BootUI.CancelButtonProviderMixin;\nvar AsyncComponent = BootUI.AsyncComponent;\n\nvar PasswordDialog = React.createClass({\n    displayName: 'PasswordDialog',\n\n    mixins: [ActionDialogMixin],\n    getInitialState: function getInitialState() {\n        return { passValid: false };\n    },\n    getDefaultProps: function getDefaultProps() {\n        return {\n            dialogTitle: _globals.pydio.MessageHash[194],\n            dialogIsModal: true,\n            dialogSize: 'sm'\n        };\n    },\n    getButtons: function getButtons() {\n        var _this = this;\n\n        var updater = arguments.length <= 0 || arguments[0] === undefined ? null : arguments[0];\n\n        if (updater) this._updater = updater;\n        var buttons = [];\n        if (!this.props.locked) {\n            buttons.push(React.createElement(_materialUi.FlatButton, { label: this.props.pydio.MessageHash[49], onTouchTap: function () {\n                    return _this.dismiss();\n                } }));\n        }\n        buttons.push(React.createElement(_materialUi.FlatButton, { label: this.props.pydio.MessageHash[48], onTouchTap: this.submit.bind(this), disabled: !this.state.passValid }));\n        return buttons;\n    },\n\n    submit: function submit() {\n        if (!this.state.passValid) {\n            return false;\n        }\n        this.refs.passwordForm.instance.post((function (value) {\n            if (value) this.dismiss();\n        }).bind(this));\n    },\n    passValidStatusChange: function passValidStatusChange(status) {\n        var _this2 = this;\n\n        this.setState({ passValid: status }, function () {\n            _this2._updater(_this2.getButtons());\n        });\n    },\n\n    render: function render() {\n\n        return React.createElement(AsyncComponent, {\n            namespace: 'UserAccount',\n            componentName: 'PasswordForm',\n            pydio: this.props.pydio,\n            ref: 'passwordForm',\n            onValidStatusChange: this.passValidStatusChange\n        });\n    }\n\n});\n\nexports['default'] = PasswordDialog;\nmodule.exports = exports['default'];\n","/*\n * Copyright 2007-2017 Charles du Jeu - Abstrium SAS <team (at) pyd.io>\n * This file is part of Pydio.\n *\n * Pydio is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Affero General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * Pydio is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU Affero General Public License for more details.\n *\n * You should have received a copy of the GNU Affero General Public License\n * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.\n *\n * The latest code can be found at <https://pydio.com>.\n */\n\n'use strict';\n\nexports.__esModule = true;\nvar React = require('react');\nvar PydioApi = require('pydio/http/api');\nvar BootUI = require('pydio/http/resources-manager').requireLib('boot');\nvar ActionDialogMixin = BootUI.ActionDialogMixin;\nvar SubmitButtonProviderMixin = BootUI.SubmitButtonProviderMixin;\nvar Loader = BootUI.Loader;\n\nvar SplashDialog = React.createClass({\n    displayName: 'SplashDialog',\n\n    mixins: [ActionDialogMixin, SubmitButtonProviderMixin],\n\n    getDefaultProps: function getDefaultProps() {\n        return {\n            dialogTitle: '',\n            dialogSize: 'lg',\n            dialogIsModal: false,\n            dialogPadding: false,\n            dialogScrollBody: true\n        };\n    },\n    submit: function submit() {\n        this.dismiss();\n    },\n\n    getInitialState: function getInitialState() {\n        return { aboutContent: null };\n    },\n\n    componentDidMount: function componentDidMount() {\n\n        PydioApi.getClient().request({\n            get_action: 'display_doc',\n            doc_file: 'CREDITS'\n        }, (function (transport) {\n            this.setState({\n                aboutContent: transport.responseText\n            });\n        }).bind(this));\n    },\n\n    render: function render() {\n        var _this = this;\n\n        if (!this.state.aboutContent) {\n            return React.createElement(Loader, { style: { minHeight: 200 } });\n        } else {\n            var ct = function ct() {\n                return { __html: _this.state.aboutContent };\n            };\n            return React.createElement('div', { style: { fontSize: 13, padding: '0 10px' }, dangerouslySetInnerHTML: ct() });\n        }\n    }\n\n});\n\nexports['default'] = SplashDialog;\nmodule.exports = exports['default'];\n","/*\n * Copyright 2007-2017 Charles du Jeu - Abstrium SAS <team (at) pyd.io>\n * This file is part of Pydio.\n *\n * Pydio is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Affero General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * Pydio is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU Affero General Public License for more details.\n *\n * You should have received a copy of the GNU Affero General Public License\n * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.\n *\n * The latest code can be found at <https://pydio.com>.\n */\n\n\"use strict\";\n\nexports.__esModule = true;\nvar global = window;\nvar pydio = global.pydio;\nvar MessageHash = pydio.MessageHash;\nexports.global = global;\nexports.pydio = pydio;\nexports.MessageHash = MessageHash;\n","/*\n * Copyright 2007-2017 Charles du Jeu - Abstrium SAS <team (at) pyd.io>\n * This file is part of Pydio.\n *\n * Pydio is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Affero General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * Pydio is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU Affero General Public License for more details.\n *\n * You should have received a copy of the GNU Affero General Public License\n * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.\n *\n * The latest code can be found at <https://pydio.com>.\n */\n\n'use strict';\n\nexports.__esModule = true;\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar _dialogSplashDialog = require('./dialog/SplashDialog');\n\nvar _dialogSplashDialog2 = _interopRequireDefault(_dialogSplashDialog);\n\nvar _dialogPasswordDialog = require('./dialog/PasswordDialog');\n\nvar _dialogPasswordDialog2 = _interopRequireDefault(_dialogPasswordDialog);\n\nvar _dialogCreateRepositoryDialog = require('./dialog/CreateRepositoryDialog');\n\nvar _dialogCreateRepositoryDialog2 = _interopRequireDefault(_dialogCreateRepositoryDialog);\n\nvar Callbacks = {\n    switchLanguage: require('./callbacks/switchLanguage'),\n    userCreateRepository: require('./callbacks/userCreateRepository'),\n    changePass: require('./callbacks/changePass'),\n    launchIndexation: require('./callbacks/launchIndexation'),\n    toggleBookmark: require('./callbacks/toggleBookmark'),\n    clearPluginsCache: require('./callbacks/clearPluginsCache'),\n    dismissUserAlert: require('./callbacks/dismissUserAlert'),\n    activateDesktopNotifications: require('./callbacks/activateDesktopNotifications')\n};\n\nvar Navigation = {\n    splash: require('./navigation/splash'),\n    up: require('./navigation/up'),\n    refresh: require('./navigation/refresh'),\n    externalSelection: require('./navigation/externalSelection'),\n    openGoPro: require('./navigation/openGoPro'),\n    switchToSettings: require('./navigation/switchToSettings')\n};\n\nexports.Callbacks = Callbacks;\nexports.Navigation = Navigation;\nexports.SplashDialog = _dialogSplashDialog2['default'];\nexports.PasswordDialog = _dialogPasswordDialog2['default'];\nexports.CreateRepositoryDialog = _dialogCreateRepositoryDialog2['default'];\n","/*\n * Copyright 2007-2017 Charles du Jeu - Abstrium SAS <team (at) pyd.io>\n * This file is part of Pydio.\n *\n * Pydio is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Affero General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * Pydio is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU Affero General Public License for more details.\n *\n * You should have received a copy of the GNU Affero General Public License\n * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.\n *\n * The latest code can be found at <https://pydio.com>.\n */\n\n'use strict';\n\nexports.__esModule = true;\n\nvar _globals = require('../globals');\n\nexports['default'] = function () {\n\n    var userSelection = _globals.pydio.getUserSelection();\n    if (userSelection.isUnique() && !userSelection.hasDir()) {\n        var fileName = userSelection.getUniqueFileName();\n        var selectorData = _globals.pydio.getController().selectorData;\n        if (selectorData.get('type') == \"ckeditor\") {\n            var ckData = selectorData.get('data');\n            if (ckData['CKEditorFuncNum']) {\n                var imagePath = fileName;\n                if (ckData['relative_path']) {\n                    imagePath = ckData['relative_path'] + fileName;\n                }\n                _globals.global.opener.CKEDITOR.tools.callFunction(ckData['CKEditorFuncNum'], imagePath);\n                _globals.global.close();\n            }\n        }\n    }\n};\n\nmodule.exports = exports['default'];\n","/*\n * Copyright 2007-2017 Charles du Jeu - Abstrium SAS <team (at) pyd.io>\n * This file is part of Pydio.\n *\n * Pydio is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Affero General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * Pydio is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU Affero General Public License for more details.\n *\n * You should have received a copy of the GNU Affero General Public License\n * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.\n *\n * The latest code can be found at <https://pydio.com>.\n */\n\n'use strict';\n\nexports.__esModule = true;\n\nvar _globals = require('../globals');\n\nexports['default'] = function () {\n  _globals.global.open('https://pydio.com/en/go-pro?referrer=settings');\n};\n\nmodule.exports = exports['default'];\n","/*\n * Copyright 2007-2017 Charles du Jeu - Abstrium SAS <team (at) pyd.io>\n * This file is part of Pydio.\n *\n * Pydio is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Affero General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * Pydio is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU Affero General Public License for more details.\n *\n * You should have received a copy of the GNU Affero General Public License\n * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.\n *\n * The latest code can be found at <https://pydio.com>.\n */\n\n'use strict';\n\nexports.__esModule = true;\n\nvar _globals = require('../globals');\n\nexports['default'] = function () {\n\n  _globals.pydio.fireContextRefresh();\n};\n\nmodule.exports = exports['default'];\n","/*\n * Copyright 2007-2017 Charles du Jeu - Abstrium SAS <team (at) pyd.io>\n * This file is part of Pydio.\n *\n * Pydio is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Affero General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * Pydio is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU Affero General Public License for more details.\n *\n * You should have received a copy of the GNU Affero General Public License\n * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.\n *\n * The latest code can be found at <https://pydio.com>.\n */\n\n'use strict';\n\nexports.__esModule = true;\n\nvar _globals = require('../globals');\n\nexports['default'] = function () {\n\n  _globals.pydio.UI.openComponentInModal('PydioCoreActions', 'SplashDialog');\n};\n\nmodule.exports = exports['default'];\n","/*\n * Copyright 2007-2017 Charles du Jeu - Abstrium SAS <team (at) pyd.io>\n * This file is part of Pydio.\n *\n * Pydio is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Affero General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * Pydio is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU Affero General Public License for more details.\n *\n * You should have received a copy of the GNU Affero General Public License\n * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.\n *\n * The latest code can be found at <https://pydio.com>.\n */\n\n'use strict';\n\nexports.__esModule = true;\n\nvar _globals = require('../globals');\n\nexports['default'] = function () {\n\n    if (!_globals.pydio.repositoryId || _globals.pydio.repositoryId != \"ajxp_conf\") {\n        _globals.pydio.triggerRepositoryChange('ajxp_conf');\n    }\n};\n\nmodule.exports = exports['default'];\n","/*\n * Copyright 2007-2017 Charles du Jeu - Abstrium SAS <team (at) pyd.io>\n * This file is part of Pydio.\n *\n * Pydio is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Affero General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * Pydio is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU Affero General Public License for more details.\n *\n * You should have received a copy of the GNU Affero General Public License\n * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.\n *\n * The latest code can be found at <https://pydio.com>.\n */\n\n'use strict';\n\nexports.__esModule = true;\n\nvar _globals = require('../globals');\n\nexports['default'] = function () {\n\n  _globals.pydio.fireContextUp();\n};\n\nmodule.exports = exports['default'];\n"]}