/* jshint ignore:start */

/* jshint ignore:end */

define('ghost/acceptance-tests/sinon', ['exports', 'ember-sinon/acceptance-tests/sinon'], function (exports, sinon) {

	'use strict';



	exports.default = sinon.default;

});
define('ghost/adapters/application', ['exports', 'ghost/adapters/embedded-relation-adapter'], function (exports, EmbeddedRelationAdapter) {

	'use strict';

	var ApplicationAdapter = EmbeddedRelationAdapter['default'].extend();

	exports['default'] = ApplicationAdapter;

});
define('ghost/adapters/base', ['exports', 'ember-data', 'ghost/utils/ghost-paths'], function (exports, DS, ghostPaths) {

    'use strict';

    var BaseAdapter = DS['default'].RESTAdapter.extend({
        host: window.location.origin,
        namespace: ghostPaths['default']().apiRoot.slice(1),

        findQuery: function findQuery(store, type, query) {
            var id;

            if (query.id) {
                id = query.id;
                delete query.id;
            }

            return this.ajax(this.buildURL(type.modelName, id), 'GET', { data: query });
        },

        buildURL: function buildURL(type, id) {
            // Ensure trailing slashes
            var url = this._super(type, id);

            if (url.slice(-1) !== '/') {
                url += '/';
            }

            return url;
        },

        // Override deleteRecord to disregard the response body on 2xx responses.
        // This is currently needed because the API is returning status 200 along
        // with the JSON object for the deleted entity and Ember expects an empty
        // response body for successful DELETEs.
        // Non-2xx (failure) responses will still work correctly as Ember will turn
        // them into rejected promises.
        deleteRecord: function deleteRecord() {
            var response = this._super.apply(this, arguments);

            return response.then(function () {
                return null;
            });
        }
    });

    exports['default'] = BaseAdapter;

});
define('ghost/adapters/embedded-relation-adapter', ['exports', 'ember', 'ghost/adapters/base'], function (exports, Ember, BaseAdapter) {

    'use strict';

    var EmbeddedRelationAdapter = BaseAdapter['default'].extend({
        find: function find(store, type, id) {
            return this.ajax(this.buildIncludeURL(store, type, id), 'GET');
        },

        findQuery: function findQuery(store, type, query) {
            return this._super(store, type, this.buildQuery(store, type, query));
        },

        findAll: function findAll(store, type, sinceToken) {
            var query = {};

            if (sinceToken) {
                query.since = sinceToken;
            }

            return this.findQuery(store, type, query);
        },

        createRecord: function createRecord(store, type, record) {
            return this.saveRecord(store, type, record, { method: 'POST' });
        },

        updateRecord: function updateRecord(store, type, record) {
            var options = {
                method: 'PUT',
                id: Ember['default'].get(record, 'id')
            };

            return this.saveRecord(store, type, record, options);
        },

        saveRecord: function saveRecord(store, type, record, options) {
            options = options || {};

            var url = this.buildIncludeURL(store, type, options.id),
                payload = this.preparePayload(store, type, record);

            return this.ajax(url, options.method, payload);
        },

        preparePayload: function preparePayload(store, type, record) {
            var serializer = store.serializerFor(type.modelName),
                payload = {};

            serializer.serializeIntoHash(payload, type, record);

            return { data: payload };
        },

        buildIncludeURL: function buildIncludeURL(store, type, id) {
            var url = this.buildURL(type.modelName, id),
                includes = this.getEmbeddedRelations(store, type);

            if (includes.length) {
                url += '?include=' + includes.join(',');
            }

            return url;
        },

        buildQuery: function buildQuery(store, type, options) {
            var toInclude = this.getEmbeddedRelations(store, type),
                query = options || {},
                deDupe = {};

            if (toInclude.length) {
                // If this is a find by id, build a query object and attach the includes
                if (typeof options === 'string' || typeof options === 'number') {
                    query = {};
                    query.id = options;
                    query.include = toInclude.join(',');
                } else if (typeof options === 'object' || Ember['default'].isNone(options)) {
                    // If this is a find all (no existing query object) build one and attach
                    // the includes.
                    // If this is a find with an existing query object then merge the includes
                    // into the existing object. Existing properties and includes are preserved.
                    query = query || {};
                    toInclude = toInclude.concat(query.include ? query.include.split(',') : []);

                    toInclude.forEach(function (include) {
                        deDupe[include] = true;
                    });

                    query.include = Object.keys(deDupe).join(',');
                }
            }

            return query;
        },

        getEmbeddedRelations: function getEmbeddedRelations(store, type) {
            var model = store.modelFor(type),
                ret = [];

            // Iterate through the model's relationships and build a list
            // of those that need to be pulled in via "include" from the API
            model.eachRelationship(function (name, meta) {
                if (meta.kind === 'hasMany' && Object.prototype.hasOwnProperty.call(meta.options, 'embedded') && meta.options.embedded === 'always') {
                    ret.push(name);
                }
            });

            return ret;
        }
    });

    exports['default'] = EmbeddedRelationAdapter;

});
define('ghost/adapters/setting', ['exports', 'ghost/adapters/application'], function (exports, ApplicationAdapter) {

    'use strict';

    var SettingAdapter = ApplicationAdapter['default'].extend({
        updateRecord: function updateRecord(store, type, record) {
            var data = {},
                serializer = store.serializerFor(type.modelName);

            // remove the fake id that we added onto the model.
            delete record.id;

            // use the SettingSerializer to transform the model back into
            // an array of settings objects like the API expects
            serializer.serializeIntoHash(data, type, record);

            // use the ApplicationAdapter's buildURL method but do not
            // pass in an id.
            return this.ajax(this.buildURL(type.modelName), 'PUT', { data: data });
        }
    });

    exports['default'] = SettingAdapter;

});
define('ghost/adapters/user', ['exports', 'ghost/adapters/application'], function (exports, ApplicationAdapter) {

    'use strict';

    var UserAdapter = ApplicationAdapter['default'].extend({
        find: function find(store, type, id) {
            return this.findQuery(store, type, { id: id, status: 'all' });
        }
    });

    exports['default'] = UserAdapter;

});
define('ghost/app', ['exports', 'ember', 'ember/resolver', 'ember/load-initializers', 'ghost/utils/link-component', 'ghost/utils/text-field', 'ghost/config/environment'], function (exports, Ember, Resolver, loadInitializers, __dep3__, __dep4__, config) {

    'use strict';

    Ember['default'].MODEL_FACTORY_INJECTIONS = true;

    var App = Ember['default'].Application.extend({
        modulePrefix: config['default'].modulePrefix,
        podModulePrefix: config['default'].podModulePrefix,
        Resolver: Resolver['default']
    });

    loadInitializers['default'](App, config['default'].modulePrefix);

    exports['default'] = App;

});
define('ghost/assets/lib/uploader', ['exports', 'ghost/utils/ghost-paths'], function (exports, ghostPaths) {

    'use strict';

    var UploadUi,
        upload,
        Ghost = ghostPaths['default']();

    UploadUi = function ($dropzone, settings) {
        var $url = '<div class="js-url"><input class="url js-upload-url gh-input" type="url" placeholder="http://"/></div>',
            $cancel = '<a class="image-cancel icon-trash js-cancel" title="Delete"><span class="hidden">Delete</span></a>',
            $progress = $('<div />', {
            'class': 'js-upload-progress progress progress-success active',
            role: 'progressbar',
            'aria-valuemin': '0',
            'aria-valuemax': '100'
        }).append($('<div />', {
            'class': 'js-upload-progress-bar bar',
            style: 'width:0%'
        }));

        $.extend(this, {
            complete: function complete(result) {
                var self = this;

                function showImage(width, height) {
                    $dropzone.find('img.js-upload-target').attr({ width: width, height: height }).css({ display: 'block' });
                    $dropzone.find('.fileupload-loading').remove();
                    $dropzone.css({ height: 'auto' });
                    $dropzone.delay(250).animate({ opacity: 100 }, 1000, function () {
                        $('.js-button-accept').prop('disabled', false);
                        self.init();
                    });
                }

                function animateDropzone($img) {
                    $dropzone.animate({ opacity: 0 }, 250, function () {
                        $dropzone.removeClass('image-uploader').addClass('pre-image-uploader');
                        $dropzone.css({ minHeight: 0 });
                        self.removeExtras();
                        $dropzone.animate({ height: $img.height() }, 250, function () {
                            showImage($img.width(), $img.height());
                        });
                    });
                }

                function preLoadImage() {
                    var $img = $dropzone.find('img.js-upload-target').attr({ src: '', width: 'auto', height: 'auto' });

                    $progress.animate({ opacity: 0 }, 250, function () {
                        $dropzone.find('span.media').after('<img class="fileupload-loading"  src="' + Ghost.subdir + '/ghost/img/loadingcat.gif" />');
                    });
                    $img.one('load', function () {
                        $dropzone.trigger('uploadsuccess', [result]);
                        animateDropzone($img);
                    }).attr('src', result);
                }
                preLoadImage();
            },

            bindFileUpload: function bindFileUpload() {
                var self = this;

                $dropzone.find('.js-fileupload').fileupload().fileupload('option', {
                    url: Ghost.apiRoot + '/uploads/',
                    add: function add(e, data) {
                        /*jshint unused:false*/
                        $('.js-button-accept').prop('disabled', true);
                        $dropzone.find('.js-fileupload').removeClass('right');
                        $dropzone.find('.js-url').remove();
                        $progress.find('.js-upload-progress-bar').removeClass('fail');
                        $dropzone.trigger('uploadstart', [$dropzone.attr('id')]);
                        $dropzone.find('span.media, div.description, a.image-url, a.image-webcam').animate({ opacity: 0 }, 250, function () {
                            $dropzone.find('div.description').hide().css({ opacity: 100 });
                            if (settings.progressbar) {
                                $dropzone.find('div.js-fail').after($progress);
                                $progress.animate({ opacity: 100 }, 250);
                            }
                            data.submit();
                        });
                    },
                    dropZone: settings.fileStorage ? $dropzone : null,
                    progressall: function progressall(e, data) {
                        /*jshint unused:false*/
                        var progress = parseInt(data.loaded / data.total * 100, 10);
                        if (settings.progressbar) {
                            $dropzone.trigger('uploadprogress', [progress, data]);
                            $progress.find('.js-upload-progress-bar').css('width', progress + '%');
                        }
                    },
                    fail: function fail(e, data) {
                        /*jshint unused:false*/
                        $('.js-button-accept').prop('disabled', false);
                        $dropzone.trigger('uploadfailure', [data.result]);
                        $dropzone.find('.js-upload-progress-bar').addClass('fail');
                        if (data.jqXHR.status === 413) {
                            $dropzone.find('div.js-fail').text('The image you uploaded was larger than the maximum file size your server allows.');
                        } else if (data.jqXHR.status === 415) {
                            $dropzone.find('div.js-fail').text('The image type you uploaded is not supported. Please use .PNG, .JPG, .GIF, .SVG.');
                        } else {
                            $dropzone.find('div.js-fail').text('Something went wrong :(');
                        }
                        $dropzone.find('div.js-fail, button.js-fail').fadeIn(1500);
                        $dropzone.find('button.js-fail').on('click', function () {
                            $dropzone.css({ minHeight: 0 });
                            $dropzone.find('div.description').show();
                            self.removeExtras();
                            self.init();
                        });
                    },
                    done: function done(e, data) {
                        /*jshint unused:false*/
                        self.complete(data.result);
                    }
                });
            },

            buildExtras: function buildExtras() {
                if (!$dropzone.find('span.media')[0]) {
                    $dropzone.prepend('<span class="media"><span class="hidden">Image Upload</span></span>');
                }
                if (!$dropzone.find('div.description')[0]) {
                    $dropzone.append('<div class="description">Add image</div>');
                }
                if (!$dropzone.find('div.js-fail')[0]) {
                    $dropzone.append('<div class="js-fail failed" style="display: none">Something went wrong :(</div>');
                }
                if (!$dropzone.find('button.js-fail')[0]) {
                    $dropzone.append('<button class="js-fail btn btn-green" style="display: none">Try Again</button>');
                }
                if (!$dropzone.find('a.image-url')[0]) {
                    $dropzone.append('<a class="image-url" title="Add image from URL"><i class="icon-link"><span class="hidden">URL</span></i></a>');
                }
                // if (!$dropzone.find('a.image-webcam')[0]) {
                //     $dropzone.append('<a class="image-webcam" title="Add image from webcam"><span class="hidden">Webcam</span></a>');
                // }
            },

            removeExtras: function removeExtras() {
                $dropzone.find('span.media, div.js-upload-progress, a.image-url, a.image-upload, a.image-webcam, div.js-fail, button.js-fail, a.js-cancel').remove();
            },

            initWithDropzone: function initWithDropzone() {
                var self = this;

                // This is the start point if no image exists
                $dropzone.find('img.js-upload-target').css({ display: 'none' });
                $dropzone.find('div.description').show();
                $dropzone.removeClass('pre-image-uploader image-uploader-url').addClass('image-uploader');
                this.removeExtras();
                this.buildExtras();
                this.bindFileUpload();
                if (!settings.fileStorage) {
                    self.initUrl();
                    return;
                }
                $dropzone.find('a.image-url').on('click', function () {
                    self.initUrl();
                });
            },
            initUrl: function initUrl() {
                var self = this,
                    val;
                this.removeExtras();
                $dropzone.addClass('image-uploader-url').removeClass('pre-image-uploader');
                $dropzone.find('.js-fileupload').addClass('right');
                $dropzone.find('.js-cancel').on('click', function () {
                    $dropzone.find('.js-url').remove();
                    $dropzone.find('.js-fileupload').removeClass('right');
                    $dropzone.trigger('imagecleared');
                    self.removeExtras();
                    self.initWithDropzone();
                });

                $dropzone.find('div.description').before($url);

                if (settings.editor) {
                    $dropzone.find('div.js-url').append('<button class="btn btn-blue js-button-accept gh-input">Save</button>');
                    $dropzone.find('div.description').hide();
                }

                $dropzone.find('.js-button-accept').on('click', function () {
                    val = $dropzone.find('.js-upload-url').val();
                    $dropzone.find('div.description').hide();
                    $dropzone.find('.js-fileupload').removeClass('right');
                    $dropzone.find('.js-url').remove();
                    if (val === '') {
                        $dropzone.trigger('uploadsuccess', 'http://');
                        self.initWithDropzone();
                    } else {
                        self.complete(val);
                    }
                });

                // Only show the toggle icon if there is a dropzone mode to go back to
                if (settings.fileStorage !== false) {
                    $dropzone.append('<a class="image-upload icon-photos" title="Add image"><span class="hidden">Upload</span></a>');
                }

                $dropzone.find('a.image-upload').on('click', function () {
                    $dropzone.find('.js-url').remove();
                    $dropzone.find('.js-fileupload').removeClass('right');
                    self.initWithDropzone();
                });
            },

            initWithImage: function initWithImage() {
                var self = this;

                // This is the start point if an image already exists
                $dropzone.removeClass('image-uploader image-uploader-url').addClass('pre-image-uploader');
                $dropzone.find('div.description').hide();
                $dropzone.find('img.js-upload-target').show();
                $dropzone.append($cancel);
                $dropzone.find('.js-cancel').on('click', function () {
                    $dropzone.find('img.js-upload-target').attr({ src: '' });
                    $dropzone.find('div.description').show();
                    $dropzone.trigger('imagecleared');
                    $dropzone.delay(250).animate({ opacity: 100 }, 1000, function () {
                        self.init();
                    });

                    $dropzone.trigger('uploadsuccess', 'http://');
                    self.initWithDropzone();
                });
            },

            init: function init() {
                var imageTarget = $dropzone.find('img.js-upload-target');
                // First check if field image is defined by checking for js-upload-target class
                if (!imageTarget[0]) {
                    // This ensures there is an image we can hook into to display uploaded image
                    $dropzone.prepend('<img class="js-upload-target" style="display: none"  src="" />');
                }
                $('.js-button-accept').prop('disabled', false);
                if (imageTarget.attr('src') === '' || imageTarget.attr('src') === undefined) {
                    this.initWithDropzone();
                } else {
                    this.initWithImage();
                }
            },

            reset: function reset() {
                $dropzone.find('.js-url').remove();
                $dropzone.find('.js-fileupload').removeClass('right');
                this.removeExtras();
                this.initWithDropzone();
            }
        });
    };

    upload = function (options) {
        var settings = $.extend({
            progressbar: true,
            editor: false,
            fileStorage: true
        }, options);

        return this.each(function () {
            var $dropzone = $(this),
                ui;

            ui = new UploadUi($dropzone, settings);
            this.uploaderUi = ui;
            ui.init();
        });
    };

    exports['default'] = upload;

});
define('ghost/authenticators/oauth2', ['exports', 'ember', 'simple-auth-oauth2/authenticators/oauth2'], function (exports, Ember, Authenticator) {

    'use strict';

    exports['default'] = Authenticator['default'].extend({
        config: Ember['default'].inject.service(),
        makeRequest: function makeRequest(url, data) {
            data.client_id = this.get('config.clientId');
            data.client_secret = this.get('config.clientSecret');
            return this._super(url, data);
        }
    });

});
define('ghost/components/ember-selectize', ['exports', 'ember-cli-selectize/components/ember-selectize'], function (exports, EmberSelectizeComponent) {

	'use strict';

	exports['default'] = EmberSelectizeComponent['default'];

});
define('ghost/components/gh-activating-list-item', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    exports['default'] = Ember['default'].Component.extend({
        tagName: 'li',
        classNameBindings: ['active'],
        active: false,
        linkClasses: null,

        unfocusLink: (function () {
            this.$('a').blur();
        }).on('click'),

        actions: {
            setActive: function setActive(value) {
                Ember['default'].run.schedule('afterRender', this, function () {
                    this.set('active', value);
                });
            }
        }
    });

});
define('ghost/components/gh-alert', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    exports['default'] = Ember['default'].Component.extend({
        tagName: 'article',
        classNames: ['gh-alert'],
        classNameBindings: ['typeClass'],

        notifications: Ember['default'].inject.service(),

        typeClass: Ember['default'].computed(function () {
            var classes = '',
                message = this.get('message'),
                type = Ember['default'].get(message, 'type'),
                typeMapping;

            typeMapping = {
                success: 'green',
                error: 'red',
                warn: 'yellow',
                info: 'blue'
            };

            if (typeMapping[type] !== undefined) {
                classes += 'gh-alert-' + typeMapping[type];
            }

            return classes;
        }),

        actions: {
            closeNotification: function closeNotification() {
                this.get('notifications').closeNotification(this.get('message'));
            }
        }
    });

});
define('ghost/components/gh-alerts', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    exports['default'] = Ember['default'].Component.extend({
        tagName: 'aside',
        classNames: 'gh-alerts',

        notifications: Ember['default'].inject.service(),

        messages: Ember['default'].computed.alias('notifications.alerts'),

        messageCountObserver: Ember['default'].observer('messages.[]', function () {
            this.sendAction('notify', this.get('messages').length);
        })
    });

});
define('ghost/components/gh-app', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    exports['default'] = Ember['default'].Component.extend({
        classNames: ['gh-app'],

        showSettingsMenu: false,

        toggleSettingsMenuBodyClass: Ember['default'].observer('showSettingsMenu', function () {
            var showSettingsMenu = this.get('showSettingsMenu');

            Ember['default'].$('body').toggleClass('settings-menu-expanded', showSettingsMenu);
        })
    });

});
define('ghost/components/gh-blog-url', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    var blogUrl = Ember['default'].Component.extend({
        tagName: '',
        config: Ember['default'].inject.service()
    });

    exports['default'] = blogUrl;

});
define('ghost/components/gh-cm-editor', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    /* global CodeMirror */
    var CodeMirrorEditor = Ember['default'].Component.extend({

        // DOM stuff
        classNameBindings: ['isFocused:focused'],
        isFocused: false,

        value: '', // make sure a value exists
        editor: null, // reference to CodeMirror editor

        // options for the editor
        lineNumbers: true,
        indentUnit: 4,
        mode: 'htmlmixed',
        theme: 'xq-light',

        didInsertElement: function didInsertElement() {
            var options = this.getProperties('lineNumbers', 'indentUnit', 'mode', 'theme'),
                self = this,
                editor;
            editor = new CodeMirror(this.get('element'), options);
            editor.getDoc().setValue(this.get('value'));

            // events
            editor.on('focus', function () {
                self.set('isFocused', true);
            });
            editor.on('blur', function () {
                self.set('isFocused', false);
            });
            editor.on('change', function () {
                self.set('value', editor.getDoc().getValue());
            });

            this.set('editor', editor);
        },

        willDestroyElement: function willDestroyElement() {
            var editor = this.get('editor').getWrapperElement();
            editor.parentNode.removeChild(editor);
            this.set('editor', null);
        }

    });

    exports['default'] = CodeMirrorEditor;

});
define('ghost/components/gh-content-cover', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    /*

    Implements a div for covering the page content
    when in a menu context that, for example,
    should be closed when the user clicks elsewhere.

    Example:
    ```
    {{gh-content-cover onClick="closeMenus" onMouseEnter="closeAutoNav"}}
    ```
    **/

    exports['default'] = Ember['default'].Component.extend({
        classNames: ['content-cover'],

        onClick: null,
        onMouseEnter: null,

        click: function click() {
            this.sendAction('onClick');
        },

        mouseEnter: function mouseEnter() {
            this.sendAction('onMouseEnter');
        }
    });

});
define('ghost/components/gh-content-preview-content', ['exports', 'ember', 'ghost/utils/set-scroll-classname'], function (exports, Ember, setScrollClassName) {

    'use strict';

    exports['default'] = Ember['default'].Component.extend({
        classNames: ['content-preview-content'],

        content: null,

        didRender: function didRender() {
            var el = this.$();

            el.on('scroll', Ember['default'].run.bind(el, setScrollClassName['default'], {
                target: el.closest('.content-preview'),
                offset: 10
            }));
        },

        didReceiveAttrs: function didReceiveAttrs(options) {
            // adjust when didReceiveAttrs gets both newAttrs and oldAttrs
            if (options.newAttrs.content && this.get('content') !== options.newAttrs.content.value) {
                var el = this.$();

                if (el) {
                    el.closest('.content-preview').scrollTop(0);
                }
            }
        },

        willDestroyElement: function willDestroyElement() {
            var el = this.$();

            el.off('scroll');
        }
    });

});
define('ghost/components/gh-content-view-container', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    exports['default'] = Ember['default'].Component.extend({
        tagName: 'section',
        classNames: ['gh-view', 'content-view-container'],

        previewIsHidden: false,

        resizeService: Ember['default'].inject.service(),

        _resizeListener: null,

        calculatePreviewIsHidden: function calculatePreviewIsHidden() {
            if (this.$('.content-preview').length) {
                this.set('previewIsHidden', !this.$('.content-preview').is(':visible'));
            }
        },

        didInsertElement: function didInsertElement() {
            this._super.apply(this, arguments);
            this._resizeListener = Ember['default'].run.bind(this, this.calculatePreviewIsHidden);
            this.get('resizeService').on('debouncedDidResize', this._resizeListener);
            this.calculatePreviewIsHidden();
        },

        willDestroy: function willDestroy() {
            this.get('resizeService').off('debouncedDidResize', this._resizeListener);
        }
    });

});
define('ghost/components/gh-dropdown-button', ['exports', 'ember', 'ghost/mixins/dropdown-mixin'], function (exports, Ember, DropdownMixin) {

    'use strict';

    exports['default'] = Ember['default'].Component.extend(DropdownMixin['default'], {
        tagName: 'button',
        attributeBindings: 'role',
        role: 'button',

        // matches with the dropdown this button toggles
        dropdownName: null,

        dropdown: Ember['default'].inject.service(),

        // Notify dropdown service this dropdown should be toggled
        click: function click(event) {
            this._super(event);
            this.get('dropdown').toggleDropdown(this.get('dropdownName'), this);
        }
    });

});
define('ghost/components/gh-dropdown', ['exports', 'ember', 'ghost/mixins/dropdown-mixin'], function (exports, Ember, DropdownMixin) {

    'use strict';

    exports['default'] = Ember['default'].Component.extend(DropdownMixin['default'], {
        classNames: 'dropdown',
        classNameBindings: ['fadeIn:fade-in-scale:fade-out', 'isOpen:open:closed'],

        name: null,
        closeOnClick: false,

        // Helps track the user re-opening the menu while it's fading out.
        closing: false,

        // Helps track whether the dropdown is open or closes, or in a transition to either
        isOpen: false,

        // Managed the toggle between the fade-in and fade-out classes
        fadeIn: Ember['default'].computed('isOpen', 'closing', function () {
            return this.get('isOpen') && !this.get('closing');
        }),

        dropdown: Ember['default'].inject.service(),

        open: function open() {
            this.set('isOpen', true);
            this.set('closing', false);
            this.set('button.isOpen', true);
        },

        close: function close() {
            var self = this;

            this.set('closing', true);

            if (this.get('button')) {
                this.set('button.isOpen', false);
            }
            this.$().on('animationend webkitAnimationEnd oanimationend MSAnimationEnd', function (event) {
                if (event.originalEvent.animationName === 'fade-out') {
                    if (self.get('closing')) {
                        self.set('isOpen', false);
                        self.set('closing', false);
                    }
                }
            });
        },

        // Called by the dropdown service when any dropdown button is clicked.
        toggle: function toggle(options) {
            var isClosing = this.get('closing'),
                isOpen = this.get('isOpen'),
                name = this.get('name'),
                button = this.get('button'),
                targetDropdownName = options.target;

            if (name === targetDropdownName && (!isOpen || isClosing)) {
                if (!button) {
                    button = options.button;
                    this.set('button', button);
                }
                this.open();
            } else if (isOpen) {
                this.close();
            }
        },

        click: function click(event) {
            this._super(event);

            if (this.get('closeOnClick')) {
                return this.close();
            }
        },

        didInsertElement: function didInsertElement() {
            this._super();

            var dropdownService = this.get('dropdown');

            dropdownService.on('close', this, this.close);
            dropdownService.on('toggle', this, this.toggle);
        },

        willDestroyElement: function willDestroyElement() {
            this._super();

            var dropdownService = this.get('dropdown');

            dropdownService.off('close', this, this.close);
            dropdownService.off('toggle', this, this.toggle);
        }
    });

});
define('ghost/components/gh-ed-editor', ['exports', 'ember', 'ghost/mixins/ed-editor-api', 'ghost/mixins/ed-editor-shortcuts', 'ghost/mixins/ed-editor-scroll'], function (exports, Ember, EditorAPI, EditorShortcuts, EditorScroll) {

    'use strict';

    exports['default'] = Ember['default'].TextArea.extend(EditorAPI['default'], EditorShortcuts['default'], EditorScroll['default'], {
        focus: false,

        /**
         * Tell the controller about focusIn events, will trigger an autosave on a new document
         */
        focusIn: function focusIn() {
            this.sendAction('onFocusIn');
        },

        /**
         * Sets the focus of the textarea if needed
         */
        setFocus: function setFocus() {
            if (this.get('focus')) {
                this.$().val(this.$().val()).focus();
            }
        },

        /**
         * Sets up properties at render time
         */
        didInsertElement: function didInsertElement() {
            this._super();

            this.setFocus();

            this.sendAction('setEditor', this);

            Ember['default'].run.scheduleOnce('afterRender', this, this.afterRenderEvent);
        },

        afterRenderEvent: function afterRenderEvent() {
            if (this.get('focus') && this.get('focusCursorAtEnd')) {
                this.setSelection('end');
            }
        },

        /**
         * Disable editing in the textarea (used while an upload is in progress)
         */
        disable: function disable() {
            var textarea = this.get('element');
            textarea.setAttribute('readonly', 'readonly');
        },

        /**
         * Reenable editing in the textarea
         */
        enable: function enable() {
            var textarea = this.get('element');
            textarea.removeAttribute('readonly');
        }
    });

});
define('ghost/components/gh-ed-preview', ['exports', 'ember', 'ghost/assets/lib/uploader'], function (exports, Ember, uploader) {

    'use strict';

    var Preview = Ember['default'].Component.extend({
        config: Ember['default'].inject.service(),

        didInsertElement: function didInsertElement() {
            this.set('scrollWrapper', this.$().closest('.entry-preview-content'));
            Ember['default'].run.scheduleOnce('afterRender', this, this.dropzoneHandler);
        },

        adjustScrollPosition: Ember['default'].observer('scrollPosition', function () {
            var scrollWrapper = this.get('scrollWrapper'),
                scrollPosition = this.get('scrollPosition');

            if (scrollWrapper) {
                scrollWrapper.scrollTop(scrollPosition);
            }
        }),

        dropzoneHandler: function dropzoneHandler() {
            var dropzones = $('.js-drop-zone');

            uploader['default'].call(dropzones, {
                editor: true,
                fileStorage: this.get('config.fileStorage')
            });

            dropzones.on('uploadstart', Ember['default'].run.bind(this, 'sendAction', 'uploadStarted'));
            dropzones.on('uploadfailure', Ember['default'].run.bind(this, 'sendAction', 'uploadFinished'));
            dropzones.on('uploadsuccess', Ember['default'].run.bind(this, 'sendAction', 'uploadFinished'));
            dropzones.on('uploadsuccess', Ember['default'].run.bind(this, 'sendAction', 'uploadSuccess'));

            // Set the current height so we can listen
            this.sendAction('updateHeight', this.$().height());
        },

        // fire off 'enable' API function from uploadManager
        // might need to make sure markdown has been processed first
        reInitDropzones: Ember['default'].observer('markdown', function () {
            Ember['default'].run.scheduleOnce('afterRender', this, this.dropzoneHandler);
        })
    });

    exports['default'] = Preview;

});
define('ghost/components/gh-editor-save-button', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    exports['default'] = Ember['default'].Component.extend({
        tagName: 'section',
        classNames: ['splitbtn', 'js-publish-splitbutton'],
        classNameBindings: ['isNew:unsaved'],

        isNew: null,
        isPublished: null,
        willPublish: null,
        postOrPage: null,
        submitting: false,

        // Tracks whether we're going to change the state of the post on save
        isDangerous: Ember['default'].computed('isPublished', 'willPublish', function () {
            return this.get('isPublished') !== this.get('willPublish');
        }),

        publishText: Ember['default'].computed('isPublished', 'postOrPage', function () {
            return this.get('isPublished') ? 'Update ' + this.get('postOrPage') : 'Publish Now';
        }),

        draftText: Ember['default'].computed('isPublished', function () {
            return this.get('isPublished') ? 'Unpublish' : 'Save Draft';
        }),

        deleteText: Ember['default'].computed('postOrPage', function () {
            return 'Delete ' + this.get('postOrPage');
        }),

        saveText: Ember['default'].computed('willPublish', 'publishText', 'draftText', function () {
            return this.get('willPublish') ? this.get('publishText') : this.get('draftText');
        }),

        actions: {
            save: function save() {
                this.sendAction('save');
            },

            setSaveType: function setSaveType(saveType) {
                this.sendAction('setSaveType', saveType);
            },

            'delete': function _delete() {
                this.sendAction('delete');
            }
        }
    });

});
define('ghost/components/gh-editor', ['exports', 'ember', 'ghost/utils/set-scroll-classname'], function (exports, Ember, setScrollClassName) {

    'use strict';

    exports['default'] = Ember['default'].Component.extend({
        tagName: 'section',
        classNames: ['gh-view'],

        scheduleAfterRender: function scheduleAfterRender() {
            Ember['default'].run.scheduleOnce('afterRender', this, this.afterRenderEvent);
        },

        didInsertElement: function didInsertElement() {
            this.scheduleAfterRender();
        },

        afterRenderEvent: function afterRenderEvent() {
            var $previewViewPort = this.$('.js-entry-preview-content');

            // cache these elements for use in other methods
            this.set('$previewViewPort', $previewViewPort);
            this.set('$previewContent', this.$('.js-rendered-markdown'));

            $previewViewPort.on('scroll', Ember['default'].run.bind($previewViewPort, setScrollClassName['default'], {
                target: this.$('.js-entry-preview'),
                offset: 10
            }));
        },

        willDestroyElement: function willDestroyElement() {
            // removes scroll handlers from the view
            this.get('$previewViewPort').off('scroll');
        },

        // updated when gh-ed-editor component scrolls
        editorScrollInfo: null,
        // updated when markdown is rendered
        height: null,

        // HTML Preview listens to scrollPosition and updates its scrollTop value
        // This property receives scrollInfo from the textEditor, and height from the preview pane, and will update the
        // scrollPosition value such that when either scrolling or typing-at-the-end of the text editor the preview pane
        // stays in sync
        scrollPosition: Ember['default'].computed('editorScrollInfo', 'height', function () {
            if (!this.get('editorScrollInfo') || !this.get('$previewContent') || !this.get('$previewViewPort')) {
                return 0;
            }

            var scrollInfo = this.get('editorScrollInfo'),
                previewHeight = this.get('$previewContent').height() - this.get('$previewViewPort').height(),
                previewPosition,
                ratio;

            ratio = previewHeight / scrollInfo.diff;
            previewPosition = scrollInfo.top * ratio;

            return previewPosition;
        }),

        activeTab: 'markdown',
        markdownActive: Ember['default'].computed.equal('activeTab', 'markdown'),
        previewActive: Ember['default'].computed.equal('activeTab', 'preview'),

        actions: {
            selectTab: function selectTab(tab) {
                this.set('activeTab', tab);
            }
        }
    });

});
define('ghost/components/gh-error-message', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    exports['default'] = Ember['default'].Component.extend({
        tagName: 'p',
        classNames: ['response'],

        errors: null,
        property: '',

        isVisible: Ember['default'].computed.notEmpty('errors'),

        message: Ember['default'].computed('errors.[]', 'property', function () {
            var property = this.get('property'),
                errors = this.get('errors'),
                messages = [],
                index;

            if (!Ember['default'].isEmpty(errors) && errors.get(property)) {
                errors.get(property).forEach(function (error) {
                    messages.push(error);
                });
                index = Math.floor(Math.random() * messages.length);
                return messages[index].message;
            }
        })
    });

});
define('ghost/components/gh-file-upload', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    exports['default'] = Ember['default'].Component.extend({
        _file: null,

        uploadButtonText: 'Text',

        uploadButtonDisabled: true,

        onUpload: null,
        onAdd: null,

        shouldResetForm: true,

        change: function change(event) {
            this.set('uploadButtonDisabled', false);
            this.sendAction('onAdd');
            this._file = event.target.files[0];
        },

        actions: {
            upload: function upload() {
                if (!this.get('uploadButtonDisabled') && this._file) {
                    this.sendAction('onUpload', this._file);
                }

                // Prevent double post by disabling the button.
                this.set('uploadButtonDisabled', true);

                // Reset form
                if (this.get('shouldResetForm')) {
                    this.$().closest('form').get(0).reset();
                }
            }
        }
    });

});
define('ghost/components/gh-form-group', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    exports['default'] = Ember['default'].Component.extend({
        classNames: 'form-group',
        classNameBindings: ['errorClass'],

        errors: null,
        property: '',
        hasValidated: Ember['default'].A(),

        errorClass: Ember['default'].computed('errors.[]', 'property', 'hasValidated.[]', function () {
            var property = this.get('property'),
                errors = this.get('errors'),
                hasValidated = this.get('hasValidated');

            // If we haven't yet validated this field, there is no validation class needed
            if (!hasValidated || !hasValidated.contains(property)) {
                return '';
            }

            if (errors) {
                return errors.get(property) ? 'error' : 'success';
            }
        })
    });

});
define('ghost/components/gh-infinite-scroll-box', ['exports', 'ember', 'ghost/mixins/infinite-scroll', 'ghost/utils/set-scroll-classname'], function (exports, Ember, InfiniteScrollMixin, setScrollClassName) {

    'use strict';

    exports['default'] = Ember['default'].Component.extend(InfiniteScrollMixin['default'], {
        didRender: function didRender() {
            this._super();

            var el = this.$();

            el.on('scroll', Ember['default'].run.bind(el, setScrollClassName['default'], {
                target: el.closest('.content-list'),
                offset: 10
            }));
        },

        willDestroyElement: function willDestroyElement() {
            this._super();

            this.$().off('scroll');
        }
    });

});
define('ghost/components/gh-infinite-scroll', ['exports', 'ember', 'ghost/mixins/infinite-scroll'], function (exports, Ember, InfiniteScrollMixin) {

	'use strict';

	exports['default'] = Ember['default'].Component.extend(InfiniteScrollMixin['default']);

});
define('ghost/components/gh-input', ['exports', 'ember', 'ghost/mixins/text-input'], function (exports, Ember, TextInputMixin) {

    'use strict';

    var Input = Ember['default'].TextField.extend(TextInputMixin['default'], {
        classNames: 'gh-input'
    });

    exports['default'] = Input;

});
define('ghost/components/gh-main', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    exports['default'] = Ember['default'].Component.extend({
        tagName: 'main',
        classNames: ['gh-main'],
        ariaRole: 'main',

        mouseEnter: function mouseEnter() {
            this.sendAction('onMouseEnter');
        }
    });

});
define('ghost/components/gh-menu-toggle', ['exports', 'ember', 'ghost/utils/mobile'], function (exports, Ember, mobileQuery) {

    'use strict';

    /*
    This cute little component has two jobs.

    On desktop, it toggles autoNav behaviour. It tracks
    that state via the maximise property, and uses the
    state to render the appropriate icon.

    On mobile, it renders a closing icon, and clicking it
    closes the mobile menu
    */

    exports['default'] = Ember['default'].Component.extend({
        classNames: ['gh-menu-toggle'],

        isMobile: false,
        maximise: false,

        iconClass: Ember['default'].computed('maximise', 'isMobile', function () {
            if (this.get('maximise') && !this.get('isMobile')) {
                return 'icon-maximise';
            } else {
                return 'icon-minimise';
            }
        }),

        didInsertElement: function didInsertElement() {
            this.set('isMobile', mobileQuery['default'].matches);
            this.set('mqListener', Ember['default'].run.bind(this, function (mql) {
                this.set('isMobile', mql.matches);
            }));
            mobileQuery['default'].addListener(this.get('mqListener'));
        },

        willDestroyElement: function willDestroyElement() {
            mobileQuery['default'].removeListener(this.get('mqListener'));
        },

        click: function click() {
            if (this.get('isMobile')) {
                this.sendAction('mobileAction');
            } else {
                this.toggleProperty('maximise');
                this.sendAction('desktopAction');
            }
        }
    });

});
define('ghost/components/gh-modal-dialog', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    var ModalDialog = Ember['default'].Component.extend({
        didInsertElement: function didInsertElement() {
            this.$('.js-modal-container, .js-modal-background').addClass('fade-in open');
            this.$('.js-modal').addClass('open');
        },

        close: function close() {
            var self = this;

            this.$('.js-modal, .js-modal-background').removeClass('fade-in').addClass('fade-out');

            // The background should always be the last thing to fade out, so check on that instead of the content
            this.$('.js-modal-background').on('animationend webkitAnimationEnd oanimationend MSAnimationEnd', function (event) {
                if (event.originalEvent.animationName === 'fade-out') {
                    self.$('.js-modal, .js-modal-background').removeClass('open');
                }
            });

            this.sendAction();
        },

        confirmaccept: 'confirmAccept',
        confirmreject: 'confirmReject',

        actions: {
            closeModal: function closeModal() {
                this.close();
            },
            confirm: function confirm(type) {
                this.sendAction('confirm' + type);
                this.close();
            },
            noBubble: Ember['default'].K
        },

        klass: Ember['default'].computed('type', 'style', function () {
            var classNames = [];

            classNames.push(this.get('type') ? 'modal-' + this.get('type') : 'modal');

            if (this.get('style')) {
                this.get('style').split(',').forEach(function (style) {
                    classNames.push('modal-style-' + style);
                });
            }

            return classNames.join(' ');
        }),

        acceptButtonClass: Ember['default'].computed('confirm.accept.buttonClass', function () {
            return this.get('confirm.accept.buttonClass') ? this.get('confirm.accept.buttonClass') : 'btn btn-green';
        }),

        rejectButtonClass: Ember['default'].computed('confirm.reject.buttonClass', function () {
            return this.get('confirm.reject.buttonClass') ? this.get('confirm.reject.buttonClass') : 'btn btn-red';
        })
    });

    exports['default'] = ModalDialog;

});
define('ghost/components/gh-nav-menu', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    exports['default'] = Ember['default'].Component.extend({
        tagName: 'nav',
        classNames: ['gh-nav'],
        classNameBindings: ['open'],

        config: Ember['default'].inject.service(),

        open: false,

        mouseEnter: function mouseEnter() {
            this.sendAction('onMouseEnter');
        },

        actions: {
            toggleAutoNav: function toggleAutoNav() {
                this.sendAction('toggleMaximise');
            },

            openModal: function openModal(modal) {
                this.sendAction('openModal', modal);
            },

            closeMobileMenu: function closeMobileMenu() {
                this.sendAction('closeMobileMenu');
            },

            openAutoNav: function openAutoNav() {
                this.sendAction('openAutoNav');
            }
        }
    });

});
define('ghost/components/gh-navigation', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    exports['default'] = Ember['default'].Component.extend({
        tagName: 'section',
        classNames: 'gh-view',

        didInsertElement: function didInsertElement() {
            var navContainer = this.$('.js-gh-blognav'),
                navElements = '.gh-blognav-item:not(.gh-blognav-item:last-child)',
                self = this;

            navContainer.sortable({
                handle: '.gh-blognav-grab',
                items: navElements,

                start: function start(event, ui) {
                    Ember['default'].run(function () {
                        ui.item.data('start-index', ui.item.index());
                    });
                },

                update: function update(event, ui) {
                    Ember['default'].run(function () {
                        self.sendAction('moveItem', ui.item.data('start-index'), ui.item.index());
                    });
                }
            });
        },

        willDestroyElement: function willDestroyElement() {
            this.$('.js-gh-blognav').sortable('destroy');
        }
    });

});
define('ghost/components/gh-navitem-url-input', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    function joinUrlParts(url, path) {
        if (path[0] !== '/' && url.slice(-1) !== '/') {
            path = '/' + path;
        } else if (path[0] === '/' && url.slice(-1) === '/') {
            path = path.slice(1);
        }

        return url + path;
    }

    exports['default'] = Ember['default'].TextField.extend({
        classNameBindings: ['fakePlaceholder'],

        didReceiveAttrs: function didReceiveAttrs() {
            var url = this.get('url'),
                baseUrl = this.get('baseUrl');

            // if we have a relative url, create the absolute url to be displayed in the input
            // if (this.get('isRelative')) {
            if (!validator.isURL(url) && url.indexOf('mailto:') !== 0) {
                url = joinUrlParts(baseUrl, url);
            }

            this.set('value', url);
        },

        isBaseUrl: Ember['default'].computed('baseUrl', 'value', function () {
            return this.get('baseUrl') === this.get('value');
        }),

        fakePlaceholder: Ember['default'].computed('isBaseUrl', 'hasFocus', function () {
            return this.get('isBaseUrl') && this.get('last') && !this.get('hasFocus');
        }),

        isRelative: Ember['default'].computed('value', function () {
            return !validator.isURL(this.get('value')) && this.get('value').indexOf('mailto:') !== 0;
        }),

        focusIn: function focusIn(event) {
            this.set('hasFocus', true);

            if (this.get('isBaseUrl')) {
                // position the cursor at the end of the input
                Ember['default'].run.next(function (el) {
                    var length = el.value.length;

                    el.setSelectionRange(length, length);
                }, event.target);
            }
        },

        keyDown: function keyDown(event) {
            // delete the "placeholder" value all at once
            if (this.get('isBaseUrl') && (event.keyCode === 8 || event.keyCode === 46)) {
                this.set('value', '');

                event.preventDefault();
            }
        },

        keyPress: function keyPress(event) {
            // enter key
            if (event.keyCode === 13) {
                event.preventDefault();
                this.notifyUrlChanged();
            }

            return true;
        },

        focusOut: function focusOut() {
            this.set('hasFocus', false);

            this.notifyUrlChanged();
        },

        notifyUrlChanged: function notifyUrlChanged() {
            this.set('value', this.get('value').trim());

            var url = this.get('value'),
                baseUrl = this.get('baseUrl');

            // if we have a relative url, create the absolute url to be displayed in the input
            if (this.get('isRelative')) {
                this.set('value', joinUrlParts(baseUrl, url));
            }

            this.sendAction('change', url);
        }
    });

});
define('ghost/components/gh-navitem', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    exports['default'] = Ember['default'].Component.extend({
        classNames: 'gh-blognav-item',

        attributeBindings: ['order:data-order'],
        order: Ember['default'].computed.readOnly('navItem.order'),

        keyPress: function keyPress(event) {
            // enter key
            if (event.keyCode === 13) {
                event.preventDefault();
                this.send('addItem');
            }
        },

        actions: {
            addItem: function addItem() {
                this.sendAction('addItem');
            },

            deleteItem: function deleteItem(item) {
                this.sendAction('deleteItem', item);
            },

            updateUrl: function updateUrl(value) {
                this.sendAction('updateUrl', value, this.get('navItem'));
            }
        }
    });

});
define('ghost/components/gh-notification', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    exports['default'] = Ember['default'].Component.extend({
        tagName: 'article',
        classNames: ['gh-notification', 'gh-notification-passive'],
        classNameBindings: ['typeClass'],

        message: null,

        notifications: Ember['default'].inject.service(),

        typeClass: Ember['default'].computed(function () {
            var classes = '',
                message = this.get('message'),
                type = Ember['default'].get(message, 'type'),
                typeMapping;

            typeMapping = {
                success: 'green',
                error: 'red',
                warn: 'yellow'
            };

            if (typeMapping[type] !== undefined) {
                classes += 'gh-notification-' + typeMapping[type];
            }

            return classes;
        }),

        didInsertElement: function didInsertElement() {
            var self = this;

            self.$().on('animationend webkitAnimationEnd oanimationend MSAnimationEnd', function (event) {
                if (event.originalEvent.animationName === 'fade-out') {
                    self.get('notifications').closeNotification(self.get('message'));
                }
            });
        },

        willDestroyElement: function willDestroyElement() {
            this.$().off('animationend webkitAnimationEnd oanimationend MSAnimationEnd');
        },

        actions: {
            closeNotification: function closeNotification() {
                this.get('notifications').closeNotification(this.get('message'));
            }
        }
    });

});
define('ghost/components/gh-notifications', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    exports['default'] = Ember['default'].Component.extend({
        tagName: 'aside',
        classNames: 'gh-notifications',

        notifications: Ember['default'].inject.service(),

        messages: Ember['default'].computed.alias('notifications.notifications')
    });

});
define('ghost/components/gh-popover-button', ['exports', 'ember', 'ghost/components/gh-dropdown-button'], function (exports, Ember, DropdownButton) {

    'use strict';

    exports['default'] = DropdownButton['default'].extend({
        dropdown: Ember['default'].inject.service(),

        click: Ember['default'].K,

        mouseEnter: function mouseEnter(event) {
            this._super(event);
            this.get('dropdown').toggleDropdown(this.get('popoverName'), this);
        },

        mouseLeave: function mouseLeave(event) {
            this._super(event);
            this.get('dropdown').toggleDropdown(this.get('popoverName'), this);
        }
    });

});
define('ghost/components/gh-popover', ['exports', 'ember', 'ghost/components/gh-dropdown'], function (exports, Ember, GhostDropdown) {

    'use strict';

    exports['default'] = GhostDropdown['default'].extend({
        classNames: 'ghost-popover',
        dropdown: Ember['default'].inject.service()
    });

});
define('ghost/components/gh-posts-list-item', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    exports['default'] = Ember['default'].Component.extend({
        tagName: 'li',
        classNameBindings: ['active', 'isFeatured:featured', 'isPage:page'],

        post: null,
        active: false,
        previewIsHidden: false,

        ghostPaths: Ember['default'].inject.service('ghost-paths'),

        isFeatured: Ember['default'].computed.alias('post.featured'),

        isPage: Ember['default'].computed.alias('post.page'),

        isPublished: Ember['default'].computed.equal('post.status', 'published'),

        authorName: Ember['default'].computed('post.author.name', 'post.author.email', function () {
            return this.get('post.author.name') || this.get('post.author.email');
        }),

        authorAvatar: Ember['default'].computed('post.author.image', function () {
            return this.get('post.author.image') || this.get('ghostPaths.url').asset('/shared/img/user-image.png');
        }),

        authorAvatarBackground: Ember['default'].computed('authorAvatar', function () {
            return ('background-image: url(' + this.get('authorAvatar') + ')').htmlSafe();
        }),

        viewOrEdit: Ember['default'].computed('previewIsHidden', function () {
            return this.get('previewIsHidden') ? 'editor.edit' : 'posts.post';
        }),

        click: function click() {
            this.sendAction('onClick', this.get('post'));
        },

        doubleClick: function doubleClick() {
            this.sendAction('onDoubleClick', this.get('post'));
        },

        didInsertElement: function didInsertElement() {
            this.addObserver('active', this, this.scrollIntoView);
        },

        willDestroyElement: function willDestroyElement() {
            this.removeObserver('active', this, this.scrollIntoView);
        },

        scrollIntoView: function scrollIntoView() {
            if (!this.get('active')) {
                return;
            }

            var element = this.$(),
                offset = element.offset().top,
                elementHeight = element.height(),
                container = Ember['default'].$('.js-content-scrollbox'),
                containerHeight = container.height(),
                currentScroll = container.scrollTop(),
                isBelowTop,
                isAboveBottom,
                isOnScreen;

            isAboveBottom = offset < containerHeight;
            isBelowTop = offset > elementHeight;

            isOnScreen = isBelowTop && isAboveBottom;

            if (!isOnScreen) {
                // Scroll so that element is centered in container
                // 40 is the amount of padding on the container
                container.clearQueue().animate({
                    scrollTop: currentScroll + offset - 40 - containerHeight / 2
                });
            }
        }
    });

});
define('ghost/components/gh-profile-image', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    /* global md5 */
    exports['default'] = Ember['default'].Component.extend({
        email: '',
        size: 90,
        hasUploadedImage: false,
        fileStorage: true,

        ghostPaths: Ember['default'].inject.service('ghost-paths'),
        hasEmail: Ember['default'].computed.notEmpty('email'),

        defaultImage: Ember['default'].computed('ghostPaths', function () {
            var url = this.get('ghostPaths.url').asset('/shared/img/user-image.png');
            return ('background-image: url(' + url + ')').htmlSafe();
        }),

        imageBackground: Ember['default'].computed('email', 'size', function () {
            var email = this.get('email'),
                size = this.get('size'),
                url;
            if (email) {
                url = 'http://www.gravatar.com/avatar/' + md5(email) + '?s=' + size + '&d=blank';
                return ('background-image: url(' + url + ')').htmlSafe();
            }
        }),

        didInsertElement: function didInsertElement() {
            var size = this.get('size'),
                uploadElement = this.$('.js-file-input');

            // while theoretically the 'add' and 'processalways' functions could be
            // added as properties of the hash passed to fileupload(), for some reason
            // they needed to be placed in an on() call for the add method to work correctly
            uploadElement.fileupload({
                url: this.get('ghostPaths.url').api('uploads'),
                dropZone: this.$('.js-img-dropzone'),
                previewMaxHeight: size,
                previewMaxWidth: size,
                previewCrop: true,
                maxNumberOfFiles: 1,
                autoUpload: false
            }).on('fileuploadadd', Ember['default'].run.bind(this, this.queueFile)).on('fileuploadprocessalways', Ember['default'].run.bind(this, this.triggerPreview));
        },

        willDestroyElement: function willDestroyElement() {
            this.$('.js-file-input').fileupload('destroy');
        },

        queueFile: function queueFile(e, data) {
            var fileName = data.files[0].name;

            if (/\.(gif|jpe?g|png|svg?z)$/i.test(fileName)) {
                this.sendAction('setImage', data);
            }
        },

        triggerPreview: function triggerPreview(e, data) {
            var file = data.files[data.index];
            if (file.preview) {
                this.set('hasUploadedImage', true);
                // necessary jQuery code because file.preview is a raw DOM object
                // potential todo: rename 'gravatar-img' class in the CSS to be something
                // that both the gravatar and the image preview can use that's not so confusing
                this.$('.js-img-preview').empty().append(this.$(file.preview).addClass('gravatar-img'));
            }
        }
    });

});
define('ghost/components/gh-search-input', ['exports', 'ember', 'ic-ajax'], function (exports, Ember, ic_ajax) {

    'use strict';

    exports['default'] = Ember['default'].Component.extend({

        selection: null,
        content: [],
        isLoading: false,
        contentExpiry: 10 * 1000,
        contentExpiresAt: false,

        posts: Ember['default'].computed.filterBy('content', 'category', 'Posts'),
        pages: Ember['default'].computed.filterBy('content', 'category', 'Pages'),
        users: Ember['default'].computed.filterBy('content', 'category', 'Users'),

        _store: Ember['default'].inject.service('store'),
        _routing: Ember['default'].inject.service('-routing'),
        _selectize: Ember['default'].computed(function () {
            return this.$('select')[0].selectize;
        }),

        refreshContent: function refreshContent() {
            var promises = [],
                now = new Date(),
                contentExpiry = this.get('contentExpiry'),
                contentExpiresAt = this.get('contentExpiresAt'),
                self = this;

            if (self.get('isLoading') || contentExpiresAt > now) {
                return;
            }

            self.set('isLoading', true);
            promises.pushObject(this._loadPosts());
            promises.pushObject(this._loadUsers());

            Ember['default'].RSVP.all(promises).then(function () {})['finally'](function () {
                self.set('isLoading', false);
                self.set('contentExpiresAt', new Date(now.getTime() + contentExpiry));
            });
        },

        _loadPosts: function _loadPosts() {
            var store = this.get('_store'),
                postsUrl = store.adapterFor('post').urlForFindQuery({}, 'post') + '/',
                postsQuery = { fields: 'id,title,page', limit: 'all', status: 'all', staticPages: 'all' },
                content = this.get('content'),
                self = this;

            return ic_ajax.request(postsUrl, { data: postsQuery }).then(function (posts) {
                content.removeObjects(self.get('posts'));
                content.removeObjects(self.get('pages'));
                content.pushObjects(posts.posts.map(function (post) {
                    return {
                        id: post.id,
                        title: post.title,
                        category: post.page ? 'Pages' : 'Posts'
                    };
                }));
            });
        },

        _loadUsers: function _loadUsers() {
            var store = this.get('_store'),
                usersUrl = store.adapterFor('user').urlForFindQuery({}, 'user') + '/',
                usersQuery = { fields: 'name,slug', limit: 'all' },
                content = this.get('content'),
                self = this;

            return ic_ajax.request(usersUrl, { data: usersQuery }).then(function (users) {
                content.removeObjects(self.get('users'));
                content.pushObjects(users.users.map(function (user) {
                    return {
                        id: user.slug,
                        title: user.name,
                        category: 'Users'
                    };
                }));
            });
        },

        _keepSelectionClear: Ember['default'].observer('selection', function () {
            if (this.get('selection') !== null) {
                this.set('selection', null);
            }
        }),

        _setKeymasterScope: function _setKeymasterScope() {
            key.setScope('search-input');
        },

        _resetKeymasterScope: function _resetKeymasterScope() {
            key.setScope('default');
        },

        willDestroy: function willDestroy() {
            this._resetKeymasterScope();
        },

        actions: {
            openSelected: function openSelected(selected) {
                var transition = null,
                    self = this;

                if (!selected) {
                    return;
                }

                if (selected.category === 'Posts' || selected.category === 'Pages') {
                    transition = self.get('_routing.router').transitionTo('editor.edit', selected.id);
                }

                if (selected.category === 'Users') {
                    transition = self.get('_routing.router').transitionTo('team.user', selected.id);
                }

                transition.then(function () {
                    if (self.get('_selectize').$control_input.is(':focus')) {
                        self._setKeymasterScope();
                    }
                });
            },

            focusInput: function focusInput() {
                this.get('_selectize').focus();
            },

            onInit: function onInit() {
                var selectize = this.get('_selectize'),
                    html = '<div class="dropdown-empty-message">Nothing found&hellip;</div>';

                selectize.$empty_results_container = $(html);
                selectize.$empty_results_container.hide();
                selectize.$dropdown.append(selectize.$empty_results_container);
            },

            onFocus: function onFocus() {
                this._setKeymasterScope();
                this.refreshContent();
            },

            onBlur: function onBlur() {
                var selectize = this.get('_selectize');

                this._resetKeymasterScope();
                selectize.$empty_results_container.hide();
            },

            onType: function onType() {
                var selectize = this.get('_selectize');

                if (!selectize.hasOptions) {
                    selectize.open();
                    selectize.$empty_results_container.show();
                } else {
                    selectize.$empty_results_container.hide();
                }
            }
        }

    });

});
define('ghost/components/gh-select-native', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    exports['default'] = Ember['default'].Component.extend({
        content: null,
        prompt: null,
        optionValuePath: 'id',
        optionLabelPath: 'title',
        selection: null,
        action: Ember['default'].K, // action to fire on change

        // shadow the passed-in `selection` to avoid
        // leaking changes to it via a 2-way binding
        _selection: Ember['default'].computed.reads('selection'),

        actions: {
            change: function change() {
                var selectEl = this.$('select')[0],
                    selectedIndex = selectEl.selectedIndex,
                    content = this.get('content'),

                // decrement index by 1 if we have a prompt
                hasPrompt = !!this.get('prompt'),
                    contentIndex = hasPrompt ? selectedIndex - 1 : selectedIndex,
                    selection = content.objectAt(contentIndex);

                // set the local, shadowed selection to avoid leaking
                // changes to `selection` out via 2-way binding
                this.set('_selection', selection);

                this.sendAction('action', selection);
            }
        }
    });

});
define('ghost/components/gh-selectize', ['exports', 'ember', 'ember-cli-selectize/components/ember-selectize'], function (exports, Ember, EmberSelectizeComponent) {

    'use strict';

    exports['default'] = EmberSelectizeComponent['default'].extend({

        _dontOpenWhenBlank: Ember['default'].on('didInsertElement', function () {
            var openOnFocus = this.get('openOnFocus');

            if (!openOnFocus) {
                Ember['default'].run.next(this, function () {
                    var selectize = this._selectize;
                    selectize.on('dropdown_open', function () {
                        if (Ember['default'].isBlank(selectize.$control_input.val())) {
                            selectize.close();
                        }
                    });
                    selectize.on('type', function (filter) {
                        if (Ember['default'].isBlank(filter)) {
                            selectize.close();
                        }
                    });
                });
            }
        }),

        /**
        * Event callback that is triggered when user creates a tag
        * - modified to pass the caret position to the action
        */
        _create: function _create(input, callback) {
            var caret = this._selectize.caretPos;

            // Delete user entered text
            this._selectize.setTextboxValue('');
            // Send create action

            // allow the observers and computed properties to run first
            Ember['default'].run.schedule('actions', this, function () {
                this.sendAction('create-item', input, caret);
            });
            // We cancel the creation here, so it's up to you to include the created element
            // in the content and selection property
            callback(null);
        },

        _addSelection: function _addSelection(obj) {
            var _valuePath = this.get('_valuePath'),
                val = Ember['default'].get(obj, _valuePath),
                caret = this._selectize.caretPos;

            // caret position is always 1 more than the desired index as this method
            // is called after selectize has inserted the item and the caret has moved
            // to the right
            caret = caret - 1;

            this.get('selection').insertAt(caret, obj);

            Ember['default'].run.schedule('actions', this, function () {
                this.sendAction('add-item', obj);
                this.sendAction('add-value', val);
            });
        }

    });

});
define('ghost/components/gh-skip-link', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    /*jshint scripturl:true*/
    exports['default'] = Ember['default'].Component.extend({
        tagName: 'a',
        anchor: '',
        classNames: ['sr-only', 'sr-only-focusable'],
        // Add attributes to component for href
        // href should be set to retain anchor properties
        // such as pointer cursor and text underline
        attributeBindings: ['href'],
        // Used so that upon clicking on the link
        // anchor behaviors or ignored
        href: Ember['default'].String.htmlSafe('javascript:;'),

        scrollTo: (function () {
            var anchor = this.get('anchor'),
                $el = Ember['default'].$(anchor);

            if ($el) {
                // Scrolls to the top of main content or whatever
                // is passed to the anchor attribute
                Ember['default'].$('body').scrollTop($el.offset().top);

                // This sets focus on the content which was skipped to
                // upon losing focus, the tabindex should be removed
                // so that normal keyboard navigation picks up from focused
                // element
                Ember['default'].$($el).attr('tabindex', -1).on('blur focusout', function () {
                    $(this).removeAttr('tabindex');
                }).focus();
            }
        }).on('click')
    });

});
define('ghost/components/gh-spin-button', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    exports['default'] = Ember['default'].Component.extend({
        tagName: 'button',
        buttonText: '',
        submitting: false,
        showSpinner: false,
        showSpinnerTimeout: null,
        autoWidth: true,

        // Disable Button when isLoading equals true
        attributeBindings: ['disabled', 'type', 'tabindex'],

        // Must be set on the controller
        disabled: Ember['default'].computed.equal('showSpinner', true),

        click: function click() {
            if (this.get('action')) {
                this.sendAction('action');
                return false;
            }
            return true;
        },

        toggleSpinner: Ember['default'].observer('submitting', function () {
            var submitting = this.get('submitting'),
                timeout = this.get('showSpinnerTimeout');

            if (submitting) {
                this.set('showSpinner', true);
                this.set('showSpinnerTimeout', Ember['default'].run.later(this, function () {
                    if (!this.get('submitting')) {
                        this.set('showSpinner', false);
                    }
                    this.set('showSpinnerTimeout', null);
                }, 1000));
            } else if (!submitting && timeout === null) {
                this.set('showSpinner', false);
            }
        }),

        setSize: Ember['default'].observer('showSpinner', function () {
            if (this.get('showSpinner') && this.get('autoWidth')) {
                this.$().width(this.$().width());
                this.$().height(this.$().height());
            } else {
                this.$().width('');
                this.$().height('');
            }
        }),

        willDestroy: function willDestroy() {
            Ember['default'].run.cancel(this.get('showSpinnerTimeout'));
        }
    });

});
define('ghost/components/gh-tab-pane', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    var TabPane = Ember['default'].Component.extend({
        classNameBindings: ['active'],

        tabsManager: Ember['default'].computed(function () {
            return this.nearestWithProperty('isTabsManager');
        }),

        tab: Ember['default'].computed('tabsManager.tabs.[]', 'tabsManager.tabPanes.[]', function () {
            var index = this.get('tabsManager.tabPanes').indexOf(this),
                tabs = this.get('tabsManager.tabs');

            return tabs && tabs.objectAt(index);
        }),

        active: Ember['default'].computed.alias('tab.active'),

        willRender: function willRender() {
            // Register with the tabs manager
            this.get('tabsManager').registerTabPane(this);
        },

        willDestroyElement: function willDestroyElement() {
            // Deregister with the tabs manager
            this.get('tabsManager').unregisterTabPane(this);
        }
    });

    exports['default'] = TabPane;

});
define('ghost/components/gh-tab', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    var Tab = Ember['default'].Component.extend({
        tabsManager: Ember['default'].computed(function () {
            return this.nearestWithProperty('isTabsManager');
        }),

        active: Ember['default'].computed('tabsManager.activeTab', function () {
            return this.get('tabsManager.activeTab') === this;
        }),

        index: Ember['default'].computed('tabsManager.tabs.@each', function () {
            return this.get('tabsManager.tabs').indexOf(this);
        }),

        // Select on click
        click: function click() {
            this.get('tabsManager').select(this);
        },

        willRender: function willRender() {
            // register the tabs with the tab manager
            this.get('tabsManager').registerTab(this);
        },

        willDestroyElement: function willDestroyElement() {
            // unregister the tabs with the tab manager
            this.get('tabsManager').unregisterTab(this);
        }
    });

    exports['default'] = Tab;

});
define('ghost/components/gh-tabs-manager', ['exports', 'ember'], function (exports, Ember) {

  'use strict';

  var TabsManager = Ember['default'].Component.extend({
      activeTab: null,
      tabs: [],
      tabPanes: [],

      // Called when a gh-tab is clicked.
      select: function select(tab) {
          this.set('activeTab', tab);
          this.sendAction('selected');
      },

      // Used by children to find this tabsManager
      isTabsManager: true,

      // Register tabs and their panes to allow for
      // interaction between components.
      registerTab: function registerTab(tab) {
          this.get('tabs').addObject(tab);
      },

      unregisterTab: function unregisterTab(tab) {
          this.get('tabs').removeObject(tab);
      },

      registerTabPane: function registerTabPane(tabPane) {
          this.get('tabPanes').addObject(tabPane);
      },

      unregisterTabPane: function unregisterTabPane(tabPane) {
          this.get('tabPanes').removeObject(tabPane);
      }
  });

  exports['default'] = TabsManager;

});
define('ghost/components/gh-textarea', ['exports', 'ember', 'ghost/mixins/text-input'], function (exports, Ember, TextInputMixin) {

    'use strict';

    var TextArea = Ember['default'].TextArea.extend(TextInputMixin['default'], {
        classNames: 'gh-input'
    });

    exports['default'] = TextArea;

});
define('ghost/components/gh-trim-focus-input', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    var TrimFocusInput = Ember['default'].TextField.extend({
        focus: true,
        classNames: 'gh-input',
        attributeBindings: ['autofocus'],

        autofocus: Ember['default'].computed(function () {
            if (this.get('focus')) {
                return device.ios() ? false : 'autofocus';
            }

            return false;
        }),

        focusField: Ember['default'].on('didInsertElement', function () {
            // This fix is required until Mobile Safari has reliable
            // autofocus, select() or focus() support
            if (this.get('focus') && !device.ios()) {
                this.$().val(this.$().val()).focus();
            }
        }),

        trimValue: Ember['default'].on('focusOut', function () {
            var text = this.$().val();
            this.$().val(text.trim());
        })
    });

    exports['default'] = TrimFocusInput;

});
define('ghost/components/gh-upload-modal', ['exports', 'ember', 'ghost/components/gh-modal-dialog', 'ghost/assets/lib/uploader', 'ghost/utils/caja-sanitizers'], function (exports, Ember, ModalDialog, upload, cajaSanitizers) {

    'use strict';

    var UploadModal = ModalDialog['default'].extend({
        layoutName: 'components/gh-modal-dialog',

        config: Ember['default'].inject.service(),

        didInsertElement: function didInsertElement() {
            this._super();
            upload['default'].call(this.$('.js-drop-zone'), { fileStorage: this.get('config.fileStorage') });
        },
        keyDown: function keyDown() {
            this.setErrorState(false);
        },
        setErrorState: function setErrorState(state) {
            if (state) {
                this.$('.js-upload-url').addClass('error');
            } else {
                this.$('.js-upload-url').removeClass('error');
            }
        },
        confirm: {
            reject: {
                func: function func() {
                    // The function called on rejection
                    return true;
                },
                buttonClass: 'btn btn-default',
                text: 'Cancel' // The reject button text
            },
            accept: {
                buttonClass: 'btn btn-blue right',
                text: 'Save', // The accept button text: 'Save'
                func: function func() {
                    var imageType = 'model.' + this.get('imageType'),
                        value;

                    if (this.$('.js-upload-url').val()) {
                        value = this.$('.js-upload-url').val();

                        if (!Ember['default'].isEmpty(value) && !cajaSanitizers['default'].url(value)) {
                            this.setErrorState(true);
                            return { message: 'Image URI is not valid' };
                        }
                    } else {
                        value = this.$('.js-upload-target').attr('src');
                    }

                    this.set(imageType, value);
                    return true;
                }
            }
        },

        actions: {
            closeModal: function closeModal() {
                this.sendAction();
            },
            confirm: function confirm(type) {
                var result,
                    func = this.get('confirm.' + type + '.func');

                if (typeof func === 'function') {
                    result = func.apply(this);
                }

                if (!result.message) {
                    this.sendAction();
                    this.sendAction('confirm' + type);
                }
            }
        }
    });

    exports['default'] = UploadModal;

});
define('ghost/components/gh-uploader', ['exports', 'ember', 'ghost/assets/lib/uploader'], function (exports, Ember, uploader) {

    'use strict';

    exports['default'] = Ember['default'].Component.extend({
        classNames: ['image-uploader', 'js-post-image-upload'],

        config: Ember['default'].inject.service(),

        imageSource: Ember['default'].computed('image', function () {
            return this.get('image') || '';
        }),

        /**
         * Sets up the uploader on render
         */
        setup: function setup() {
            var $this = this.$(),
                self = this;

            // this.set('uploaderReference', uploader.call($this, {
            //     editor: true,
            //     fileStorage: this.get('config.fileStorage')
            // }));

            $this.on('uploadsuccess', function (event, result) {
                if (result && result !== '' && result !== 'http://') {
                    self.sendAction('uploaded', result);
                }
            });

            $this.on('imagecleared', function () {
                self.sendAction('canceled');
            });
        },

        // removes event listeners from the uploader
        removeListeners: function removeListeners() {
            var $this = this.$();

            $this.off();
            $this.find('.js-cancel').off();
        },

        // didInsertElement: function () {
        //     Ember.run.scheduleOnce('afterRender', this, this.setup());
        // },
        didInsertElement: function didInsertElement() {
            this.send('initUploader');
        },

        willDestroyElement: function willDestroyElement() {
            this.removeListeners();
        },

        actions: {
            initUploader: function initUploader() {
                var ref,
                    el,
                    self = this;

                el = this.$();
                ref = uploader['default'].call(el, {
                    editor: true,
                    fileStorage: this.get('config.fileStorage')
                });

                el.on('uploadsuccess', function (event, result) {
                    if (result && result !== '' && result !== 'http://') {
                        self.sendAction('uploaded', result);
                    }
                });

                el.on('imagecleared', function () {
                    self.sendAction('canceled');
                });

                this.sendAction('initUploader', this.get('uploaderReference'));
            }
        }
    });

});
define('ghost/components/gh-url-preview', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    var urlPreview = Ember['default'].Component.extend({
        classNames: 'ghost-url-preview',
        prefix: null,
        slug: null,

        config: Ember['default'].inject.service(),

        url: Ember['default'].computed('slug', function () {
            // Get the blog URL and strip the scheme
            var blogUrl = this.get('config.blogUrl'),
                noSchemeBlogUrl = blogUrl.substr(blogUrl.indexOf('://') + 3),
                // Remove `http[s]://`

            // Get the prefix and slug values
            prefix = this.get('prefix') ? this.get('prefix') + '/' : '',
                slug = this.get('slug') ? this.get('slug') + '/' : '',

            // Join parts of the URL together with slashes
            theUrl = noSchemeBlogUrl + '/' + prefix + slug;

            return theUrl;
        })
    });

    exports['default'] = urlPreview;

});
define('ghost/components/gh-user-active', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    exports['default'] = Ember['default'].Component.extend({
        tagName: '',

        user: null,

        ghostPaths: Ember['default'].inject.service('ghost-paths'),

        userDefault: Ember['default'].computed('ghostPaths', function () {
            return this.get('ghostPaths.url').asset('/shared/img/user-image.png');
        }),

        userImageBackground: Ember['default'].computed('user.image', 'userDefault', function () {
            var url = this.get('user.image') || this.get('userDefault');

            return ('background-image: url(' + url + ')').htmlSafe();
        }),

        lastLogin: Ember['default'].computed('user.last_login', function () {
            var lastLogin = this.get('user.last_login');

            return lastLogin ? lastLogin.fromNow() : '(Never)';
        })
    });

});
define('ghost/components/gh-user-invited', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    exports['default'] = Ember['default'].Component.extend({
        tagName: '',

        user: null,
        isSending: false,

        notifications: Ember['default'].inject.service(),

        createdAt: Ember['default'].computed('user.created_at', function () {
            var createdAt = this.get('user.created_at');

            return createdAt ? createdAt.fromNow() : '';
        }),

        actions: {
            resend: function resend() {
                var user = this.get('user'),
                    notifications = this.get('notifications'),
                    self = this;

                this.set('isSending', true);
                user.resendInvite().then(function (result) {
                    var notificationText = 'Invitation resent! (' + user.get('email') + ')';

                    // If sending the invitation email fails, the API will still return a status of 201
                    // but the user's status in the response object will be 'invited-pending'.
                    if (result.users[0].status === 'invited-pending') {
                        notifications.showAlert('Invitation email was not sent.  Please try resending.', { type: 'error' });
                    } else {
                        user.set('status', result.users[0].status);
                        notifications.showNotification(notificationText);
                    }
                })['catch'](function (error) {
                    notifications.showAPIError(error);
                })['finally'](function () {
                    self.set('isSending', false);
                });
            },

            revoke: function revoke() {
                var user = this.get('user'),
                    email = user.get('email'),
                    notifications = this.get('notifications'),
                    self = this;

                // reload the user to get the most up-to-date information
                user.reload().then(function () {
                    if (user.get('invited')) {
                        user.destroyRecord().then(function () {
                            var notificationText = 'Invitation revoked. (' + email + ')';

                            notifications.showNotification(notificationText);
                        })['catch'](function (error) {
                            notifications.showAPIError(error);
                        });
                    } else {
                        // if the user is no longer marked as "invited", then show a warning and reload the route
                        self.sendAction('reload');
                        notifications.showAlert('This user has already accepted the invitation.', { type: 'error', delayed: true });
                    }
                });
            }
        }
    });

});
define('ghost/components/gh-view-title', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    exports['default'] = Ember['default'].Component.extend({
        tagName: 'h2',
        classNames: ['view-title'],
        actions: {
            openMobileMenu: function openMobileMenu() {
                this.sendAction('openMobileMenu');
            }
        }
    });

});
define('ghost/controllers/about', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    var AboutController = Ember['default'].Controller.extend({
        updateNotificationCount: 0,

        actions: {
            updateNotificationChange: function updateNotificationChange(count) {
                this.set('updateNotificationCount', count);
            }
        }
    });

    exports['default'] = AboutController;

});
define('ghost/controllers/application', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    exports['default'] = Ember['default'].Controller.extend({
        dropdown: Ember['default'].inject.service(),

        // jscs: disable
        signedOut: Ember['default'].computed.match('currentPath', /(signin|signup|setup|reset)/),
        // jscs: enable

        topNotificationCount: 0,
        showMobileMenu: false,
        showSettingsMenu: false,

        autoNav: false,
        autoNavOpen: Ember['default'].computed('autoNav', {
            get: function get() {
                return false;
            },
            set: function set(key, value) {
                if (this.get('autoNav')) {
                    return value;
                }
                return false;
            }
        }),

        actions: {
            topNotificationChange: function topNotificationChange(count) {
                this.set('topNotificationCount', count);
            },

            toggleAutoNav: function toggleAutoNav() {
                this.toggleProperty('autoNav');
            },

            openAutoNav: function openAutoNav() {
                this.set('autoNavOpen', true);
            },

            closeAutoNav: function closeAutoNav() {
                this.set('autoNavOpen', false);
            },

            closeMobileMenu: function closeMobileMenu() {
                this.set('showMobileMenu', false);
            }
        }
    });

});
define('ghost/controllers/editor/edit', ['exports', 'ember', 'ghost/mixins/editor-base-controller'], function (exports, Ember, EditorControllerMixin) {

    'use strict';

    exports['default'] = Ember['default'].Controller.extend(EditorControllerMixin['default'], {
        actions: {
            openDeleteModal: function openDeleteModal() {
                this.send('openModal', 'delete-post', this.get('model'));
            }
        }
    });

});
define('ghost/controllers/editor/new', ['exports', 'ember', 'ghost/mixins/editor-base-controller'], function (exports, Ember, EditorControllerMixin) {

    'use strict';

    var EditorNewController = Ember['default'].Controller.extend(EditorControllerMixin['default'], {
        // Overriding autoSave on the base controller, as the new controller shouldn't be autosaving
        autoSave: Ember['default'].K,
        actions: {
            /**
              * Redirect to editor after the first save
              */
            save: function save(options) {
                var self = this;
                return this._super(options).then(function (model) {
                    if (model.get('id')) {
                        self.replaceRoute('editor.edit', model);
                    }
                });
            }
        }
    });

    exports['default'] = EditorNewController;

});
define('ghost/controllers/error', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    var ErrorController = Ember['default'].Controller.extend({
        code: Ember['default'].computed('content.status', function () {
            return this.get('content.status') > 200 ? this.get('content.status') : 500;
        }),
        message: Ember['default'].computed('content.statusText', function () {
            if (this.get('code') === 404) {
                return 'Page not found';
            }

            return this.get('content.statusText') !== 'error' ? this.get('content.statusText') : 'Internal Server Error';
        }),
        stack: false
    });

    exports['default'] = ErrorController;

});
define('ghost/controllers/feature', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    var FeatureController = Ember['default'].Controller.extend(Ember['default'].PromiseProxyMixin, {
        init: function init() {
            var promise;

            promise = this.store.find('setting', { type: 'blog,theme' }).then(function (settings) {
                return settings.get('firstObject');
            });

            this.set('promise', promise);
        },

        setting: Ember['default'].computed.alias('content'),

        labs: Ember['default'].computed('isSettled', 'setting.labs', function () {
            var value = {};

            if (this.get('isFulfilled')) {
                try {
                    value = JSON.parse(this.get('setting.labs') || {});
                } catch (err) {
                    value = {};
                }
            }

            return value;
        })
    });

    exports['default'] = FeatureController;

});
define('ghost/controllers/modals/copy-html', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    exports['default'] = Ember['default'].Controller.extend({
        generatedHTML: Ember['default'].computed.alias('model.generatedHTML')
    });

});
define('ghost/controllers/modals/delete-all', ['exports', 'ember', 'ic-ajax'], function (exports, Ember, ic_ajax) {

    'use strict';

    exports['default'] = Ember['default'].Controller.extend({
        ghostPaths: Ember['default'].inject.service('ghost-paths'),
        notifications: Ember['default'].inject.service(),

        actions: {
            confirmAccept: function confirmAccept() {
                var self = this;

                ic_ajax.request(this.get('ghostPaths.url').api('db'), {
                    type: 'DELETE'
                }).then(function () {
                    self.get('notifications').showAlert('All content deleted from database.', { type: 'success' });
                    self.store.unloadAll('post');
                    self.store.unloadAll('tag');
                })['catch'](function (response) {
                    self.get('notifications').showAPIError(response);
                });
            },

            confirmReject: function confirmReject() {
                return false;
            }
        },

        confirm: {
            accept: {
                text: 'Delete',
                buttonClass: 'btn btn-red'
            },
            reject: {
                text: 'Cancel',
                buttonClass: 'btn btn-default btn-minor'
            }
        }
    });

});
define('ghost/controllers/modals/delete-post', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    exports['default'] = Ember['default'].Controller.extend({
        dropdown: Ember['default'].inject.service(),
        notifications: Ember['default'].inject.service(),

        actions: {
            confirmAccept: function confirmAccept() {
                var self = this,
                    model = this.get('model');

                // definitely want to clear the data store and post of any unsaved, client-generated tags
                model.updateTags();

                model.destroyRecord().then(function () {
                    self.get('dropdown').closeDropdowns();
                    self.transitionToRoute('posts.index');
                }, function () {
                    self.get('notifications').showAlert('Your post could not be deleted. Please try again.', { type: 'error' });
                });
            },

            confirmReject: function confirmReject() {
                return false;
            }
        },

        confirm: {
            accept: {
                text: 'Delete',
                buttonClass: 'btn btn-red'
            },
            reject: {
                text: 'Cancel',
                buttonClass: 'btn btn-default btn-minor'
            }
        }
    });

});
define('ghost/controllers/modals/delete-tag', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    exports['default'] = Ember['default'].Controller.extend({
        notifications: Ember['default'].inject.service(),

        postInflection: Ember['default'].computed('model.post_count', function () {
            return this.get('model.post_count') > 1 ? 'posts' : 'post';
        }),

        actions: {
            confirmAccept: function confirmAccept() {
                var tag = this.get('model'),
                    self = this;

                this.send('closeMenus');

                tag.destroyRecord()['catch'](function (error) {
                    self.get('notifications').showAPIError(error);
                });
            },

            confirmReject: function confirmReject() {
                return false;
            }
        },

        confirm: {
            accept: {
                text: 'Delete',
                buttonClass: 'btn btn-red'
            },
            reject: {
                text: 'Cancel',
                buttonClass: 'btn btn-default btn-minor'
            }
        }
    });

});
define('ghost/controllers/modals/delete-user', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    exports['default'] = Ember['default'].Controller.extend({
        notifications: Ember['default'].inject.service(),

        userPostCount: Ember['default'].computed('model.id', function () {
            var promise,
                query = {
                author: this.get('model.slug'),
                status: 'all'
            };

            promise = this.store.find('post', query).then(function (results) {
                return results.meta.pagination.total;
            });

            return Ember['default'].Object.extend(Ember['default'].PromiseProxyMixin, {
                count: Ember['default'].computed.alias('content'),

                inflection: Ember['default'].computed('count', function () {
                    return this.get('count') > 1 ? 'posts' : 'post';
                })
            }).create({ promise: promise });
        }),

        actions: {
            confirmAccept: function confirmAccept() {
                var self = this,
                    user = this.get('model');

                user.destroyRecord().then(function () {
                    self.store.unloadAll('post');
                    self.transitionToRoute('team');
                }, function () {
                    self.get('notifications').showAlert('The user could not be deleted. Please try again.', { type: 'error' });
                });
            },

            confirmReject: function confirmReject() {
                return false;
            }
        },

        confirm: {
            accept: {
                text: 'Delete User',
                buttonClass: 'btn btn-red'
            },
            reject: {
                text: 'Cancel',
                buttonClass: 'btn btn-default btn-minor'
            }
        }
    });

});
define('ghost/controllers/modals/invite-new-user', ['exports', 'ember', 'ghost/mixins/validation-engine'], function (exports, Ember, ValidationEngine) {

    'use strict';

    exports['default'] = Ember['default'].Controller.extend(ValidationEngine['default'], {
        notifications: Ember['default'].inject.service(),

        validationType: 'signup',

        role: null,
        authorRole: null,

        roles: Ember['default'].computed(function () {
            return this.store.find('role', { permissions: 'assign' });
        }),

        // Used to set the initial value for the dropdown
        authorRoleObserver: Ember['default'].observer('roles.@each.role', function () {
            var self = this;

            this.get('roles').then(function (roles) {
                var authorRole = roles.findBy('name', 'Author');

                self.set('authorRole', authorRole);

                if (!self.get('role')) {
                    self.set('role', authorRole);
                }
            });
        }),

        confirm: {
            accept: {
                text: 'send invitation now'
            },
            reject: {
                buttonClass: 'hidden'
            }
        },

        actions: {
            setRole: function setRole(role) {
                this.set('role', role);
            },

            confirmAccept: function confirmAccept() {
                var email = this.get('email'),
                    role = this.get('role'),
                    validationErrors = this.get('errors.messages'),
                    self = this,
                    newUser;

                // reset the form and close the modal
                this.set('email', '');
                this.set('role', self.get('authorRole'));

                this.store.find('user').then(function (result) {
                    var invitedUser = result.findBy('email', email);

                    if (invitedUser) {
                        if (invitedUser.get('status') === 'invited' || invitedUser.get('status') === 'invited-pending') {
                            self.get('notifications').showAlert('A user with that email address was already invited.', { type: 'warn' });
                        } else {
                            self.get('notifications').showAlert('A user with that email address already exists.', { type: 'warn' });
                        }
                    } else {
                        newUser = self.store.createRecord('user', {
                            email: email,
                            status: 'invited',
                            role: role
                        });

                        newUser.save().then(function () {
                            var notificationText = 'Invitation sent! (' + email + ')';

                            // If sending the invitation email fails, the API will still return a status of 201
                            // but the user's status in the response object will be 'invited-pending'.
                            if (newUser.get('status') === 'invited-pending') {
                                self.get('notifications').showAlert('Invitation email was not sent.  Please try resending.', { type: 'error' });
                            } else {
                                self.get('notifications').showNotification(notificationText);
                            }
                        })['catch'](function (errors) {
                            newUser.deleteRecord();
                            // TODO: user model includes ValidationEngine mixin so
                            // save is overridden in order to validate, we probably
                            // want to use inline-validations here and only show an
                            // alert if we have an actual error
                            if (errors) {
                                self.get('notifications').showErrors(errors);
                            } else if (validationErrors) {
                                self.get('notifications').showAlert(validationErrors.toString(), { type: 'error' });
                            }
                        })['finally'](function () {
                            self.get('errors').clear();
                        });
                    }
                });
            },

            confirmReject: function confirmReject() {
                return false;
            }
        }
    });

});
define('ghost/controllers/modals/leave-editor', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    exports['default'] = Ember['default'].Controller.extend({
        notifications: Ember['default'].inject.service(),

        args: Ember['default'].computed.alias('model'),

        actions: {
            confirmAccept: function confirmAccept() {
                var args = this.get('args'),
                    editorController,
                    model,
                    transition;

                if (Ember['default'].isArray(args)) {
                    editorController = args[0];
                    transition = args[1];
                    model = editorController.get('model');
                }

                if (!transition || !editorController) {
                    this.get('notifications').showNotification('Sorry, there was an error in the application. Please let the Ghost team know what happened.', { type: 'error' });

                    return true;
                }

                // definitely want to clear the data store and post of any unsaved, client-generated tags
                model.updateTags();

                if (model.get('isNew')) {
                    // the user doesn't want to save the new, unsaved post, so delete it.
                    model.deleteRecord();
                } else {
                    // roll back changes on model props
                    model.rollback();
                }

                // setting isDirty to false here allows willTransition on the editor route to succeed
                editorController.set('isDirty', false);

                // since the transition is now certain to complete, we can unset window.onbeforeunload here
                window.onbeforeunload = null;

                transition.retry();
            },

            confirmReject: function confirmReject() {}
        },

        confirm: {
            accept: {
                text: 'Leave',
                buttonClass: 'btn btn-red'
            },
            reject: {
                text: 'Stay',
                buttonClass: 'btn btn-default btn-minor'
            }
        }
    });

});
define('ghost/controllers/modals/signin', ['exports', 'ember', 'ghost/mixins/validation-engine'], function (exports, Ember, ValidationEngine) {

    'use strict';

    exports['default'] = Ember['default'].Controller.extend(ValidationEngine['default'], {
        validationType: 'signin',
        submitting: false,

        application: Ember['default'].inject.controller(),
        notifications: Ember['default'].inject.service(),

        identification: Ember['default'].computed('session.user.email', function () {
            return this.get('session.user.email');
        }),

        actions: {
            authenticate: function authenticate() {
                var appController = this.get('application'),
                    authStrategy = 'ghost-authenticator:oauth2-password-grant',
                    data = this.getProperties('identification', 'password'),
                    self = this;

                appController.set('skipAuthSuccessHandler', true);

                this.get('session').authenticate(authStrategy, data).then(function () {
                    self.send('closeModal');
                    self.set('password', '');
                })['catch'](function () {
                    // if authentication fails a rejected promise will be returned.
                    // it needs to be caught so it doesn't generate an exception in the console,
                    // but it's actually "handled" by the sessionAuthenticationFailed action handler.
                })['finally'](function () {
                    self.toggleProperty('submitting');
                    appController.set('skipAuthSuccessHandler', undefined);
                });
            },

            validateAndAuthenticate: function validateAndAuthenticate() {
                var self = this;

                this.toggleProperty('submitting');

                // Manually trigger events for input fields, ensuring legacy compatibility with
                // browsers and password managers that don't send proper events on autofill
                $('#login').find('input').trigger('change');

                this.validate({ format: false }).then(function () {
                    self.send('authenticate');
                })['catch'](function (errors) {
                    self.get('notifications').showErrors(errors);
                });
            },

            confirmAccept: function confirmAccept() {
                this.send('validateAndAuthenticate');
            }
        }
    });

});
define('ghost/controllers/modals/transfer-owner', ['exports', 'ember', 'ic-ajax'], function (exports, Ember, ic_ajax) {

    'use strict';

    exports['default'] = Ember['default'].Controller.extend({
        dropdown: Ember['default'].inject.service(),
        ghostPaths: Ember['default'].inject.service('ghost-paths'),
        notifications: Ember['default'].inject.service(),

        actions: {
            confirmAccept: function confirmAccept() {
                var user = this.get('model'),
                    url = this.get('ghostPaths.url').api('users', 'owner'),
                    self = this;

                self.get('dropdown').closeDropdowns();

                ic_ajax.request(url, {
                    type: 'PUT',
                    data: {
                        owner: [{
                            id: user.get('id')
                        }]
                    }
                }).then(function (response) {
                    // manually update the roles for the users that just changed roles
                    // because store.pushPayload is not working with embedded relations
                    if (response && Ember['default'].isArray(response.users)) {
                        response.users.forEach(function (userJSON) {
                            var user = self.store.getById('user', userJSON.id),
                                role = self.store.getById('role', userJSON.roles[0].id);

                            user.set('role', role);
                        });
                    }

                    self.get('notifications').showAlert('Ownership successfully transferred to ' + user.get('name'), { type: 'success' });
                })['catch'](function (error) {
                    self.get('notifications').showAPIError(error);
                });
            },

            confirmReject: function confirmReject() {
                return false;
            }
        },

        confirm: {
            accept: {
                text: 'Yep - I\'m sure',
                buttonClass: 'btn btn-red'
            },
            reject: {
                text: 'Cancel',
                buttonClass: 'btn btn-default btn-minor'
            }
        }
    });

});
define('ghost/controllers/modals/upload', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    exports['default'] = Ember['default'].Controller.extend({
        notifications: Ember['default'].inject.service(),

        acceptEncoding: 'image/*',

        actions: {
            confirmAccept: function confirmAccept() {
                var notifications = this.get('notifications');

                this.get('model').save().then(function (model) {
                    return model;
                })['catch'](function (err) {
                    notifications.showAPIError(err);
                });
            },

            confirmReject: function confirmReject() {
                return false;
            }
        }
    });

});
define('ghost/controllers/post-settings-menu', ['exports', 'ember', 'ghost/utils/date-formatting', 'ghost/mixins/settings-menu-controller', 'ghost/models/slug-generator', 'ghost/utils/bound-one-way', 'ghost/utils/isNumber'], function (exports, Ember, date_formatting, SettingsMenuMixin, SlugGenerator, boundOneWay, isNumber) {

    'use strict';

    exports['default'] = Ember['default'].Controller.extend(SettingsMenuMixin['default'], {
        debounceId: null,
        lastPromise: null,
        selectedAuthor: null,
        uploaderReference: null,

        application: Ember['default'].inject.controller(),
        config: Ember['default'].inject.service(),
        ghostPaths: Ember['default'].inject.service('ghost-paths'),
        notifications: Ember['default'].inject.service(),

        initializeSelectedAuthor: Ember['default'].observer('model', function () {
            var self = this;

            return this.get('model.author').then(function (author) {
                self.set('selectedAuthor', author);
                return author;
            });
        }),

        authors: Ember['default'].computed(function () {
            // Loaded asynchronously, so must use promise proxies.
            var deferred = {};

            deferred.promise = this.store.find('user', { limit: 'all' }).then(function (users) {
                return users.rejectBy('id', 'me').sortBy('name');
            }).then(function (users) {
                return users.filter(function (user) {
                    return user.get('active');
                });
            });

            return Ember['default'].ArrayProxy.extend(Ember['default'].PromiseProxyMixin).create(deferred);
        }),

        /*jshint unused:false */
        publishedAtValue: Ember['default'].computed('model.published_at', {
            get: function get() {
                var pubDate = this.get('model.published_at');

                if (pubDate) {
                    return date_formatting.formatDate(pubDate);
                }

                return date_formatting.formatDate(moment());
            },
            set: function set(key, value) {
                // We're using a fake setter to reset
                // the cache for this property
                return date_formatting.formatDate(moment());
            }
        }),
        /*jshint unused:true */

        slugValue: boundOneWay['default']('model.slug'),

        // Lazy load the slug generator
        slugGenerator: Ember['default'].computed(function () {
            return SlugGenerator['default'].create({
                ghostPaths: this.get('ghostPaths'),
                slugType: 'post'
            });
        }),

        // Requests slug from title
        generateAndSetSlug: function generateAndSetSlug(destination) {
            var self = this,
                title = this.get('model.titleScratch'),
                afterSave = this.get('lastPromise'),
                promise;

            // Only set an "untitled" slug once per post
            if (title === '(Untitled)' && this.get('model.slug')) {
                return;
            }

            promise = Ember['default'].RSVP.resolve(afterSave).then(function () {
                return self.get('slugGenerator').generateSlug(title).then(function (slug) {
                    self.set(destination, slug);
                })['catch'](function () {
                    // Nothing to do (would be nice to log this somewhere though),
                    // but a rejected promise needs to be handled here so that a resolved
                    // promise is returned.
                });
            });

            this.set('lastPromise', promise);
        },

        metaTitleScratch: boundOneWay['default']('model.meta_title'),
        metaDescriptionScratch: boundOneWay['default']('model.meta_description'),

        seoTitle: Ember['default'].computed('model.titleScratch', 'metaTitleScratch', function () {
            var metaTitle = this.get('metaTitleScratch') || '';

            metaTitle = metaTitle.length > 0 ? metaTitle : this.get('model.titleScratch');

            if (metaTitle.length > 70) {
                metaTitle = metaTitle.substring(0, 70).trim();
                metaTitle = Ember['default'].Handlebars.Utils.escapeExpression(metaTitle);
                metaTitle = Ember['default'].String.htmlSafe(metaTitle + '&hellip;');
            }

            return metaTitle;
        }),

        seoDescription: Ember['default'].computed('model.scratch', 'metaDescriptionScratch', function () {
            var metaDescription = this.get('metaDescriptionScratch') || '',
                el,
                html = '',
                placeholder;

            if (metaDescription.length > 0) {
                placeholder = metaDescription;
            } else {
                el = $('.rendered-markdown');

                // Get rendered markdown
                if (el !== undefined && el.length > 0) {
                    html = el.clone();
                    html.find('.js-drop-zone').remove();
                    html = html[0].innerHTML;
                }

                // Strip HTML
                placeholder = $('<div />', { html: html }).text();
                // Replace new lines and trim
                // jscs: disable
                placeholder = placeholder.replace(/\n+/g, ' ').trim();
                // jscs: enable
            }

            if (placeholder.length > 156) {
                // Limit to 156 characters
                placeholder = placeholder.substring(0, 156).trim();
                placeholder = Ember['default'].Handlebars.Utils.escapeExpression(placeholder);
                placeholder = Ember['default'].String.htmlSafe(placeholder + '&hellip;');
            }

            return placeholder;
        }),

        seoURL: Ember['default'].computed('model.slug', 'config.blogUrl', function () {
            var blogUrl = this.get('config.blogUrl'),
                seoSlug = this.get('model.slug') ? this.get('model.slug') : '',
                seoURL = blogUrl + '/' + seoSlug;

            // only append a slash to the URL if the slug exists
            if (seoSlug) {
                seoURL += '/';
            }

            if (seoURL.length > 70) {
                seoURL = seoURL.substring(0, 70).trim();
                seoURL = Ember['default'].String.htmlSafe(seoURL + '&hellip;');
            }

            return seoURL;
        }),

        // observe titleScratch, keeping the post's slug in sync
        // with it until saved for the first time.
        addTitleObserver: Ember['default'].observer('model', function () {
            if (this.get('model.isNew') || this.get('model.title') === '(Untitled)') {
                this.addObserver('model.titleScratch', this, 'titleObserver');
            }
        }),

        titleObserver: function titleObserver() {
            var debounceId,
                title = this.get('model.title');

            // generate a slug if a post is new and doesn't have a title yet or
            // if the title is still '(Untitled)' and the slug is unaltered.
            if (this.get('model.isNew') && !title || title === '(Untitled)') {
                debounceId = Ember['default'].run.debounce(this, 'generateAndSetSlug', 'model.slug', 700);
            }

            this.set('debounceId', debounceId);
        },

        // live-query of all tags for tag input autocomplete
        availableTags: Ember['default'].computed(function () {
            return this.get('store').filter('tag', { limit: 'all' }, function () {
                return true;
            });
        }),

        showErrors: function showErrors(errors) {
            errors = Ember['default'].isArray(errors) ? errors : [errors];
            this.get('notifications').showErrors(errors);
        },

        actions: {
            togglePage: function togglePage() {
                var self = this;

                this.toggleProperty('model.page');
                // If this is a new post.  Don't save the model.  Defer the save
                // to the user pressing the save button
                if (this.get('model.isNew')) {
                    return;
                }

                this.get('model').save()['catch'](function (errors) {
                    self.showErrors(errors);
                    self.get('model').rollback();
                });
            },

            toggleFeatured: function toggleFeatured() {
                var self = this;

                this.toggleProperty('model.featured');

                // If this is a new post.  Don't save the model.  Defer the save
                // to the user pressing the save button
                if (this.get('model.isNew')) {
                    return;
                }

                this.get('model').save(this.get('saveOptions'))['catch'](function (errors) {
                    self.showErrors(errors);
                    self.get('model').rollback();
                });
            },

            /**
             * triggered by user manually changing slug
             */
            updateSlug: function updateSlug(newSlug) {
                var slug = this.get('model.slug'),
                    self = this;

                newSlug = newSlug || slug;

                newSlug = newSlug && newSlug.trim();

                // Ignore unchanged slugs or candidate slugs that are empty
                if (!newSlug || slug === newSlug) {
                    // reset the input to its previous state
                    this.set('slugValue', slug);

                    return;
                }

                this.get('slugGenerator').generateSlug(newSlug).then(function (serverSlug) {
                    // If after getting the sanitized and unique slug back from the API
                    // we end up with a slug that matches the existing slug, abort the change
                    if (serverSlug === slug) {
                        return;
                    }

                    // Because the server transforms the candidate slug by stripping
                    // certain characters and appending a number onto the end of slugs
                    // to enforce uniqueness, there are cases where we can get back a
                    // candidate slug that is a duplicate of the original except for
                    // the trailing incrementor (e.g., this-is-a-slug and this-is-a-slug-2)

                    // get the last token out of the slug candidate and see if it's a number
                    var slugTokens = serverSlug.split('-'),
                        check = Number(slugTokens.pop());

                    // if the candidate slug is the same as the existing slug except
                    // for the incrementor then the existing slug should be used
                    if (isNumber['default'](check) && check > 0) {
                        if (slug === slugTokens.join('-') && serverSlug !== newSlug) {
                            self.set('slugValue', slug);

                            return;
                        }
                    }

                    self.set('model.slug', serverSlug);

                    if (self.hasObserverFor('model.titleScratch')) {
                        self.removeObserver('model.titleScratch', self, 'titleObserver');
                    }

                    // If this is a new post.  Don't save the model.  Defer the save
                    // to the user pressing the save button
                    if (self.get('model.isNew')) {
                        return;
                    }

                    return self.get('model').save();
                })['catch'](function (errors) {
                    self.showErrors(errors);
                    self.get('model').rollback();
                });
            },

            /**
             * Parse user's set published date.
             * Action sent by post settings menu view.
             * (#1351)
             */
            setPublishedAt: function setPublishedAt(userInput) {
                var errMessage = '',
                    newPublishedAt = date_formatting.parseDateString(userInput),
                    publishedAt = this.get('model.published_at'),
                    self = this;

                if (!userInput) {
                    // Clear out the published_at field for a draft
                    if (this.get('model.isDraft')) {
                        this.set('model.published_at', null);
                    }

                    return;
                }

                // Validate new Published date
                if (!newPublishedAt.isValid()) {
                    errMessage = 'Published Date must be a valid date with format: ' + 'DD MMM YY @ HH:mm (e.g. 6 Dec 14 @ 15:00)';
                }
                if (newPublishedAt.diff(new Date(), 'h') > 0) {
                    errMessage = 'Published Date cannot currently be in the future.';
                }

                // If errors, notify and exit.
                if (errMessage) {
                    this.get('model.errors').add('post-setting-date', errMessage);

                    return;
                }

                // Do nothing if the user didn't actually change the date
                if (publishedAt && publishedAt.isSame(newPublishedAt)) {
                    return;
                }

                // Validation complete
                this.set('model.published_at', newPublishedAt);

                // If this is a new post.  Don't save the model.  Defer the save
                // to the user pressing the save button
                if (this.get('model.isNew')) {
                    return;
                }

                this.get('model').save()['catch'](function (errors) {
                    self.showErrors(errors);
                    self.get('model').rollback();
                });
            },

            setMetaTitle: function setMetaTitle(metaTitle) {
                var property = 'meta_title',
                    model = this.get('model'),
                    currentTitle = model.get(property) || '';

                // Only update if the title has changed
                if (currentTitle === metaTitle) {
                    return;
                }

                model.set(property, metaTitle);

                // If this is a new post.  Don't save the model.  Defer the save
                // to the user pressing the save button
                if (model.get('isNew')) {
                    return;
                }

                model.save();
            },

            setMetaDescription: function setMetaDescription(metaDescription) {
                var property = 'meta_description',
                    model = this.get('model'),
                    currentDescription = model.get(property) || '';

                // Only update if the description has changed
                if (currentDescription === metaDescription) {
                    return;
                }

                model.set(property, metaDescription);

                // If this is a new post.  Don't save the model.  Defer the save
                // to the user pressing the save button
                if (model.get('isNew')) {
                    return;
                }

                model.save();
            },

            setCoverImage: function setCoverImage(image) {
                var self = this;

                this.set('model.image', image);

                if (this.get('model.isNew')) {
                    return;
                }

                this.get('model').save()['catch'](function (errors) {
                    self.showErrors(errors);
                    self.get('model').rollback();
                });
            },

            clearCoverImage: function clearCoverImage() {
                var self = this;

                this.set('model.image', '');

                if (this.get('model.isNew')) {
                    return;
                }

                this.get('model').save()['catch'](function (errors) {
                    self.showErrors(errors);
                    self.get('model').rollback();
                });
            },

            resetUploader: function resetUploader() {
                var uploader = this.get('uploaderReference');

                if (uploader && uploader[0]) {
                    uploader[0].uploaderUi.reset();
                }
            },

            resetPubDate: function resetPubDate() {
                this.set('publishedAtValue', '');
            },

            closeNavMenu: function closeNavMenu() {
                this.get('application').send('closeNavMenu');
            },

            changeAuthor: function changeAuthor(newAuthor) {
                var author = this.get('model.author'),
                    model = this.get('model'),
                    self = this;

                // return if nothing changed
                if (newAuthor.get('id') === author.get('id')) {
                    return;
                }

                model.set('author', newAuthor);

                // if this is a new post (never been saved before), don't try to save it
                if (this.get('model.isNew')) {
                    return;
                }

                model.save()['catch'](function (errors) {
                    self.showErrors(errors);
                    self.set('selectedAuthor', author);
                    model.rollback();
                });
            },

            addTag: function addTag(tagName, index) {
                var self = this,
                    currentTags = this.get('model.tags'),
                    currentTagNames = currentTags.map(function (tag) {
                    return tag.get('name').toLowerCase();
                }),
                    availableTagNames = null,
                    tagToAdd = null;

                tagName = tagName.trim();

                // abort if tag is already selected
                if (currentTagNames.contains(tagName.toLowerCase())) {
                    return;
                }

                this.get('availableTags').then(function (availableTags) {
                    availableTagNames = availableTags.map(function (tag) {
                        return tag.get('name').toLowerCase();
                    });

                    // find existing tag or create new
                    if (availableTagNames.contains(tagName.toLowerCase())) {
                        tagToAdd = availableTags.find(function (tag) {
                            return tag.get('name').toLowerCase() === tagName.toLowerCase();
                        });
                    } else {
                        tagToAdd = self.get('store').createRecord('tag', {
                            name: tagName
                        });

                        // we need to set a UUID so that selectize has a unique value
                        // it will be ignored when sent to the server
                        tagToAdd.set('uuid', Ember['default'].guidFor(tagToAdd));
                    }

                    // push tag onto post relationship
                    if (tagToAdd) {
                        self.get('model.tags').insertAt(index, tagToAdd);
                    }
                });
            },

            removeTag: function removeTag(tag) {
                this.get('model.tags').removeObject(tag);

                if (tag.get('isNew')) {
                    tag.destroyRecord();
                }
            }
        }
    });

});
define('ghost/controllers/posts', ['exports', 'ember', 'ghost/mixins/pagination-controller'], function (exports, Ember, PaginationControllerMixin) {

    'use strict';

    function comparator(item1, item2) {
        var updated1 = item1.get('updated_at'),
            updated2 = item2.get('updated_at'),
            idResult,
            statusResult,
            updatedAtResult,
            publishedAtResult;

        // when `updated_at` is undefined, the model is still
        // being written to with the results from the server
        if (item1.get('isNew') || !updated1) {
            return -1;
        }

        if (item2.get('isNew') || !updated2) {
            return 1;
        }

        idResult = Ember['default'].compare(parseInt(item1.get('id')), parseInt(item2.get('id')));
        statusResult = Ember['default'].compare(item1.get('status'), item2.get('status'));
        updatedAtResult = Ember['default'].compare(updated1.valueOf(), updated2.valueOf());
        publishedAtResult = publishedAtCompare(item1, item2);

        if (statusResult === 0) {
            if (publishedAtResult === 0) {
                if (updatedAtResult === 0) {
                    // This should be DESC
                    return idResult * -1;
                }
                // This should be DESC
                return updatedAtResult * -1;
            }
            // This should be DESC
            return publishedAtResult * -1;
        }

        return statusResult;
    }

    function publishedAtCompare(item1, item2) {
        var published1 = item1.get('published_at'),
            published2 = item2.get('published_at');

        if (!published1 && !published2) {
            return 0;
        }

        if (!published1 && published2) {
            return -1;
        }

        if (!published2 && published1) {
            return 1;
        }

        return Ember['default'].compare(published1.valueOf(), published2.valueOf());
    }

    exports['default'] = Ember['default'].Controller.extend(PaginationControllerMixin['default'], {
        // See PostsRoute's shortcuts
        postListFocused: Ember['default'].computed.equal('keyboardFocus', 'postList'),
        postContentFocused: Ember['default'].computed.equal('keyboardFocus', 'postContent'),

        sortedPosts: Ember['default'].computed('model.@each.status', 'model.@each.published_at', 'model.@each.isNew', 'model.@each.updated_at', function () {
            var postsArray = this.get('model').toArray();

            return postsArray.sort(comparator);
        }),

        init: function init() {
            // let the PaginationControllerMixin know what type of model we will be paginating
            // this is necessary because we do not have access to the model inside the Controller::init method
            this._super({ modelType: 'post' });
        },

        actions: {
            showPostContent: function showPostContent(post) {
                if (!post) {
                    return;
                }

                this.transitionToRoute('posts.post', post);
            }
        }
    });

});
define('ghost/controllers/reset', ['exports', 'ember', 'ic-ajax', 'ghost/mixins/validation-engine'], function (exports, Ember, ic_ajax, ValidationEngine) {

    'use strict';

    exports['default'] = Ember['default'].Controller.extend(ValidationEngine['default'], {
        newPassword: '',
        ne2Password: '',
        token: '',
        submitting: false,
        flowErrors: '',

        validationType: 'reset',

        ghostPaths: Ember['default'].inject.service('ghost-paths'),
        notifications: Ember['default'].inject.service(),

        email: Ember['default'].computed('token', function () {
            // The token base64 encodes the email (and some other stuff),
            // each section is divided by a '|'. Email comes second.
            return atob(this.get('token')).split('|')[1];
        }),

        // Used to clear sensitive information
        clearData: function clearData() {
            this.setProperties({
                newPassword: '',
                ne2Password: '',
                token: ''
            });
        },

        actions: {
            submit: function submit() {
                var credentials = this.getProperties('newPassword', 'ne2Password', 'token'),
                    self = this;
                this.set('flowErrors', '');
                this.get('hasValidated').addObjects(['newPassword', 'ne2Password']);
                this.validate().then(function () {
                    self.toggleProperty('submitting');
                    ic_ajax.request({
                        url: self.get('ghostPaths.url').api('authentication', 'passwordreset'),
                        type: 'PUT',
                        data: {
                            passwordreset: [credentials]
                        }
                    }).then(function (resp) {
                        self.toggleProperty('submitting');
                        self.get('notifications').showAlert(resp.passwordreset[0].message, { type: 'warn', delayed: true });
                        self.get('session').authenticate('ghost-authenticator:oauth2-password-grant', {
                            identification: self.get('email'),
                            password: credentials.newPassword
                        });
                    })['catch'](function (response) {
                        self.get('notifications').showAPIError(response);
                        self.toggleProperty('submitting');
                    });
                })['catch'](function () {
                    if (self.get('errors.newPassword')) {
                        self.set('flowErrors', self.get('errors.newPassword')[0].message);
                    }

                    if (self.get('errors.ne2Password')) {
                        self.set('flowErrors', self.get('errors.ne2Password')[0].message);
                    }
                });
            }
        }
    });

});
define('ghost/controllers/settings/code-injection', ['exports', 'ember', 'ghost/mixins/settings-save'], function (exports, Ember, SettingsSaveMixin) {

    'use strict';

    exports['default'] = Ember['default'].Controller.extend(SettingsSaveMixin['default'], {
        notifications: Ember['default'].inject.service(),

        save: function save() {
            var notifications = this.get('notifications');

            return this.get('model').save()['catch'](function (error) {
                notifications.showAPIError(error);
            });
        }
    });

});
define('ghost/controllers/settings/general', ['exports', 'ember', 'ghost/mixins/settings-save', 'ghost/utils/random-password'], function (exports, Ember, SettingsSaveMixin, randomPassword) {

    'use strict';

    exports['default'] = Ember['default'].Controller.extend(SettingsSaveMixin['default'], {
        notifications: Ember['default'].inject.service(),
        config: Ember['default'].inject.service(),

        selectedTheme: Ember['default'].computed('model.activeTheme', 'themes', function () {
            var activeTheme = this.get('model.activeTheme'),
                themes = this.get('themes'),
                selectedTheme;

            themes.forEach(function (theme) {
                if (theme.name === activeTheme) {
                    selectedTheme = theme;
                }
            });

            return selectedTheme;
        }),

        logoImageSource: Ember['default'].computed('model.logo', function () {
            return this.get('model.logo') || '';
        }),

        coverImageSource: Ember['default'].computed('model.cover', function () {
            return this.get('model.cover') || '';
        }),

        isDatedPermalinks: Ember['default'].computed('model.permalinks', {
            set: function set(key, value) {
                this.set('model.permalinks', value ? '/:year/:month/:day/:slug/' : '/:slug/');

                var slugForm = this.get('model.permalinks');
                return slugForm !== '/:slug/';
            },
            get: function get() {
                var slugForm = this.get('model.permalinks');

                return slugForm !== '/:slug/';
            }
        }),

        themes: Ember['default'].computed(function () {
            return this.get('model.availableThemes').reduce(function (themes, t) {
                var theme = {};

                theme.name = t.name;
                theme.label = t['package'] ? t['package'].name + ' - ' + t['package'].version : t.name;
                theme['package'] = t['package'];
                theme.active = !!t.active;

                themes.push(theme);

                return themes;
            }, []);
        }).readOnly(),

        generatePassword: Ember['default'].observer('model.isPrivate', function () {
            this.get('model.errors').remove('password');
            if (this.get('model.isPrivate') && this.get('model.isDirty')) {
                this.get('model').set('password', randomPassword['default']());
            }
        }),

        save: function save() {
            var notifications = this.get('notifications'),
                config = this.get('config');

            return this.get('model').save().then(function (model) {
                config.set('blogTitle', model.get('title'));

                return model;
            })['catch'](function (error) {
                if (error) {
                    notifications.showAPIError(error);
                }
            });
        },

        actions: {
            validate: function validate(property) {
                this.get('model').validate({ property: property });
            },

            checkPostsPerPage: function checkPostsPerPage() {
                var postsPerPage = this.get('model.postsPerPage');

                if (postsPerPage < 1 || postsPerPage > 1000 || isNaN(postsPerPage)) {
                    this.set('model.postsPerPage', 5);
                }
            },

            setTheme: function setTheme(theme) {
                this.set('model.activeTheme', theme.name);
            }
        }
    });

});
define('ghost/controllers/settings/labs', ['exports', 'ember', 'ic-ajax'], function (exports, Ember, ic_ajax) {

    'use strict';

    exports['default'] = Ember['default'].Controller.extend({
        uploadButtonText: 'Import',
        importErrors: '',
        submitting: false,

        ghostPaths: Ember['default'].inject.service('ghost-paths'),
        notifications: Ember['default'].inject.service(),

        labsJSON: Ember['default'].computed('model.labs', function () {
            return JSON.parse(this.get('model.labs') || {});
        }),

        saveLabs: function saveLabs(optionName, optionValue) {
            var self = this,
                labsJSON = this.get('labsJSON');

            // Set new value in the JSON object
            labsJSON[optionName] = optionValue;

            this.set('model.labs', JSON.stringify(labsJSON));

            this.get('model').save()['catch'](function (errors) {
                self.showErrors(errors);
                self.get('model').rollback();
            });
        },

        actions: {
            onUpload: function onUpload(file) {
                var self = this,
                    formData = new FormData(),
                    notifications = this.get('notifications'),
                    currentUserId = this.get('session.user.id');

                this.set('uploadButtonText', 'Importing');
                this.set('importErrors', '');

                formData.append('importfile', file);

                ic_ajax.request(this.get('ghostPaths.url').api('db'), {
                    type: 'POST',
                    data: formData,
                    dataType: 'json',
                    cache: false,
                    contentType: false,
                    processData: false
                }).then(function () {
                    // Clear the store, so that all the new data gets fetched correctly.
                    self.store.unloadAll();
                    // Reload currentUser and set session
                    self.set('session.user', self.store.find('user', currentUserId));
                    // TODO: keep as notification, add link to view content
                    notifications.showNotification('Import successful.');
                })['catch'](function (response) {
                    if (response && response.jqXHR && response.jqXHR.responseJSON && response.jqXHR.responseJSON.errors) {
                        self.set('importErrors', response.jqXHR.responseJSON.errors);
                    }

                    notifications.showAlert('Import Failed', { type: 'error' });
                })['finally'](function () {
                    self.set('uploadButtonText', 'Import');
                });
            },

            exportData: function exportData() {
                var iframe = $('#iframeDownload'),
                    downloadURL = this.get('ghostPaths.url').api('db') + '?access_token=' + this.get('session.secure.access_token');

                if (iframe.length === 0) {
                    iframe = $('<iframe>', { id: 'iframeDownload' }).hide().appendTo('body');
                }

                iframe.attr('src', downloadURL);
            },

            sendTestEmail: function sendTestEmail() {
                var notifications = this.get('notifications'),
                    self = this;

                this.toggleProperty('submitting');

                ic_ajax.request(this.get('ghostPaths.url').api('mail', 'test'), {
                    type: 'POST'
                }).then(function () {
                    notifications.showAlert('Check your email for the test message.', { type: 'info' });
                    self.toggleProperty('submitting');
                })['catch'](function (error) {
                    if (typeof error.jqXHR !== 'undefined') {
                        notifications.showAPIError(error);
                    } else {
                        notifications.showErrors(error);
                    }
                    self.toggleProperty('submitting');
                });
            }
        }
    });

});
define('ghost/controllers/settings/navigation', ['exports', 'ember', 'ghost/mixins/settings-save'], function (exports, Ember, SettingsSaveMixin) {

    'use strict';

    var NavItem = Ember['default'].Object.extend({
        label: '',
        url: '',
        last: false,

        isComplete: Ember['default'].computed('label', 'url', function () {
            return !(Ember['default'].isBlank(this.get('label').trim()) || Ember['default'].isBlank(this.get('url')));
        })
    });

    exports['default'] = Ember['default'].Controller.extend(SettingsSaveMixin['default'], {
        config: Ember['default'].inject.service(),
        notifications: Ember['default'].inject.service(),

        blogUrl: Ember['default'].computed('config.blogUrl', function () {
            var url = this.get('config.blogUrl');

            return url.slice(-1) !== '/' ? url + '/' : url;
        }),

        navigationItems: Ember['default'].computed('model.navigation', function () {
            var navItems, lastItem;

            try {
                navItems = JSON.parse(this.get('model.navigation') || [{}]);
            } catch (e) {
                navItems = [{}];
            }

            navItems = navItems.map(function (item) {
                return NavItem.create(item);
            });

            lastItem = navItems.get('lastObject');
            if (!lastItem || lastItem.get('isComplete')) {
                navItems.addObject(NavItem.create({ last: true }));
            }

            return navItems;
        }),

        updateLastNavItem: Ember['default'].observer('navigationItems.[]', function () {
            var navItems = this.get('navigationItems');

            navItems.forEach(function (item, index, items) {
                if (index === items.length - 1) {
                    item.set('last', true);
                } else {
                    item.set('last', false);
                }
            });
        }),

        save: function save() {
            var navSetting,
                blogUrl = this.get('config').blogUrl,
                blogUrlRegex = new RegExp('^' + blogUrl + '(.*)', 'i'),
                navItems = this.get('navigationItems'),
                message = 'One of your navigation items has an empty label. ' + '<br /> Please enter a new label or delete the item before saving.',
                match,
                notifications = this.get('notifications');

            // Don't save if there's a blank label.
            if (navItems.find(function (item) {
                return !item.get('isComplete') && !item.get('last');
            })) {
                notifications.showAlert(message.htmlSafe(), { type: 'error' });
                return;
            }

            navSetting = navItems.map(function (item) {
                var label, url;

                if (!item || !item.get('isComplete')) {
                    return;
                }

                label = item.get('label').trim();
                url = item.get('url').trim();

                // is this an internal URL?
                match = url.match(blogUrlRegex);

                if (match) {
                    url = match[1];

                    // if the last char is not a slash, then add one,
                    // as long as there is no # or . in the URL (anchor or file extension)
                    // this also handles the empty case for the homepage
                    if (url[url.length - 1] !== '/' && url.indexOf('#') === -1 && url.indexOf('.') === -1) {
                        url += '/';
                    }
                } else if (!validator.isURL(url) && url !== '' && url[0] !== '/' && url.indexOf('mailto:') !== 0) {
                    url = '/' + url;
                }

                return { label: label, url: url };
            }).compact();

            this.set('model.navigation', JSON.stringify(navSetting));

            // trigger change event because even if the final JSON is unchanged
            // we need to have navigationItems recomputed.
            this.get('model').notifyPropertyChange('navigation');

            return this.get('model').save()['catch'](function (err) {
                notifications.showErrors(err);
            });
        },

        actions: {
            addItem: function addItem() {
                var navItems = this.get('navigationItems'),
                    lastItem = navItems.get('lastObject');

                if (lastItem && lastItem.get('isComplete')) {
                    navItems.addObject(NavItem.create({ last: true })); // Adds new blank navItem
                }
            },

            deleteItem: function deleteItem(item) {
                if (!item) {
                    return;
                }

                var navItems = this.get('navigationItems');

                navItems.removeObject(item);
            },

            moveItem: function moveItem(index, newIndex) {
                var navItems = this.get('navigationItems'),
                    item = navItems.objectAt(index);

                navItems.removeAt(index);
                navItems.insertAt(newIndex, item);
            },

            updateUrl: function updateUrl(url, navItem) {
                if (!navItem) {
                    return;
                }

                if (Ember['default'].isBlank(url)) {
                    navItem.set('url', this.get('blogUrl'));

                    return;
                }

                navItem.set('url', url);
            }
        }
    });

});
define('ghost/controllers/settings/tags', ['exports', 'ember', 'ghost/mixins/pagination-controller', 'ghost/mixins/settings-menu-controller', 'ghost/utils/bound-one-way'], function (exports, Ember, PaginationMixin, SettingsMenuMixin, boundOneWay) {

    'use strict';

    exports['default'] = Ember['default'].Controller.extend(PaginationMixin['default'], SettingsMenuMixin['default'], {
        tags: Ember['default'].computed.alias('model'),

        activeTag: null,
        activeTagNameScratch: boundOneWay['default']('activeTag.name'),
        activeTagSlugScratch: boundOneWay['default']('activeTag.slug'),
        activeTagDescriptionScratch: boundOneWay['default']('activeTag.description'),
        activeTagMetaTitleScratch: boundOneWay['default']('activeTag.meta_title'),
        activeTagMetaDescriptionScratch: boundOneWay['default']('activeTag.meta_description'),

        init: function init(options) {
            options = options || {};
            options.modelType = 'tag';
            this._super(options);
        },

        application: Ember['default'].inject.controller(),
        config: Ember['default'].inject.service(),
        notifications: Ember['default'].inject.service(),

        uploaderReference: null,

        // This observer loads and resets the uploader whenever the active tag changes,
        // ensuring that we can reuse the whole settings menu.
        updateUploader: Ember['default'].observer('activeTag.image', 'uploaderReference', function () {
            var uploader = this.get('uploaderReference'),
                image = this.get('activeTag.image');

            if (uploader && uploader[0]) {
                if (image) {
                    uploader[0].uploaderUi.initWithImage();
                } else {
                    uploader[0].uploaderUi.reset();
                }
            }
        }),

        saveActiveTagProperty: function saveActiveTagProperty(propKey, newValue) {
            var activeTag = this.get('activeTag'),
                currentValue = activeTag.get(propKey),
                self = this;

            newValue = newValue.trim();

            // Quit if there was no change
            if (newValue === currentValue) {
                return;
            }

            activeTag.set(propKey, newValue);
            activeTag.get('hasValidated').addObject(propKey);

            activeTag.save()['catch'](function (error) {
                if (error) {
                    self.notifications.showAPIError(error);
                }
            });
        },

        seoTitle: Ember['default'].computed('scratch', 'activeTagNameScratch', 'activeTagMetaTitleScratch', function () {
            var metaTitle = this.get('activeTagMetaTitleScratch') || '';

            metaTitle = metaTitle.length > 0 ? metaTitle : this.get('activeTagNameScratch');

            if (metaTitle && metaTitle.length > 70) {
                metaTitle = metaTitle.substring(0, 70).trim();
                metaTitle = Ember['default'].Handlebars.Utils.escapeExpression(metaTitle);
                metaTitle = Ember['default'].String.htmlSafe(metaTitle + '&hellip;');
            }

            return metaTitle;
        }),

        seoURL: Ember['default'].computed('activeTagSlugScratch', function () {
            var blogUrl = this.get('config.blogUrl'),
                seoSlug = this.get('activeTagSlugScratch') ? this.get('activeTagSlugScratch') : '',
                seoURL = blogUrl + '/tag/' + seoSlug;

            // only append a slash to the URL if the slug exists
            if (seoSlug) {
                seoURL += '/';
            }

            if (seoURL.length > 70) {
                seoURL = seoURL.substring(0, 70).trim();
                seoURL = Ember['default'].String.htmlSafe(seoURL + '&hellip;');
            }

            return seoURL;
        }),

        seoDescription: Ember['default'].computed('scratch', 'activeTagDescriptionScratch', 'activeTagMetaDescriptionScratch', function () {
            var metaDescription = this.get('activeTagMetaDescriptionScratch') || '';

            metaDescription = metaDescription.length > 0 ? metaDescription : this.get('activeTagDescriptionScratch');

            if (metaDescription && metaDescription.length > 156) {
                metaDescription = metaDescription.substring(0, 156).trim();
                metaDescription = Ember['default'].Handlebars.Utils.escapeExpression(metaDescription);
                metaDescription = Ember['default'].String.htmlSafe(metaDescription + '&hellip;');
            }

            return metaDescription;
        }),

        actions: {
            newTag: function newTag() {
                this.set('activeTag', this.store.createRecord('tag', { post_count: 0 }));
                this.get('activeTag.errors').clear();
                this.send('openSettingsMenu');
            },

            editTag: function editTag(tag) {
                tag.validate();
                this.set('activeTag', tag);
                this.send('openSettingsMenu');
            },

            saveActiveTagName: function saveActiveTagName(name) {
                this.saveActiveTagProperty('name', name);
            },

            saveActiveTagSlug: function saveActiveTagSlug(slug) {
                this.saveActiveTagProperty('slug', slug);
            },

            saveActiveTagDescription: function saveActiveTagDescription(description) {
                this.saveActiveTagProperty('description', description);
            },

            saveActiveTagMetaTitle: function saveActiveTagMetaTitle(metaTitle) {
                this.saveActiveTagProperty('meta_title', metaTitle);
            },

            saveActiveTagMetaDescription: function saveActiveTagMetaDescription(metaDescription) {
                this.saveActiveTagProperty('meta_description', metaDescription);
            },

            setCoverImage: function setCoverImage(image) {
                this.saveActiveTagProperty('image', image);
            },

            clearCoverImage: function clearCoverImage() {
                this.saveActiveTagProperty('image', '');
            },

            closeNavMenu: function closeNavMenu() {
                this.get('application').send('closeNavMenu');
            },

            setUploaderReference: function setUploaderReference(ref) {
                this.set('uploaderReference', ref);
            }
        }
    });

});
define('ghost/controllers/setup', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    exports['default'] = Ember['default'].Controller.extend({
        appController: Ember['default'].inject.controller('application'),
        ghostPaths: Ember['default'].inject.service('ghost-paths'),

        showBackLink: Ember['default'].computed.match('appController.currentRouteName', /^setup\.(two|three)$/),

        backRoute: Ember['default'].computed('appController.currentRouteName', function () {
            var appController = this.get('appController'),
                currentRoute = Ember['default'].get(appController, 'currentRouteName');

            return currentRoute === 'setup.two' ? 'setup.one' : 'setup.two';
        })
    });

});
define('ghost/controllers/setup/three', ['exports', 'ember', 'ember-data'], function (exports, Ember, DS) {

    'use strict';

    exports['default'] = Ember['default'].Controller.extend({
        notifications: Ember['default'].inject.service(),
        two: Ember['default'].inject.controller('setup/two'),

        errors: DS['default'].Errors.create(),
        hasValidated: Ember['default'].A(),
        users: '',
        ownerEmail: Ember['default'].computed.alias('two.email'),
        submitting: false,

        usersArray: Ember['default'].computed('users', function () {
            var errors = this.get('errors'),
                users = this.get('users').split('\n').filter(function (email) {
                return email.trim().length > 0;
            });

            // remove "no users to invite" error if we have users
            if (users.uniq().length > 0 && errors.get('users.length') === 1) {
                if (errors.get('users.firstObject').message.match(/no users/i)) {
                    errors.remove('users');
                }
            }

            return users.uniq();
        }),

        validUsersArray: Ember['default'].computed('usersArray', 'ownerEmail', function () {
            var ownerEmail = this.get('ownerEmail');

            return this.get('usersArray').filter(function (user) {
                return validator.isEmail(user) && user !== ownerEmail;
            });
        }),

        invalidUsersArray: Ember['default'].computed('usersArray', 'ownerEmail', function () {
            var ownerEmail = this.get('ownerEmail');

            return this.get('usersArray').reject(function (user) {
                return validator.isEmail(user) || user === ownerEmail;
            });
        }),

        validationResult: Ember['default'].computed('invalidUsersArray', function () {
            var errors = [];

            this.get('invalidUsersArray').forEach(function (user) {
                errors.push({
                    user: user,
                    error: 'email'
                });
            });

            if (errors.length === 0) {
                // ensure we aren't highlighting fields when everything is fine
                this.get('errors').clear();
                return true;
            } else {
                return errors;
            }
        }),

        validate: function validate() {
            var errors = this.get('errors'),
                validationResult = this.get('validationResult'),
                property = 'users';

            errors.clear();

            // If property isn't in the `hasValidated` array, add it to mark that this field can show a validation result
            this.get('hasValidated').addObject(property);

            if (validationResult === true) {
                return true;
            }

            validationResult.forEach(function (error) {
                // Only one error type here so far, but one day the errors might be more detailed
                switch (error.error) {
                    case 'email':
                        errors.add(property, error.user + ' is not a valid email.');
                }
            });

            return false;
        },

        buttonText: Ember['default'].computed('errors.users', 'validUsersArray', 'invalidUsersArray', function () {
            var usersError = this.get('errors.users.firstObject.message'),
                validNum = this.get('validUsersArray').length,
                invalidNum = this.get('invalidUsersArray').length,
                userCount;

            if (usersError && usersError.match(/no users/i)) {
                return usersError;
            }

            if (invalidNum > 0) {
                userCount = invalidNum === 1 ? 'email address' : 'email addresses';
                return invalidNum + ' invalid ' + userCount;
            }

            if (validNum > 0) {
                userCount = validNum === 1 ? 'user' : 'users';
                userCount = validNum + ' ' + userCount;
            } else {
                userCount = 'some users';
            }

            return 'Invite ' + userCount;
        }),

        buttonClass: Ember['default'].computed('validationResult', 'usersArray.length', function () {
            if (this.get('validationResult') === true && this.get('usersArray.length') > 0) {
                return 'btn-green';
            } else {
                return 'btn-minor';
            }
        }),

        authorRole: Ember['default'].computed(function () {
            return this.store.find('role').then(function (roles) {
                return roles.findBy('name', 'Author');
            });
        }),

        actions: {
            validate: function validate() {
                this.validate();
            },

            invite: function invite() {
                var self = this,
                    users = this.get('usersArray'),
                    notifications = this.get('notifications'),
                    invitationsString;

                if (this.validate() && users.length > 0) {
                    this.toggleProperty('submitting');
                    this.get('authorRole').then(function (authorRole) {
                        Ember['default'].RSVP.Promise.all(users.map(function (user) {
                            var newUser = self.store.createRecord('user', {
                                email: user,
                                status: 'invited',
                                role: authorRole
                            });

                            return newUser.save().then(function () {
                                return {
                                    email: user,
                                    success: newUser.get('status') === 'invited'
                                };
                            })['catch'](function () {
                                return {
                                    email: user,
                                    success: false
                                };
                            });
                        })).then(function (invites) {
                            var successCount = 0,
                                erroredEmails = [],
                                message;

                            invites.forEach(function (invite) {
                                if (invite.success) {
                                    successCount++;
                                } else {
                                    erroredEmails.push(invite.email);
                                }
                            });

                            if (erroredEmails.length > 0) {
                                invitationsString = erroredEmails.length > 1 ? ' invitations: ' : ' invitation: ';
                                message = 'Failed to send ' + erroredEmails.length + invitationsString;
                                message += erroredEmails.join(', ');
                                notifications.showAlert(message, { type: 'error', delayed: successCount > 0 });
                            }

                            if (successCount > 0) {
                                // pluralize
                                invitationsString = successCount > 1 ? 'invitations' : 'invitation';
                                notifications.showAlert(successCount + ' ' + invitationsString + ' sent!', { type: 'success', delayed: true });
                            }
                            self.send('loadServerNotifications');
                            self.toggleProperty('submitting');
                            self.transitionToRoute('posts.index');
                        });
                    });
                } else if (users.length === 0) {
                    this.get('errors').add('users', 'No users to invite');
                }
            },

            skipInvite: function skipInvite() {
                this.send('loadServerNotifications');
                this.transitionToRoute('posts.index');
            }
        }
    });

});
define('ghost/controllers/setup/two', ['exports', 'ember', 'ic-ajax', 'ghost/mixins/validation-engine'], function (exports, Ember, ic_ajax, ValidationEngine) {

    'use strict';

    exports['default'] = Ember['default'].Controller.extend(ValidationEngine['default'], {
        size: 90,
        blogTitle: null,
        name: null,
        email: '',
        validEmail: '',
        password: null,
        image: null,
        blogCreated: false,
        submitting: false,
        flowErrors: '',

        ghostPaths: Ember['default'].inject.service('ghost-paths'),
        notifications: Ember['default'].inject.service(),
        application: Ember['default'].inject.controller(),
        config: Ember['default'].inject.service(),

        // ValidationEngine settings
        validationType: 'setup',

        /**
         * Uploads the given data image, then sends the changed user image property to the server
         * @param  {Object} user User object, returned from the 'setup' api call
         * @return {Ember.RSVP.Promise} A promise that takes care of both calls
         */
        sendImage: function sendImage(user) {
            var self = this,
                image = this.get('image');

            return new Ember['default'].RSVP.Promise(function (resolve, reject) {
                image.formData = {};
                image.submit().success(function (response) {
                    user.image = response;
                    ic_ajax.request({
                        url: self.get('ghostPaths.url').api('users', user.id.toString()),
                        type: 'PUT',
                        data: {
                            users: [user]
                        }
                    }).then(resolve)['catch'](reject);
                }).error(reject);
            });
        },

        actions: {
            preValidate: function preValidate(model) {
                // Only triggers validation if a value has been entered, preventing empty errors on focusOut
                if (this.get(model)) {
                    if (model === 'email') {
                        this.send('handleEmail');
                    }
                    this.validate({ property: model });
                }
            },

            setup: function setup() {
                var self = this,
                    setupProperties = ['blogTitle', 'name', 'email', 'password', 'image'],
                    data = self.getProperties(setupProperties),
                    notifications = this.get('notifications'),
                    config = this.get('config'),
                    method = this.get('blogCreated') ? 'PUT' : 'POST';

                this.toggleProperty('submitting');
                this.set('flowErrors', '');

                this.get('hasValidated').addObjects(setupProperties);
                this.validate().then(function () {
                    ic_ajax.request({
                        url: self.get('ghostPaths.url').api('authentication', 'setup'),
                        type: method,
                        data: {
                            setup: [{
                                name: data.name,
                                email: data.email,
                                password: data.password,
                                blogTitle: data.blogTitle
                            }]
                        }
                    }).then(function (result) {
                        config.set('blogTitle', data.blogTitle);
                        // Don't call the success handler, otherwise we will be redirected to admin
                        self.get('application').set('skipAuthSuccessHandler', true);
                        self.get('session').authenticate('ghost-authenticator:oauth2-password-grant', {
                            identification: self.get('email'),
                            password: self.get('password')
                        }).then(function () {
                            self.set('blogCreated', true);
                            if (data.image) {
                                self.sendImage(result.users[0]).then(function () {
                                    self.toggleProperty('submitting');
                                    self.transitionToRoute('setup.three');
                                })['catch'](function (resp) {
                                    self.toggleProperty('submitting');
                                    notifications.showAPIError(resp);
                                });
                            } else {
                                self.toggleProperty('submitting');
                                self.transitionToRoute('setup.three');
                            }
                        });
                    })['catch'](function (resp) {
                        self.toggleProperty('submitting');
                        if (resp && resp.jqXHR && resp.jqXHR.responseJSON && resp.jqXHR.responseJSON.errors) {
                            self.set('flowErrors', resp.jqXHR.responseJSON.errors[0].message);
                        } else {
                            notifications.showAPIError(resp);
                        }
                    });
                })['catch'](function () {
                    self.toggleProperty('submitting');
                    self.set('flowErrors', 'Please fill out the form to setup your blog.');
                });
            },
            setImage: function setImage(image) {
                this.set('image', image);
            },
            handleEmail: function handleEmail() {
                var self = this;

                this.validate({ property: 'email' }).then(function () {
                    self.set('validEmail', self.get('email'));
                });
            }
        }
    });

});
define('ghost/controllers/signin', ['exports', 'ember', 'ghost/mixins/validation-engine', 'ic-ajax'], function (exports, Ember, ValidationEngine, ic_ajax) {

    'use strict';

    exports['default'] = Ember['default'].Controller.extend(ValidationEngine['default'], {
        submitting: false,
        loggingIn: false,
        authProperties: ['identification', 'password'],

        ghostPaths: Ember['default'].inject.service('ghost-paths'),
        notifications: Ember['default'].inject.service(),
        flowErrors: '',

        // ValidationEngine settings
        validationType: 'signin',

        actions: {
            authenticate: function authenticate() {
                var self = this,
                    model = this.get('model'),
                    authStrategy = 'ghost-authenticator:oauth2-password-grant',
                    data = model.getProperties(this.authProperties);

                // Authentication transitions to posts.index, we can leave spinner running unless there is an error
                this.get('session').authenticate(authStrategy, data)['catch'](function (err) {
                    self.toggleProperty('loggingIn');

                    if (err.errors) {
                        self.set('flowErrors', err.errors[0].message.string);

                        // this catches both 'no user' and 'user inactive' errors
                        // long term, we probably need to introduce error codes from the server
                        if (err.errors[0].message.string.match(/user with that email/)) {
                            self.get('model.errors').add('identification', '');
                        }

                        if (err.errors[0].message.string.match(/password is incorrect/)) {
                            self.get('model.errors').add('password', '');
                        }
                    }
                    // if authentication fails a rejected promise will be returned.
                    // it needs to be caught so it doesn't generate an exception in the console,
                    // but it's actually "handled" by the sessionAuthenticationFailed action handler.
                });
            },

            validateAndAuthenticate: function validateAndAuthenticate() {
                var self = this;
                this.set('flowErrors', '');
                // Manually trigger events for input fields, ensuring legacy compatibility with
                // browsers and password managers that don't send proper events on autofill
                $('#login').find('input').trigger('change');

                // This is a bit dirty, but there's no other way to ensure the properties are set as well as 'signin'
                this.get('hasValidated').addObjects(this.authProperties);
                this.validate({ property: 'signin' }).then(function () {
                    self.toggleProperty('loggingIn');
                    self.send('authenticate');
                })['catch'](function (error) {
                    if (error) {
                        self.get('notifications').showAPIError(error);
                    } else {
                        self.set('flowErrors', 'Please fill out the form to sign in.');
                    }
                });
            },

            forgotten: function forgotten() {
                var email = this.get('model.identification'),
                    notifications = this.get('notifications'),
                    self = this;

                this.set('flowErrors', '');
                // This is a bit dirty, but there's no other way to ensure the properties are set as well as 'forgotPassword'
                this.get('hasValidated').addObject('identification');
                this.validate({ property: 'forgotPassword' }).then(function () {
                    self.toggleProperty('submitting');

                    ic_ajax.request({
                        url: self.get('ghostPaths.url').api('authentication', 'passwordreset'),
                        type: 'POST',
                        data: {
                            passwordreset: [{
                                email: email
                            }]
                        }
                    }).then(function () {
                        self.toggleProperty('submitting');
                        notifications.showAlert('Please check your email for instructions.', { type: 'info' });
                    })['catch'](function (resp) {
                        self.toggleProperty('submitting');
                        if (resp && resp.jqXHR && resp.jqXHR.responseJSON && resp.jqXHR.responseJSON.errors) {
                            var message = resp.jqXHR.responseJSON.errors[0].message;

                            self.set('flowErrors', message);

                            if (message.match(/no user with that email/)) {
                                self.get('model.errors').add('identification', '');
                            }
                        } else {
                            notifications.showAPIError(resp, { defaultErrorText: 'There was a problem with the reset, please try again.' });
                        }
                    });
                })['catch'](function () {
                    self.set('flowErrors', 'Please enter an email address then click "Forgot?".');
                });
            }
        }
    });

});
define('ghost/controllers/signup', ['exports', 'ember', 'ic-ajax', 'ghost/mixins/validation-engine'], function (exports, Ember, ic_ajax, ValidationEngine) {

    'use strict';

    exports['default'] = Ember['default'].Controller.extend(ValidationEngine['default'], {
        // ValidationEngine settings
        validationType: 'signup',

        submitting: false,
        flowErrors: '',
        image: null,
        validEmail: '',

        ghostPaths: Ember['default'].inject.service('ghost-paths'),
        config: Ember['default'].inject.service(),
        notifications: Ember['default'].inject.service(),

        sendImage: function sendImage() {
            var self = this,
                image = this.get('image');

            this.get('session.user').then(function (user) {
                return new Ember['default'].RSVP.Promise(function (resolve, reject) {
                    image.formData = {};
                    image.submit().success(function (response) {
                        user.image = response;
                        ic_ajax.request({
                            url: self.get('ghostPaths.url').api('users', user.id.toString()),
                            type: 'PUT',
                            data: {
                                users: [user]
                            }
                        }).then(resolve)['catch'](reject);
                    }).error(reject);
                });
            });
        },

        actions: {
            signup: function signup() {
                var self = this,
                    model = this.get('model'),
                    setupProperties = ['name', 'email', 'password', 'token'],
                    data = model.getProperties(setupProperties),
                    image = this.get('image'),
                    notifications = this.get('notifications');

                this.set('flowErrors', '');

                this.get('hasValidated').addObjects(setupProperties);
                this.validate().then(function () {
                    self.toggleProperty('submitting');
                    ic_ajax.request({
                        url: self.get('ghostPaths.url').api('authentication', 'invitation'),
                        type: 'POST',
                        dataType: 'json',
                        data: {
                            invitation: [{
                                name: data.name,
                                email: data.email,
                                password: data.password,
                                token: data.token
                            }]
                        }
                    }).then(function () {
                        self.get('session').authenticate('ghost-authenticator:oauth2-password-grant', {
                            identification: self.get('model.email'),
                            password: self.get('model.password')
                        }).then(function () {
                            if (image) {
                                self.sendImage();
                            }
                        })['catch'](function (resp) {
                            notifications.showAPIError(resp);
                        });
                    })['catch'](function (resp) {
                        self.toggleProperty('submitting');
                        if (resp && resp.jqXHR && resp.jqXHR.responseJSON && resp.jqXHR.responseJSON.errors) {
                            self.set('flowErrors', resp.jqXHR.responseJSON.errors[0].message);
                        } else {
                            notifications.showAPIError(resp);
                        }
                    });
                })['catch'](function () {
                    self.set('flowErrors', 'Please fill out the form to complete your sign-up');
                });
            },
            setImage: function setImage(image) {
                this.set('image', image);
            },
            handleEmail: function handleEmail() {
                var self = this;

                this.validate({ property: 'email' }).then(function () {
                    self.set('validEmail', self.get('email'));
                });
            }
        }
    });

});
define('ghost/controllers/team/index', ['exports', 'ember', 'ghost/mixins/pagination-controller'], function (exports, Ember, PaginationControllerMixin) {

    'use strict';

    exports['default'] = Ember['default'].Controller.extend(PaginationControllerMixin['default'], {
        init: function init() {
            // let the PaginationControllerMixin know what type of model we will be paginating
            // this is necessary because we do not have access to the model inside the Controller::init method
            this._super({ modelType: 'user' });
        },

        users: Ember['default'].computed.alias('model'),

        activeUsers: Ember['default'].computed.filter('users', function (user) {
            return (/^active|warn-[1-4]|locked$/.test(user.get('status'))
            );
        }),

        invitedUsers: Ember['default'].computed.filter('users', function (user) {
            var status = user.get('status');

            return status === 'invited' || status === 'invited-pending';
        })
    });

});
define('ghost/controllers/team/user', ['exports', 'ember', 'ghost/models/slug-generator', 'ghost/utils/isNumber', 'ghost/utils/bound-one-way', 'ghost/mixins/validation-engine'], function (exports, Ember, SlugGenerator, isNumber, boundOneWay, ValidationEngine) {

    'use strict';

    exports['default'] = Ember['default'].Controller.extend(ValidationEngine['default'], {
        // ValidationEngine settings
        validationType: 'user',
        submitting: false,

        ghostPaths: Ember['default'].inject.service('ghost-paths'),
        notifications: Ember['default'].inject.service(),

        currentUser: Ember['default'].computed.alias('session.user'),

        isNotOwnProfile: Ember['default'].computed('user.id', 'currentUser.id', function () {
            return this.get('user.id') !== this.get('currentUser.id');
        }),

        isNotOwnersProfile: Ember['default'].computed.not('user.isOwner'),

        isAdminUserOnOwnerProfile: Ember['default'].computed.and('currentUser.isAdmin', 'user.isOwner'),

        canAssignRoles: Ember['default'].computed.or('currentUser.isAdmin', 'currentUser.isOwner'),

        canMakeOwner: Ember['default'].computed.and('currentUser.isOwner', 'isNotOwnProfile', 'user.isAdmin'),

        rolesDropdownIsVisible: Ember['default'].computed.and('isNotOwnProfile', 'canAssignRoles', 'isNotOwnersProfile'),

        deleteUserActionIsVisible: Ember['default'].computed('currentUser', 'canAssignRoles', 'user', function () {
            if (this.get('canAssignRoles') && this.get('isNotOwnProfile') && !this.get('user.isOwner') || this.get('currentUser.isEditor') && (this.get('isNotOwnProfile') || this.get('user.isAuthor'))) {
                return true;
            }
        }),

        userActionsAreVisible: Ember['default'].computed.or('deleteUserActionIsVisible', 'canMakeOwner'),

        user: Ember['default'].computed.alias('model'),

        email: Ember['default'].computed.readOnly('model.email'),

        slugValue: boundOneWay['default']('model.slug'),

        lastPromise: null,

        // duplicated in gh-user-active -- find a better home and consolidate?

        userDefault: Ember['default'].computed('ghostPaths', function () {
            return this.get('ghostPaths.url').asset('/shared/img/user-image.png');
        }),

        userImageBackground: Ember['default'].computed('user.image', 'userDefault', function () {
            var url = this.get('user.image') || this.get('userDefault');

            return ('background-image: url(' + url + ')').htmlSafe();
        }),

        // end duplicated

        coverDefault: Ember['default'].computed('ghostPaths', function () {
            return this.get('ghostPaths.url').asset('/shared/img/user-cover.png');
        }),

        coverImageBackground: Ember['default'].computed('user.cover', 'coverDefault', function () {
            var url = this.get('user.cover') || this.get('coverDefault');

            return ('background-image: url(' + url + ')').htmlSafe();
        }),

        coverTitle: Ember['default'].computed('user.name', function () {
            return this.get('user.name') + '\'s Cover Image';
        }),

        // Lazy load the slug generator for slugPlaceholder
        slugGenerator: Ember['default'].computed(function () {
            return SlugGenerator['default'].create({
                ghostPaths: this.get('ghostPaths'),
                slugType: 'user'
            });
        }),

        roles: Ember['default'].computed(function () {
            return this.store.find('role', { permissions: 'assign' });
        }),

        actions: {
            changeRole: function changeRole(newRole) {
                this.set('model.role', newRole);
            },

            save: function save() {
                var user = this.get('user'),
                    slugValue = this.get('slugValue'),
                    afterUpdateSlug = this.get('lastPromise'),
                    promise,
                    slugChanged,
                    self = this;

                if (user.get('slug') !== slugValue) {
                    slugChanged = true;
                    user.set('slug', slugValue);
                }

                this.toggleProperty('submitting');

                promise = Ember['default'].RSVP.resolve(afterUpdateSlug).then(function () {
                    return user.save({ format: false });
                }).then(function (model) {
                    var currentPath, newPath;

                    // If the user's slug has changed, change the URL and replace
                    // the history so refresh and back button still work
                    if (slugChanged) {
                        currentPath = window.history.state.path;

                        newPath = currentPath.split('/');
                        newPath[newPath.length - 2] = model.get('slug');
                        newPath = newPath.join('/');

                        window.history.replaceState({ path: newPath }, '', newPath);
                    }

                    self.toggleProperty('submitting');

                    return model;
                })['catch'](function (errors) {
                    if (errors) {
                        self.get('notifications').showErrors(errors);
                    }

                    self.toggleProperty('submitting');
                });

                this.set('lastPromise', promise);
            },

            password: function password() {
                var user = this.get('user'),
                    self = this;

                if (user.get('isPasswordValid')) {
                    user.saveNewPassword().then(function (model) {
                        // Clear properties from view
                        user.setProperties({
                            password: '',
                            newPassword: '',
                            ne2Password: ''
                        });

                        self.get('notifications').showAlert('Password updated.', { type: 'success' });

                        return model;
                    })['catch'](function (errors) {
                        self.get('notifications').showAPIError(errors);
                    });
                } else {
                    // TODO: switch to in-line validation
                    self.get('notifications').showErrors(user.get('passwordValidationErrors'));
                }
            },

            updateSlug: function updateSlug(newSlug) {
                var self = this,
                    afterSave = this.get('lastPromise'),
                    promise;

                promise = Ember['default'].RSVP.resolve(afterSave).then(function () {
                    var slug = self.get('model.slug');

                    newSlug = newSlug || slug;

                    newSlug = newSlug.trim();

                    // Ignore unchanged slugs or candidate slugs that are empty
                    if (!newSlug || slug === newSlug) {
                        self.set('slugValue', slug);

                        return;
                    }

                    return self.get('slugGenerator').generateSlug(newSlug).then(function (serverSlug) {
                        // If after getting the sanitized and unique slug back from the API
                        // we end up with a slug that matches the existing slug, abort the change
                        if (serverSlug === slug) {
                            return;
                        }

                        // Because the server transforms the candidate slug by stripping
                        // certain characters and appending a number onto the end of slugs
                        // to enforce uniqueness, there are cases where we can get back a
                        // candidate slug that is a duplicate of the original except for
                        // the trailing incrementor (e.g., this-is-a-slug and this-is-a-slug-2)

                        // get the last token out of the slug candidate and see if it's a number
                        var slugTokens = serverSlug.split('-'),
                            check = Number(slugTokens.pop());

                        // if the candidate slug is the same as the existing slug except
                        // for the incrementor then the existing slug should be used
                        if (isNumber['default'](check) && check > 0) {
                            if (slug === slugTokens.join('-') && serverSlug !== newSlug) {
                                self.set('slugValue', slug);

                                return;
                            }
                        }

                        self.set('slugValue', serverSlug);
                    });
                });

                this.set('lastPromise', promise);
            }
        }
    });

});
define('ghost/helpers/gh-count-characters', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    var countCharacters = Ember['default'].HTMLBars.makeBoundHelper(function (arr /* hashParams */) {
        var el = document.createElement('span'),
            length,
            content;

        if (!arr || !arr.length) {
            return;
        }

        content = arr[0] || '';
        length = content.length;

        el.className = 'word-count';

        if (length > 180) {
            el.style.color = '#E25440';
        } else {
            el.style.color = '#9E9D95';
        }

        el.innerHTML = 200 - length;

        return Ember['default'].String.htmlSafe(el.outerHTML);
    });

    exports['default'] = countCharacters;

});
define('ghost/helpers/gh-count-down-characters', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    var countDownCharacters = Ember['default'].HTMLBars.makeBoundHelper(function (arr /* hashParams */) {
        var el = document.createElement('span'),
            content,
            maxCharacters,
            length;

        if (!arr || arr.length < 2) {
            return;
        }

        content = arr[0] || '';
        maxCharacters = arr[1];
        length = content.length;

        el.className = 'word-count';

        if (length > maxCharacters) {
            el.style.color = '#E25440';
        } else {
            el.style.color = '#9FBB58';
        }

        el.innerHTML = length;

        return Ember['default'].String.htmlSafe(el.outerHTML);
    });

    exports['default'] = countDownCharacters;

});
define('ghost/helpers/gh-count-words', ['exports', 'ember', 'ghost/utils/word-count'], function (exports, Ember, counter) {

    'use strict';

    var countWords = Ember['default'].HTMLBars.makeBoundHelper(function (arr /* hashParams */) {
        if (!arr || !arr.length) {
            return;
        }

        var markdown, count;

        markdown = arr[0] || '';

        if (/^\s*$/.test(markdown)) {
            return '0 words';
        }

        count = counter['default'](markdown);

        return count + (count === 1 ? ' word' : ' words');
    });

    exports['default'] = countWords;

});
define('ghost/helpers/gh-format-html', ['exports', 'ember', 'ghost/utils/caja-sanitizers'], function (exports, Ember, cajaSanitizers) {

    'use strict';

    var formatHTML = Ember['default'].HTMLBars.makeBoundHelper(function (arr /* hashParams */) {
        if (!arr || !arr.length) {
            return;
        }

        var escapedhtml = arr[0] || '';

        // replace script and iFrame
        escapedhtml = escapedhtml.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '<pre class="js-embed-placeholder">Embedded JavaScript</pre>');
        escapedhtml = escapedhtml.replace(/<iframe\b[^<]*(?:(?!<\/iframe>)<[^<]*)*<\/iframe>/gi, '<pre class="iframe-embed-placeholder">Embedded iFrame</pre>');

        // sanitize HTML
        // jscs:disable requireCamelCaseOrUpperCaseIdentifiers
        escapedhtml = html_sanitize(escapedhtml, cajaSanitizers['default'].url, cajaSanitizers['default'].id);
        // jscs:enable requireCamelCaseOrUpperCaseIdentifiers

        return Ember['default'].String.htmlSafe(escapedhtml);
    });

    exports['default'] = formatHTML;

});
define('ghost/helpers/gh-format-markdown', ['exports', 'ember', 'ghost/utils/caja-sanitizers'], function (exports, Ember, cajaSanitizers) {

    'use strict';

    var showdown, formatMarkdown;

    showdown = new Showdown.converter({ extensions: ['ghostimagepreview', 'ghostgfm', 'footnotes', 'highlight'] });

    formatMarkdown = Ember['default'].HTMLBars.makeBoundHelper(function (arr /* hashParams */) {
        if (!arr || !arr.length) {
            return;
        }

        var escapedhtml = '',
            markdown = arr[0] || '';

        // convert markdown to HTML
        escapedhtml = showdown.makeHtml(markdown);

        // replace script and iFrame
        escapedhtml = escapedhtml.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '<pre class="js-embed-placeholder">Embedded JavaScript</pre>');
        escapedhtml = escapedhtml.replace(/<iframe\b[^<]*(?:(?!<\/iframe>)<[^<]*)*<\/iframe>/gi, '<pre class="iframe-embed-placeholder">Embedded iFrame</pre>');

        // sanitize html
        // jscs:disable requireCamelCaseOrUpperCaseIdentifiers
        escapedhtml = html_sanitize(escapedhtml, cajaSanitizers['default'].url, cajaSanitizers['default'].id);
        // jscs:enable requireCamelCaseOrUpperCaseIdentifiers

        return Ember['default'].String.htmlSafe(escapedhtml);
    });

    exports['default'] = formatMarkdown;

});
define('ghost/helpers/gh-format-timeago', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    var formatTimeago = Ember['default'].HTMLBars.makeBoundHelper(function (arr /* hashParams */) {
        if (!arr || !arr.length) {
            return;
        }

        var timeago = arr[0];

        return moment(timeago).fromNow();
        // stefanpenner says cool for small number of timeagos.
        // For large numbers moment sucks => single Ember.Object based clock better
        // https://github.com/manuelmitasch/ghost-admin-ember-demo/commit/fba3ab0a59238290c85d4fa0d7c6ed1be2a8a82e#commitcomment-5396524
    });

    exports['default'] = formatTimeago;

});
define('ghost/helpers/gh-path', ['exports', 'ember', 'ghost/utils/ghost-paths'], function (exports, Ember, ghostPaths) {

    'use strict';

    var _slicedToArray = (function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i['return']) _i['return'](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError('Invalid attempt to destructure non-iterable instance'); } }; })();

    function ghostPathsHelper(params /*, hash */) {
        var base;
        var paths = ghostPaths['default']();

        var _params = _slicedToArray(params, 2);

        var path = _params[0];
        var url = _params[1];

        if (!path) {
            path = 'blog';
        }

        if (!/^(blog|admin|api)$/.test(path)) {
            url = path;
            path = 'blog';
        }

        switch (path.toString()) {
            case 'blog':
                base = paths.blogRoot;
                break;
            case 'admin':
                base = paths.adminRoot;
                break;
            case 'api':
                base = paths.apiRoot;
                break;
            default:
                base = paths.blogRoot;
                break;
        }

        // handle leading and trailing slashes

        base = base[base.length - 1] !== '/' ? base + '/' : base;

        if (url && url.length > 0) {
            if (url[0] === '/') {
                url = url.substr(1);
            }

            base = base + url;
        }

        return Ember['default'].String.htmlSafe(base);
    }

    exports['default'] = Ember['default'].HTMLBars.makeBoundHelper(ghostPathsHelper);

});
define('ghost/helpers/gh-user-can-admin', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    exports.ghUserCanAdmin = ghUserCanAdmin;

    function ghUserCanAdmin(params) {
        return !!(params[0].get('isOwner') || params[0].get('isAdmin'));
    }

    exports['default'] = Ember['default'].HTMLBars.makeBoundHelper(ghUserCanAdmin);

});
define('ghost/helpers/is-equal', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    exports.isEqual = isEqual;

    var _slicedToArray = (function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i['return']) _i['return'](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError('Invalid attempt to destructure non-iterable instance'); } }; })();

    function isEqual(params /*, hash*/) {
        var _params = _slicedToArray(params, 2);

        var lhs = _params[0];
        var rhs = _params[1];

        return lhs === rhs;
    }

    exports['default'] = Ember['default'].HTMLBars.makeBoundHelper(isEqual);

});
define('ghost/helpers/is-not', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    exports.isNot = isNot;

    function isNot(params /*, hash*/) {
        return !params;
    }

    exports['default'] = Ember['default'].HTMLBars.makeBoundHelper(isNot);

});
define('ghost/helpers/read-path', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    exports.readPath = readPath;

    var _slicedToArray = (function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i['return']) _i['return'](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError('Invalid attempt to destructure non-iterable instance'); } }; })();

    function readPath(params /*, hash*/) {
        var _params = _slicedToArray(params, 2);

        var obj = _params[0];
        var path = _params[1];

        return Ember['default'].get(obj, path);
    }

    exports['default'] = Ember['default'].HTMLBars.makeBoundHelper(readPath);

});
define('ghost/initializers/app-version', ['exports', 'ghost/config/environment', 'ember'], function (exports, config, Ember) {

  'use strict';

  var classify = Ember['default'].String.classify;
  var registered = false;

  exports['default'] = {
    name: 'App Version',
    initialize: function initialize(container, application) {
      if (!registered) {
        var appName = classify(application.toString());
        Ember['default'].libraries.register(appName, config['default'].APP.version);
        registered = true;
      }
    }
  };

});
define('ghost/initializers/ember-cli-fastclick', ['exports', 'ember'], function (exports, Ember) {

  'use strict';

  var EmberCliFastclickInitializer = {
    name: 'fastclick',

    initialize: function initialize() {
      Ember['default'].run.schedule('afterRender', function () {
        FastClick.attach(document.body);
      });
    }
  };

  exports['default'] = EmberCliFastclickInitializer;

});
define('ghost/initializers/export-application-global', ['exports', 'ember', 'ghost/config/environment'], function (exports, Ember, config) {

  'use strict';

  exports.initialize = initialize;

  function initialize() {
    var application = arguments[1] || arguments[0];
    if (config['default'].exportApplicationGlobal !== false) {
      var value = config['default'].exportApplicationGlobal;
      var globalName;

      if (typeof value === 'string') {
        globalName = value;
      } else {
        globalName = Ember['default'].String.classify(config['default'].modulePrefix);
      }

      if (!window[globalName]) {
        window[globalName] = application;

        application.reopen({
          willDestroy: function willDestroy() {
            this._super.apply(this, arguments);
            delete window[globalName];
          }
        });
      }
    }
  }

  ;

  exports['default'] = {
    name: 'export-application-global',

    initialize: initialize
  };

});
define('ghost/initializers/ghost-authenticator', ['exports', 'ghost/authenticators/oauth2'], function (exports, GhostOauth2Authenticator) {

    'use strict';

    exports['default'] = {
        name: 'ghost-authentictor',

        initialize: function initialize(container) {
            container.register('ghost-authenticator:oauth2-password-grant', GhostOauth2Authenticator['default']);
        }
    };

});
define('ghost/initializers/resize', ['exports', 'ember-resize/services/resize', 'ghost/config/environment'], function (exports, ResizeService, config) {

  'use strict';

  exports.initialize = initialize;

  function initialize() {
    var application = arguments[1] || arguments[0];

    var resizeServiceDefaults = config['default'].resizeServiceDefaults;
    var injectionFactories = resizeServiceDefaults.injectionFactories;

    application.register('config:resize-service', resizeServiceDefaults, { instantiate: false });
    application.register('service:resize', ResizeService['default']);
    application.inject('service:resize', 'resizeServiceDefaults', 'config:resize-service');

    injectionFactories.forEach(function (factory) {
      application.inject(factory, 'resizeService', 'service:resize');
    });
  }

  exports['default'] = {
    name: 'resize',
    initialize: initialize
  };

});
define('ghost/initializers/simple-auth-env', ['exports', 'ghost/config/environment', 'ghost/utils/ghost-paths'], function (exports, ENV, ghostPaths) {

    'use strict';

    var Ghost = ghostPaths['default']();

    exports['default'] = {
        name: 'simple-auth-env',
        before: 'simple-auth-oauth2',

        initialize: function initialize() {
            ENV['default']['simple-auth-oauth2'].serverTokenEndpoint = Ghost.apiRoot + '/authentication/token';
            ENV['default']['simple-auth-oauth2'].serverTokenRevocationEndpoint = Ghost.apiRoot + '/authentication/revoke';

            ENV['default']['simple-auth'].localStorageKey = 'ghost' + (Ghost.subdir.indexOf('/') === 0 ? '-' + Ghost.subdir.substr(1) : '') + ':session';
        }
    };

});
define('ghost/initializers/simple-auth-oauth2', ['exports', 'simple-auth-oauth2/configuration', 'simple-auth-oauth2/authenticators/oauth2', 'simple-auth-oauth2/authorizers/oauth2', 'ghost/config/environment'], function (exports, Configuration, Authenticator, Authorizer, ENV) {

  'use strict';

  exports['default'] = {
    name: 'simple-auth-oauth2',
    before: 'simple-auth',
    initialize: function initialize(container, application) {
      Configuration['default'].load(container, ENV['default']['simple-auth-oauth2'] || {});
      container.register('simple-auth-authorizer:oauth2-bearer', Authorizer['default']);
      container.register('simple-auth-authenticator:oauth2-password-grant', Authenticator['default']);
    }
  };

});
define('ghost/initializers/simple-auth', ['exports', 'simple-auth/configuration', 'simple-auth/setup', 'ghost/config/environment'], function (exports, Configuration, setup, ENV) {

  'use strict';

  exports['default'] = {
    name: 'simple-auth',
    initialize: function initialize(container, application) {
      Configuration['default'].load(container, ENV['default']['simple-auth'] || {});
      setup['default'](container, application);
    }
  };

});
define('ghost/initializers/trailing-history', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    var trailingHistory, registerTrailingLocationHistory;

    trailingHistory = Ember['default'].HistoryLocation.extend({
        formatURL: function formatURL() {
            // jscs: disable
            return this._super.apply(this, arguments).replace(/\/?$/, '/');
            // jscs: enable
        }
    });

    registerTrailingLocationHistory = {
        name: 'registerTrailingLocationHistory',

        initialize: function initialize(container, application) {
            application.register('location:trailing-history', trailingHistory);
        }
    };

    exports['default'] = registerTrailingLocationHistory;

});
define('ghost/instance-initializers/authentication', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    var AuthenticationInitializer = {
        name: 'authentication',

        initialize: function initialize(instance) {
            var store = instance.container.lookup('store:main'),
                Session = instance.container.lookup('simple-auth-session:main');

            Session.reopen({
                user: Ember['default'].computed(function () {
                    return store.find('user', 'me');
                })
            });
        }
    };

    exports['default'] = AuthenticationInitializer;

});
define('ghost/mixins/body-event-listener', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    var BodyEventListener = Ember['default'].Mixin.create({
        bodyElementSelector: 'html',
        bodyClick: Ember['default'].K,

        init: function init() {
            this._super();

            return Ember['default'].run.next(this, this._setupDocumentHandlers);
        },

        willDestroy: function willDestroy() {
            this._super();

            return this._removeDocumentHandlers();
        },

        _setupDocumentHandlers: function _setupDocumentHandlers() {
            if (this._clickHandler) {
                return;
            }

            var self = this;

            this._clickHandler = function () {
                return self.bodyClick();
            };

            return $(this.get('bodyElementSelector')).on('click', this._clickHandler);
        },

        _removeDocumentHandlers: function _removeDocumentHandlers() {
            $(this.get('bodyElementSelector')).off('click', this._clickHandler);
            this._clickHandler = null;
        },

        // http://stackoverflow.com/questions/152975/how-to-detect-a-click-outside-an-element
        click: function click(event) {
            return event.stopPropagation();
        }
    });

    exports['default'] = BodyEventListener;

});
define('ghost/mixins/current-user-settings', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    var CurrentUserSettings = Ember['default'].Mixin.create({
        transitionAuthor: function transitionAuthor() {
            var self = this;

            return function (user) {
                if (user.get('isAuthor')) {
                    return self.transitionTo('team.user', user);
                }

                return user;
            };
        },

        transitionEditor: function transitionEditor() {
            var self = this;

            return function (user) {
                if (user.get('isEditor')) {
                    return self.transitionTo('team');
                }

                return user;
            };
        }
    });

    exports['default'] = CurrentUserSettings;

});
define('ghost/mixins/dropdown-mixin', ['exports', 'ember'], function (exports, Ember) {

  'use strict';

  var DropdownMixin = Ember['default'].Mixin.create(Ember['default'].Evented, {
      classNameBindings: ['isOpen:open:closed'],
      isOpen: false,

      click: function click(event) {
          this._super(event);

          return event.stopPropagation();
      }
  });

  exports['default'] = DropdownMixin;

});
define('ghost/mixins/ed-editor-api', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    var EditorAPI = Ember['default'].Mixin.create({
        /**
         * Get Value
         *
         * Get the full contents of the textarea
         *
         * @returns {String}
         */
        getValue: function getValue() {
            return this.$().val();
        },

        /**
         * Get Selection
         *
         * Return the currently selected text from the textarea
         *
         * @returns {Selection}
         */
        getSelection: function getSelection() {
            return this.$().getSelection();
        },

        /**
         * Get Line To Cursor
         *
         * Fetch the string of characters from the start of the given line up to the cursor
         * @returns {{text: string, start: number}}
         */
        getLineToCursor: function getLineToCursor() {
            var selection = this.$().getSelection(),
                value = this.getValue(),
                lineStart;

            // Normalise newlines
            value = value.replace('\r\n', '\n');

            // We want to look at the characters behind the cursor
            lineStart = value.lastIndexOf('\n', selection.start - 1) + 1;

            return {
                text: value.substring(lineStart, selection.start),
                start: lineStart
            };
        },

        /**
         * Get Line
         *
         * Return the string of characters for the line the cursor is currently on
         *
         * @returns {{text: string, start: number, end: number}}
         */
        getLine: function getLine() {
            var selection = this.$().getSelection(),
                value = this.getValue(),
                lineStart,
                lineEnd;

            // Normalise newlines
            value = value.replace('\r\n', '\n');

            // We want to look at the characters behind the cursor
            lineStart = value.lastIndexOf('\n', selection.start - 1) + 1;
            lineEnd = value.indexOf('\n', selection.start);
            lineEnd = lineEnd === -1 ? value.length - 1 : lineEnd;

            return {
                // jscs:disable
                text: value.substring(lineStart, lineEnd).replace(/^\n/, ''),
                // jscs:enable
                start: lineStart,
                end: lineEnd
            };
        },

        /**
         * Set Selection
         *
         * Set the section of text in the textarea that should be selected by the cursor
         *
         * @param {number} start
         * @param {number} end
         */
        setSelection: function setSelection(start, end) {
            var $textarea = this.$();

            if (start === 'end') {
                start = $textarea.val().length;
            }

            end = end || start;

            $textarea.setSelection(start, end);
        },

        /**
         * Replace Selection
         *
         * @param {String} replacement - the string to replace with
         * @param {number} replacementStart - where to start replacing
         * @param {number} [replacementEnd] - when to stop replacing, defaults to replacementStart
         * @param {String|boolean|Object} [cursorPosition]  - where to put the cursor after replacing
         *
         * Cursor position after replacement defaults to the end of the replacement.
         * Providing selectionStart only will cause the cursor to be placed there, or alternatively a range can be selected
         * by providing selectionEnd.
         */
        replaceSelection: function replaceSelection(replacement, replacementStart, replacementEnd, cursorPosition) {
            var $textarea = this.$();

            cursorPosition = cursorPosition || 'collapseToEnd';
            replacementEnd = replacementEnd || replacementStart;

            $textarea.setSelection(replacementStart, replacementEnd);

            if (['select', 'collapseToStart', 'collapseToEnd'].indexOf(cursorPosition) !== -1) {
                $textarea.replaceSelectedText(replacement, cursorPosition);
            } else {
                $textarea.replaceSelectedText(replacement);
                if (cursorPosition.hasOwnProperty('start')) {
                    $textarea.setSelection(cursorPosition.start, cursorPosition.end);
                } else {
                    $textarea.setSelection(cursorPosition, cursorPosition);
                }
            }

            $textarea.focus();
            // Tell the editor it has changed, as programmatic replacements won't trigger this automatically
            this.sendAction('onChange');
        }
    });

    exports['default'] = EditorAPI;

});
define('ghost/mixins/ed-editor-scroll', ['exports', 'ember', 'ghost/utils/set-scroll-classname'], function (exports, Ember, setScrollClassName) {

    'use strict';

    var EditorScroll = Ember['default'].Mixin.create({
        /**
         * Determine if the cursor is at the end of the textarea
         */
        isCursorAtEnd: function isCursorAtEnd() {
            var selection = this.$().getSelection(),
                value = this.getValue(),
                linesAtEnd = 3,
                stringAfterCursor,
                match;

            stringAfterCursor = value.substring(selection.end);
            /* jscs: disable */
            match = stringAfterCursor.match(/\n/g);
            /* jscs: enable */

            if (!match || match.length < linesAtEnd) {
                return true;
            }

            return false;
        },

        /**
         * Build an object that represents the scroll state
         */
        getScrollInfo: function getScrollInfo() {
            var scroller = this.get('element'),
                scrollInfo = {
                top: scroller.scrollTop,
                height: scroller.scrollHeight,
                clientHeight: scroller.clientHeight,
                diff: scroller.scrollHeight - scroller.clientHeight,
                padding: 50,
                isCursorAtEnd: this.isCursorAtEnd()
            };

            return scrollInfo;
        },

        /**
         * Calculate if we're within scrollInfo.padding of the end of the document, and scroll the rest of the way
         */
        adjustScrollPosition: function adjustScrollPosition() {
            // If we're receiving change events from the end of the document, i.e the user is typing-at-the-end, update the
            // scroll position to ensure both panels stay in view and in sync
            var scrollInfo = this.getScrollInfo();
            if (scrollInfo.isCursorAtEnd && scrollInfo.diff >= scrollInfo.top && scrollInfo.diff < scrollInfo.top + scrollInfo.padding) {
                scrollInfo.top += scrollInfo.padding;
                // Scroll the left pane
                this.$().scrollTop(scrollInfo.top);
            }
        },

        /**
         * Send the scrollInfo for scrollEvents to the view so that the preview pane can be synced
         */
        scrollHandler: function scrollHandler() {
            this.set('scrollThrottle', Ember['default'].run.throttle(this, function () {
                this.sendAction('updateScrollInfo', this.getScrollInfo());
            }, 10));
        },

        /**
         * once the element is in the DOM bind to the events which control scroll behaviour
         */
        attachScrollHandlers: function attachScrollHandlers() {
            var $el = this.$();

            $el.on('keypress', Ember['default'].run.bind(this, this.adjustScrollPosition));

            $el.on('scroll', Ember['default'].run.bind(this, this.scrollHandler));
            $el.on('scroll', Ember['default'].run.bind($el, setScrollClassName['default'], {
                target: Ember['default'].$('.js-entry-markdown'),
                offset: 10
            }));
        },

        /**
         * once the element has been removed from the DOM unbind from the events which control scroll behaviour
         */
        detachScrollHandlers: function detachScrollHandlers() {
            this.$().off('keypress');
            this.$().off('scroll');
            Ember['default'].run.cancel(this.get('scrollThrottle'));
        },

        didInsertElement: function didInsertElement() {
            this._super();

            this.attachScrollHandlers();
        },

        willDestroyElement: function willDestroyElement() {
            this._super();

            this.detachScrollHandlers();
        }
    });

    exports['default'] = EditorScroll;

});
define('ghost/mixins/ed-editor-shortcuts', ['exports', 'ember', 'ghost/utils/titleize'], function (exports, Ember, titleize) {

    'use strict';

    /* global moment, Showdown */
    var simpleShortcutSyntax, shortcuts, EditorShortcuts;

    // Used for simple, noncomputational replace-and-go! shortcuts.
    // See default case in shortcut function below.
    simpleShortcutSyntax = {
        bold: {
            regex: '**|**',
            cursor: '|'
        },
        italic: {
            regex: '*|*',
            cursor: '|'

        },
        strike: {
            regex: '~~|~~',
            cursor: '|'
        },
        code: {
            regex: '`|`',
            cursor: '|'
        },
        blockquote: {
            regex: '> |',
            cursor: '|',
            newline: true
        },
        list: {
            regex: '* |',
            cursor: '|',
            newline: true
        },
        link: {
            regex: '[|](http://)',
            cursor: 'http://'
        },
        image: {
            regex: '![|](http://)',
            cursor: 'http://',
            newline: true
        }
    };

    shortcuts = {
        simple: function simple(type, replacement, selection, line) {
            var shortcut,
                startIndex = 0;

            if (simpleShortcutSyntax.hasOwnProperty(type)) {
                shortcut = simpleShortcutSyntax[type];
                // insert the markdown
                replacement.text = shortcut.regex.replace('|', selection.text);

                // add a newline if needed
                if (shortcut.newline && line.text !== '') {
                    startIndex = 1;
                    replacement.text = '\n' + replacement.text;
                }

                // handle cursor position
                if (selection.text === '' && shortcut.cursor === '|') {
                    // the cursor should go where | was
                    replacement.position = startIndex + replacement.start + shortcut.regex.indexOf(shortcut.cursor);
                } else if (shortcut.cursor !== '|') {
                    // the cursor should select the string which matches shortcut.cursor
                    replacement.position = {
                        start: replacement.start + replacement.text.indexOf(shortcut.cursor)
                    };
                    replacement.position.end = replacement.position.start + shortcut.cursor.length;
                }
            }

            return replacement;
        },
        cycleHeaderLevel: function cycleHeaderLevel(replacement, line) {
            // jscs:disable
            var match = line.text.match(/^#+/),

            // jscs:enable
            currentHeaderLevel,
                hashPrefix;

            if (!match) {
                currentHeaderLevel = 1;
            } else {
                currentHeaderLevel = match[0].length;
            }

            if (currentHeaderLevel > 2) {
                currentHeaderLevel = 1;
            }

            hashPrefix = new Array(currentHeaderLevel + 2).join('#');

            // jscs:disable
            replacement.text = hashPrefix + ' ' + line.text.replace(/^#* /, '');
            // jscs:enable

            replacement.start = line.start;
            replacement.end = line.end;

            return replacement;
        },
        copyHTML: function copyHTML(editor, selection) {
            var converter = new Showdown.converter(),
                generatedHTML;

            if (selection.text) {
                generatedHTML = converter.makeHtml(selection.text);
            } else {
                generatedHTML = converter.makeHtml(editor.getValue());
            }

            // Talk to the editor
            editor.sendAction('openModal', 'copy-html', { generatedHTML: generatedHTML });
        },
        currentDate: function currentDate(replacement) {
            replacement.text = moment(new Date()).format('D MMMM YYYY');
            return replacement;
        },
        uppercase: function uppercase(replacement, selection) {
            replacement.text = selection.text.toLocaleUpperCase();
            return replacement;
        },
        lowercase: function lowercase(replacement, selection) {
            replacement.text = selection.text.toLocaleLowerCase();
            return replacement;
        },
        titlecase: function titlecase(replacement, selection) {
            replacement.text = titleize['default'](selection.text);
            return replacement;
        }
    };

    EditorShortcuts = Ember['default'].Mixin.create({
        shortcut: function shortcut(type) {
            var selection = this.getSelection(),
                replacement = {
                start: selection.start,
                end: selection.end,
                position: 'collapseToEnd'
            };

            switch (type) {
                // This shortcut is special as it needs to send an action
                case 'copyHTML':
                    shortcuts.copyHTML(this, selection);
                    break;
                case 'cycleHeaderLevel':
                    replacement = shortcuts.cycleHeaderLevel(replacement, this.getLine());
                    break;
                // These shortcuts all process the basic information
                case 'currentDate':
                case 'uppercase':
                case 'lowercase':
                case 'titlecase':
                    replacement = shortcuts[type](replacement, selection, this.getLineToCursor());
                    break;
                // All the of basic formatting shortcuts work with a regex
                default:
                    replacement = shortcuts.simple(type, replacement, selection, this.getLineToCursor());
            }

            if (replacement.text) {
                this.replaceSelection(replacement.text, replacement.start, replacement.end, replacement.position);
            }
        }
    });

    exports['default'] = EditorShortcuts;

});
define('ghost/mixins/editor-base-controller', ['exports', 'ember', 'ghost/models/post', 'ghost/utils/bound-one-way', 'ghost/utils/ed-image-manager'], function (exports, Ember, PostModel, boundOneWay, imageManager) {

    'use strict';

    var watchedProps = ['model.scratch', 'model.titleScratch', 'model.isDirty', 'model.tags.[]'];

    PostModel['default'].eachAttribute(function (name) {
        watchedProps.push('model.' + name);
    });

    exports['default'] = Ember['default'].Mixin.create({
        postSettingsMenuController: Ember['default'].inject.controller('post-settings-menu'),

        autoSaveId: null,
        timedSaveId: null,
        editor: null,
        submitting: false,

        notifications: Ember['default'].inject.service(),

        init: function init() {
            var self = this;

            this._super();

            window.onbeforeunload = function () {
                return self.get('isDirty') ? self.unloadDirtyMessage() : null;
            };
        },

        shouldFocusTitle: Ember['default'].computed.alias('model.isNew'),
        shouldFocusEditor: false,

        autoSave: Ember['default'].observer('model.scratch', function () {
            // Don't save just because we swapped out models
            if (this.get('model.isDraft') && !this.get('model.isNew')) {
                var autoSaveId, timedSaveId, saveOptions;

                saveOptions = {
                    silent: true,
                    backgroundSave: true
                };

                timedSaveId = Ember['default'].run.throttle(this, 'send', 'save', saveOptions, 60000, false);
                this.set('timedSaveId', timedSaveId);

                autoSaveId = Ember['default'].run.debounce(this, 'send', 'save', saveOptions, 3000);
                this.set('autoSaveId', autoSaveId);
            }
        }),

        /**
         * By default, a post will not change its publish state.
         * Only with a user-set value (via setSaveType action)
         * can the post's status change.
         */
        willPublish: boundOneWay['default']('model.isPublished'),

        // set by the editor route and `isDirty`. useful when checking
        // whether the number of tags has changed for `isDirty`.
        previousTagNames: null,

        tagNames: Ember['default'].computed('model.tags.@each.name', function () {
            return this.get('model.tags').mapBy('name');
        }),

        postOrPage: Ember['default'].computed('model.page', function () {
            return this.get('model.page') ? 'Page' : 'Post';
        }),

        // compares previousTagNames to tagNames
        tagNamesEqual: function tagNamesEqual() {
            var tagNames = this.get('tagNames'),
                previousTagNames = this.get('previousTagNames'),
                hashCurrent,
                hashPrevious;

            // beware! even if they have the same length,
            // that doesn't mean they're the same.
            if (tagNames.length !== previousTagNames.length) {
                return false;
            }

            // instead of comparing with slow, nested for loops,
            // perform join on each array and compare the strings
            hashCurrent = tagNames.join('');
            hashPrevious = previousTagNames.join('');

            return hashCurrent === hashPrevious;
        },

        // a hook created in editor-base-route's setupController
        modelSaved: function modelSaved() {
            var model = this.get('model');

            // safer to updateTags on save in one place
            // rather than in all other places save is called
            model.updateTags();

            // set previousTagNames to current tagNames for isDirty check
            this.set('previousTagNames', this.get('tagNames'));

            // `updateTags` triggers `isDirty => true`.
            // for a saved model it would otherwise be false.

            // if the two "scratch" properties (title and content) match the model, then
            // it's ok to set isDirty to false
            if (model.get('titleScratch') === model.get('title') && model.get('scratch') === model.get('markdown')) {
                this.set('isDirty', false);
            }
        },

        // an ugly hack, but necessary to watch all the model's properties
        // and more, without having to be explicit and do it manually
        isDirty: Ember['default'].computed.apply(Ember['default'], watchedProps.concat({
            get: function get() {
                var model = this.get('model'),
                    markdown = model.get('markdown'),
                    title = model.get('title'),
                    titleScratch = model.get('titleScratch'),
                    scratch = this.get('editor').getValue(),
                    changedAttributes;

                if (!this.tagNamesEqual()) {
                    return true;
                }

                if (titleScratch !== title) {
                    return true;
                }

                // since `scratch` is not model property, we need to check
                // it explicitly against the model's markdown attribute
                if (markdown !== scratch) {
                    return true;
                }

                // if the Adapter failed to save the model isError will be true
                // and we should consider the model still dirty.
                if (model.get('isError')) {
                    return true;
                }

                // models created on the client always return `isDirty: true`,
                // so we need to see which properties have actually changed.
                if (model.get('isNew')) {
                    changedAttributes = Ember['default'].keys(model.changedAttributes());

                    if (changedAttributes.length) {
                        return true;
                    }

                    return false;
                }

                // even though we use the `scratch` prop to show edits,
                // which does *not* change the model's `isDirty` property,
                // `isDirty` will tell us if the other props have changed,
                // as long as the model is not new (model.isNew === false).
                return model.get('isDirty');
            },
            set: function set(key, value) {
                return value;
            }
        })),

        // used on window.onbeforeunload
        unloadDirtyMessage: function unloadDirtyMessage() {
            return '==============================\n\n' + 'Hey there! It looks like you\'re in the middle of writing' + ' something and you haven\'t saved all of your content.' + '\n\nSave before you go!\n\n' + '==============================';
        },

        // TODO: This has to be moved to the I18n localization file.
        // This structure is supposed to be close to the i18n-localization which will be used soon.
        messageMap: {
            errors: {
                post: {
                    published: {
                        published: 'Update failed.',
                        draft: 'Saving failed.'
                    },
                    draft: {
                        published: 'Publish failed.',
                        draft: 'Saving failed.'
                    }

                }
            },

            success: {
                post: {
                    published: {
                        published: 'Updated.',
                        draft: 'Saved.'
                    },
                    draft: {
                        published: 'Published!',
                        draft: 'Saved.'
                    }
                }
            }
        },

        // TODO: Update for new notification click-action API
        showSaveNotification: function showSaveNotification(prevStatus, status, delay) {
            var message = this.messageMap.success.post[prevStatus][status],
                path = this.get('model.absoluteUrl'),
                type = this.get('postOrPage'),
                notifications = this.get('notifications');

            if (status === 'published') {
                message += '&nbsp;<a href="' + path + '">View ' + type + '</a>';
            }

            notifications.showNotification(message.htmlSafe(), { delayed: delay });
        },

        showErrorAlert: function showErrorAlert(prevStatus, status, errors, delay) {
            var message = this.messageMap.errors.post[prevStatus][status],
                notifications = this.get('notifications'),
                error;

            function isString(str) {
                /*global toString*/
                return toString.call(str) === '[object String]';
            }

            if (errors && isString(errors)) {
                error = errors;
            } else if (errors && errors[0] && isString(errors[0])) {
                error = errors[0];
            } else if (errors && errors[0] && errors[0].message && isString(errors[0].message)) {
                error = errors[0].message;
            } else {
                error = 'Unknown Error';
            }

            message += '<br />' + error;

            notifications.showAlert(message.htmlSafe(), { type: 'error', delayed: delay });
        },

        actions: {
            save: function save(options) {
                var status,
                    prevStatus = this.get('model.status'),
                    isNew = this.get('model.isNew'),
                    autoSaveId = this.get('autoSaveId'),
                    timedSaveId = this.get('timedSaveId'),
                    self = this,
                    psmController = this.get('postSettingsMenuController'),
                    promise;

                options = options || {};

                // when navigating quickly between pages autoSave will occasionally
                // try to run after the editor has been torn down so bail out here
                // before we throw errors
                if (!this.get('editor').$()) {
                    return 0;
                }

                this.toggleProperty('submitting');

                if (options.backgroundSave) {
                    // do not allow a post's status to be set to published by a background save
                    status = 'draft';
                } else {
                    status = this.get('willPublish') ? 'published' : 'draft';
                }

                if (autoSaveId) {
                    Ember['default'].run.cancel(autoSaveId);
                    this.set('autoSaveId', null);
                }

                if (timedSaveId) {
                    Ember['default'].run.cancel(timedSaveId);
                    this.set('timedSaveId', null);
                }

                // Set the properties that are indirected
                // set markdown equal to what's in the editor, minus the image markers.
                this.set('model.markdown', this.get('editor').getValue());
                this.set('model.status', status);

                // Set a default title
                if (!this.get('model.titleScratch').trim()) {
                    this.set('model.titleScratch', '(Untitled)');
                }

                this.set('model.title', this.get('model.titleScratch'));
                this.set('model.meta_title', psmController.get('metaTitleScratch'));
                this.set('model.meta_description', psmController.get('metaDescriptionScratch'));

                if (!this.get('model.slug')) {
                    // Cancel any pending slug generation that may still be queued in the
                    // run loop because we need to run it before the post is saved.
                    Ember['default'].run.cancel(psmController.get('debounceId'));

                    psmController.generateAndSetSlug('model.slug');
                }

                promise = Ember['default'].RSVP.resolve(psmController.get('lastPromise')).then(function () {
                    return self.get('model').save(options).then(function (model) {
                        if (!options.silent) {
                            self.showSaveNotification(prevStatus, model.get('status'), isNew ? true : false);
                        }

                        self.toggleProperty('submitting');
                        return model;
                    });
                })['catch'](function (errors) {
                    if (!options.silent) {
                        errors = errors || self.get('model.errors.messages');
                        self.showErrorAlert(prevStatus, self.get('model.status'), errors);
                    }

                    self.set('model.status', prevStatus);

                    self.toggleProperty('submitting');
                    return self.get('model');
                });

                psmController.set('lastPromise', promise);

                return promise;
            },

            setSaveType: function setSaveType(newType) {
                if (newType === 'publish') {
                    this.set('willPublish', true);
                } else if (newType === 'draft') {
                    this.set('willPublish', false);
                }
            },

            // set from a `sendAction` on the gh-ed-editor component,
            // so that we get a reference for handling uploads.
            setEditor: function setEditor(editor) {
                this.set('editor', editor);
            },

            // fired from the gh-ed-preview component when an image upload starts
            disableEditor: function disableEditor() {
                this.get('editor').disable();
            },

            // fired from the gh-ed-preview component when an image upload finishes
            enableEditor: function enableEditor() {
                this.get('editor').enable();
            },

            // Match the uploaded file to a line in the editor, and update that line with a path reference
            // ensuring that everything ends up in the correct place and format.
            handleImgUpload: function handleImgUpload(e, resultSrc) {
                var editor = this.get('editor'),
                    editorValue = editor.getValue(),
                    replacement = imageManager['default'].getSrcRange(editorValue, e.target),
                    cursorPosition;

                if (replacement) {
                    cursorPosition = replacement.start + resultSrc.length + 1;
                    if (replacement.needsParens) {
                        resultSrc = '(' + resultSrc + ')';
                    }
                    editor.replaceSelection(resultSrc, replacement.start, replacement.end, cursorPosition);
                }
            },

            autoSaveNew: function autoSaveNew() {
                if (this.get('model.isNew')) {
                    this.send('save', { silent: true, backgroundSave: true });
                }
            },

            updateEditorScrollInfo: function updateEditorScrollInfo(scrollInfo) {
                this.set('editorScrollInfo', scrollInfo);
            },

            updateHeight: function updateHeight(height) {
                this.set('height', height);
            }
        }
    });

});
define('ghost/mixins/editor-base-route', ['exports', 'ember', 'ghost/mixins/shortcuts-route', 'ghost/mixins/style-body', 'ghost/utils/editor-shortcuts'], function (exports, Ember, ShortcutsRoute, styleBody, editorShortcuts) {

    'use strict';

    var EditorBaseRoute = Ember['default'].Mixin.create(styleBody['default'], ShortcutsRoute['default'], {
        classNames: ['editor'],

        actions: {
            save: function save() {
                this.get('controller').send('save');
            },

            publish: function publish() {
                var controller = this.get('controller');

                controller.send('setSaveType', 'publish');
                controller.send('save');
            },

            toggleZenMode: function toggleZenMode() {
                Ember['default'].$('body').toggleClass('zen');
            },

            // The actual functionality is implemented in utils/ed-editor-shortcuts
            editorShortcut: function editorShortcut(options) {
                // Only fire editor shortcuts when the editor has focus.
                if (this.get('controller.editor').$().is(':focus')) {
                    this.get('controller.editor').shortcut(options.type);
                }
            },

            willTransition: function willTransition(transition) {
                var controller = this.get('controller'),
                    scratch = controller.get('model.scratch'),
                    controllerIsDirty = controller.get('isDirty'),
                    model = controller.get('model'),
                    state = model.getProperties('isDeleted', 'isSaving', 'isDirty', 'isNew'),
                    fromNewToEdit,
                    deletedWithoutChanges;

                // if a save is in-flight we don't know whether or not it's safe to leave
                // so we abort the transition and retry after the save has completed.
                if (state.isSaving) {
                    transition.abort();
                    return Ember['default'].run.later(this, function () {
                        Ember['default'].RSVP.resolve(controller.get('lastPromise')).then(function () {
                            transition.retry();
                        });
                    }, 100);
                }

                fromNewToEdit = this.get('routeName') === 'editor.new' && transition.targetName === 'editor.edit' && transition.intent.contexts && transition.intent.contexts[0] && transition.intent.contexts[0].id === model.get('id');

                deletedWithoutChanges = state.isDeleted && (state.isSaving || !state.isDirty);

                if (!fromNewToEdit && !deletedWithoutChanges && controllerIsDirty) {
                    transition.abort();
                    this.send('openModal', 'leave-editor', [controller, transition]);
                    return;
                }

                // The controller may hold model state that will be lost in the transition,
                // so we need to apply it now.
                if (fromNewToEdit && controllerIsDirty) {
                    if (scratch !== model.get('markdown')) {
                        model.set('markdown', scratch);
                    }
                }

                if (state.isNew) {
                    model.deleteRecord();
                }

                // since the transition is now certain to complete..
                window.onbeforeunload = null;

                // remove model-related listeners created in editor-base-route
                this.detachModelHooks(controller, model);
            }
        },

        renderTemplate: function renderTemplate(controller, model) {
            this._super(controller, model);

            this.render('post-settings-menu', {
                into: 'application',
                outlet: 'settings-menu',
                model: model
            });
        },

        shortcuts: editorShortcuts['default'],

        attachModelHooks: function attachModelHooks(controller, model) {
            // this will allow us to track when the model is saved and update the controller
            // so that we can be sure controller.isDirty is correct, without having to update the
            // controller on each instance of `model.save()`.
            //
            // another reason we can't do this on `model.save().then()` is because the post-settings-menu
            // also saves the model, and passing messages is difficult because we have two
            // types of editor controllers, and the PSM also exists on the posts.post route.
            //
            // The reason we can't just keep this functionality in the editor controller is
            // because we need to remove these handlers on `willTransition` in the editor route.
            model.on('didCreate', controller, controller.get('modelSaved'));
            model.on('didUpdate', controller, controller.get('modelSaved'));
        },

        detachModelHooks: function detachModelHooks(controller, model) {
            model.off('didCreate', controller, controller.get('modelSaved'));
            model.off('didUpdate', controller, controller.get('modelSaved'));
        },

        setupController: function setupController(controller, model) {
            model.set('scratch', model.get('markdown'));
            model.set('titleScratch', model.get('title'));

            this._super(controller, model);
            var tags = model.get('tags');

            if (tags) {
                // used to check if anything has changed in the editor
                controller.set('previousTagNames', tags.mapBy('name'));
            } else {
                controller.set('previousTagNames', []);
            }

            // attach model-related listeners created in editor-base-route
            this.attachModelHooks(controller, model);
        }
    });

    exports['default'] = EditorBaseRoute;

});
define('ghost/mixins/infinite-scroll', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    exports['default'] = Ember['default'].Mixin.create({
        isLoading: false,
        triggerPoint: 100,

        /**
         * Determines if we are past a scroll point where we need to fetch the next page
         * @param {object} event The scroll event
         */
        checkScroll: function checkScroll(event) {
            var element = event.target,
                triggerPoint = this.get('triggerPoint'),
                isLoading = this.get('isLoading');

            // If we haven't passed our threshold or we are already fetching content, exit
            if (isLoading || element.scrollTop + element.clientHeight + triggerPoint <= element.scrollHeight) {
                return;
            }

            this.sendAction('fetch');
        },

        didInsertElement: function didInsertElement() {
            var el = this.get('element');

            el.onscroll = Ember['default'].run.bind(this, this.checkScroll);

            if (el.scrollHeight <= el.clientHeight) {
                this.sendAction('fetch');
            }
        },

        willDestroyElement: function willDestroyElement() {
            // turn off the scroll handler
            this.get('element').onscroll = null;
        }
    });

});
define('ghost/mixins/pagination-controller', ['exports', 'ember', 'ghost/utils/ajax'], function (exports, Ember, getRequestErrorMessage) {

    'use strict';

    exports['default'] = Ember['default'].Mixin.create({
        notifications: Ember['default'].inject.service(),

        // set from PaginationRouteMixin
        paginationSettings: null,

        // indicates whether we're currently loading the next page
        isLoading: null,

        /**
         * Takes an ajax response, concatenates any error messages, then generates an error notification.
         * @param {jqXHR} response The jQuery ajax reponse object.
         * @return
         */
        reportLoadError: function reportLoadError(response) {
            var message = 'A problem was encountered while loading more records';

            if (response) {
                // Get message from response
                message += ': ' + getRequestErrorMessage['default'](response, true);
            } else {
                message += '.';
            }

            this.get('notifications').showAlert(message, { type: 'error' });
        },

        actions: {
            /**
             * Loads the next paginated page of posts into the ember-data store. Will cause the posts list UI to update.
             * @return
             */
            loadNextPage: function loadNextPage() {
                var self = this,
                    store = this.get('store'),
                    recordType = this.get('model').get('type'),
                    metadata = this.store.metadataFor(recordType),
                    nextPage = metadata.pagination && metadata.pagination.next,
                    paginationSettings = this.get('paginationSettings');

                if (nextPage) {
                    this.set('isLoading', true);
                    this.set('paginationSettings.page', nextPage);

                    store.find(recordType, paginationSettings).then(function () {
                        self.set('isLoading', false);
                    }, function (response) {
                        self.reportLoadError(response);
                    });
                }
            },

            resetPagination: function resetPagination() {
                this.set('paginationSettings.page', 1);
                this.store.setMetadataFor('tag', { pagination: undefined });
            }
        }
    });

});
define('ghost/mixins/pagination-route', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    var defaultPaginationSettings, PaginationRoute;

    defaultPaginationSettings = {
        page: 1,
        limit: 15
    };

    PaginationRoute = Ember['default'].Mixin.create({
        /**
         * Sets up pagination details
         * @param {object} settings specifies additional pagination details
         */
        setupPagination: function setupPagination(settings) {
            settings = settings || {};
            for (var key in defaultPaginationSettings) {
                if (defaultPaginationSettings.hasOwnProperty(key)) {
                    if (!settings.hasOwnProperty(key)) {
                        settings[key] = defaultPaginationSettings[key];
                    }
                }
            }

            this.set('paginationSettings', settings);
            this.controller.set('paginationSettings', settings);
        }
    });

    exports['default'] = PaginationRoute;

});
define('ghost/mixins/resize-aware', ['exports', 'ember-resize/mixins/resize-aware'], function (exports, resize_aware) {

	'use strict';



	exports.default = resize_aware.default;

});
define('ghost/mixins/settings-menu-controller', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    exports['default'] = Ember['default'].Mixin.create({
        application: Ember['default'].inject.controller(),

        isViewingSubview: Ember['default'].computed('application.showSettingsMenu', {
            get: function get() {
                return false;
            },
            set: function set(key, value) {
                // Not viewing a subview if we can't even see the PSM
                if (!this.get('application.showSettingsMenu')) {
                    return false;
                }
                return value;
            }
        }),

        actions: {
            showSubview: function showSubview() {
                this.set('isViewingSubview', true);
            },

            closeSubview: function closeSubview() {
                this.set('isViewingSubview', false);
            }
        }
    });

});
define('ghost/mixins/settings-save', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    exports['default'] = Ember['default'].Mixin.create({
        submitting: false,

        actions: {
            save: function save() {
                var self = this;

                this.set('submitting', true);

                this.save().then(function () {
                    self.set('submitting', false);
                });
            }
        }
    });

});
define('ghost/mixins/shortcuts-route', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    key.filter = function () {
        return true;
    };

    key.setScope('default');
    /**
     * Only routes can implement shortcuts.
     * If you need to trigger actions on the controller,
     * simply call them with `this.get('controller').send('action')`.
     *
     * To implement shortcuts, add this mixin to your `extend()`,
     * and implement a `shortcuts` hash.
     * In this hash, keys are shortcut combinations and values are route action names.
     *  (see [keymaster docs](https://github.com/madrobby/keymaster/blob/master/README.markdown)),
     *
     * ```javascript
     * shortcuts: {
     *     'ctrl+s, command+s': 'save',
     *     'ctrl+alt+z': 'toggleZenMode'
     * }
     * ```
     * For more complex actions, shortcuts can instead have their value
     * be an object like {action, options}
     * ```javascript
     * shortcuts: {
     *      'ctrl+k': {action: 'markdownShortcut', options: 'createLink'}
     * }
     * ```
     * You can set the scope of your shortcut by passing a scope property.
     * ```javascript
     * shortcuts : {
     *   'enter': {action : 'confirmModal', scope: 'modal'}
     * }
     * ```
     * If you don't specify a scope, we use a default scope called "default".
     * To have all your shortcut work in all scopes, give it the scope "all".
     * Find out more at the keymaster docs
     */
    var ShortcutsRoute = Ember['default'].Mixin.create({
        registerShortcuts: function registerShortcuts() {
            var self = this,
                shortcuts = this.get('shortcuts');

            Ember['default'].keys(shortcuts).forEach(function (shortcut) {
                var scope = shortcuts[shortcut].scope || 'default',
                    action = shortcuts[shortcut],
                    options;

                if (Ember['default'].typeOf(action) !== 'string') {
                    options = action.options;
                    action = action.action;
                }

                key(shortcut, scope, function (event) {
                    // stop things like ctrl+s from actually opening a save dialogue
                    event.preventDefault();
                    self.send(action, options);
                });
            });
        },

        removeShortcuts: function removeShortcuts() {
            var shortcuts = this.get('shortcuts');

            Ember['default'].keys(shortcuts).forEach(function (shortcut) {
                key.unbind(shortcut);
            });
        },

        activate: function activate() {
            this._super();
            this.registerShortcuts();
        },

        deactivate: function deactivate() {
            this._super();
            this.removeShortcuts();
        }
    });

    exports['default'] = ShortcutsRoute;

});
define('ghost/mixins/style-body', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    var styleBody = Ember['default'].Mixin.create({
        activate: function activate() {
            this._super();

            var cssClasses = this.get('classNames');

            if (cssClasses) {
                Ember['default'].run.schedule('afterRender', null, function () {
                    cssClasses.forEach(function (curClass) {
                        Ember['default'].$('body').addClass(curClass);
                    });
                });
            }
        },

        deactivate: function deactivate() {
            this._super();

            var cssClasses = this.get('classNames');

            Ember['default'].run.schedule('afterRender', null, function () {
                cssClasses.forEach(function (curClass) {
                    Ember['default'].$('body').removeClass(curClass);
                });
            });
        }
    });

    exports['default'] = styleBody;

});
define('ghost/mixins/text-input', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    var BlurField = Ember['default'].Mixin.create({
        selectOnClick: false,
        stopEnterKeyDownPropagation: false,

        click: function click(event) {
            if (this.get('selectOnClick')) {
                event.currentTarget.select();
            }
        },

        keyDown: function keyDown(event) {
            // stop event propagation when pressing "enter"
            // most useful in the case when undesired (global) keyboard shortcuts are getting triggered while interacting
            // with this particular input element.
            if (this.get('stopEnterKeyDownPropagation') && event.keyCode === 13) {
                event.stopPropagation();

                return true;
            }
        }
    });

    exports['default'] = BlurField;

});
define('ghost/mixins/validation-engine', ['exports', 'ember', 'ember-data', 'ghost/utils/ajax', 'ghost/utils/validator-extensions', 'ghost/validators/post', 'ghost/validators/setup', 'ghost/validators/signup', 'ghost/validators/signin', 'ghost/validators/setting', 'ghost/validators/reset', 'ghost/validators/user', 'ghost/validators/tag-settings'], function (exports, Ember, DS, getRequestErrorMessage, ValidatorExtensions, PostValidator, SetupValidator, SignupValidator, SigninValidator, SettingValidator, ResetValidator, UserValidator, TagSettingsValidator) {

    'use strict';

    ValidatorExtensions['default'].init();

    /**
    * The class that gets this mixin will receive these properties and functions.
    * It will be able to validate any properties on itself (or the model it passes to validate())
    * with the use of a declared validator.
    */
    exports['default'] = Ember['default'].Mixin.create({
        // these validators can be passed a model to validate when the class that
        // mixes in the ValidationEngine declares a validationType equal to a key on this object.
        // the model is either passed in via `this.validate({ model: object })`
        // or by calling `this.validate()` without the model property.
        // in that case the model will be the class that the ValidationEngine
        // was mixed into, i.e. the controller or Ember Data model.
        validators: {
            post: PostValidator['default'],
            setup: SetupValidator['default'],
            signup: SignupValidator['default'],
            signin: SigninValidator['default'],
            setting: SettingValidator['default'],
            reset: ResetValidator['default'],
            user: UserValidator['default'],
            tag: TagSettingsValidator['default']
        },

        // This adds the Errors object to the validation engine, and shouldn't affect
        // ember-data models because they essentially use the same thing
        errors: DS['default'].Errors.create(),

        // Store whether a property has been validated yet, so that we know whether or not
        // to show error / success validation for a field
        hasValidated: Ember['default'].A(),

        /**
        * Passes the model to the validator specified by validationType.
        * Returns a promise that will resolve if validation succeeds, and reject if not.
        * Some options can be specified:
        *
        * `model: Object` - you can specify the model to be validated, rather than pass the default value of `this`,
        *                   the class that mixes in this mixin.
        *
        * `property: String` - you can specify a specific property to validate. If
        * 					   no property is specified, the entire model will be
        * 					   validated
        */
        validate: function validate(opts) {
            // jscs:disable safeContextKeyword
            opts = opts || {};

            var model = this,
                type,
                validator,
                hasValidated;

            if (opts.model) {
                model = opts.model;
            } else if (this instanceof DS['default'].Model) {
                model = this;
            } else if (this.get('model')) {
                model = this.get('model');
            }

            type = this.get('validationType') || model.get('validationType');
            validator = this.get('validators.' + type) || model.get('validators.' + type);
            hasValidated = this.get('hasValidated');

            opts.validationType = type;

            return new Ember['default'].RSVP.Promise(function (resolve, reject) {
                var passed;

                if (!type || !validator) {
                    return reject(['The validator specified, "' + type + '", did not exist!']);
                }

                if (opts.property) {
                    // If property isn't in `hasValidated`, add it to mark that this field can show a validation result
                    hasValidated.addObject(opts.property);
                    model.get('errors').remove(opts.property);
                } else {
                    model.get('errors').clear();
                }

                passed = validator.check(model, opts.property);

                return passed ? resolve() : reject();
            });
        },

        /**
        * The primary goal of this method is to override the `save` method on Ember Data models.
        * This allows us to run validation before actually trying to save the model to the server.
        * You can supply options to be passed into the `validate` method, since the ED `save` method takes no options.
        */
        save: function save(options) {
            var self = this,

            // this is a hack, but needed for async _super calls.
            // ref: https://github.com/emberjs/ember.js/pull/4301
            _super = this.__nextSuper;

            options = options || {};
            options.wasSave = true;

            // model.destroyRecord() calls model.save() behind the scenes.
            // in that case, we don't need validation checks or error propagation,
            // because the model itself is being destroyed.
            if (this.get('isDeleted')) {
                return this._super();
            }

            // If validation fails, reject with validation errors.
            // If save to the server fails, reject with server response.
            return this.validate(options).then(function () {
                return _super.call(self, options);
            })['catch'](function (result) {
                // server save failed or validator type doesn't exist
                if (result && !Ember['default'].isArray(result)) {
                    // return the array of errors from the server
                    result = getRequestErrorMessage['default'](result);
                }

                return Ember['default'].RSVP.reject(result);
            });
        },
        actions: {
            validate: function validate(property) {
                this.validate({ property: property });
            }
        }
    });

});
define('ghost/models/notification', ['exports', 'ember-data'], function (exports, DS) {

    'use strict';

    var Notification = DS['default'].Model.extend({
        dismissible: DS['default'].attr('boolean'),
        status: DS['default'].attr('string'),
        type: DS['default'].attr('string'),
        message: DS['default'].attr('string')
    });

    exports['default'] = Notification;

});
define('ghost/models/post', ['exports', 'ember', 'ember-data', 'ghost/mixins/validation-engine'], function (exports, Ember, DS, ValidationEngine) {

    'use strict';

    exports['default'] = DS['default'].Model.extend(ValidationEngine['default'], {
        validationType: 'post',

        uuid: DS['default'].attr('string'),
        title: DS['default'].attr('string', { defaultValue: '' }),
        slug: DS['default'].attr('string'),
        markdown: DS['default'].attr('string', { defaultValue: '' }),
        html: DS['default'].attr('string'),
        image: DS['default'].attr('string'),
        featured: DS['default'].attr('boolean', { defaultValue: false }),
        page: DS['default'].attr('boolean', { defaultValue: false }),
        status: DS['default'].attr('string', { defaultValue: 'draft' }),
        language: DS['default'].attr('string', { defaultValue: 'en_US' }),
        meta_title: DS['default'].attr('string'),
        meta_description: DS['default'].attr('string'),
        author: DS['default'].belongsTo('user', { async: true }),
        author_id: DS['default'].attr('number'),
        updated_at: DS['default'].attr('moment-date'),
        updated_by: DS['default'].attr(),
        published_at: DS['default'].attr('moment-date'),
        published_by: DS['default'].belongsTo('user', { async: true }),
        created_at: DS['default'].attr('moment-date'),
        created_by: DS['default'].attr(),
        tags: DS['default'].hasMany('tag', { embedded: 'always' }),
        url: DS['default'].attr('string'),

        config: Ember['default'].inject.service(),
        ghostPaths: Ember['default'].inject.service('ghost-paths'),

        absoluteUrl: Ember['default'].computed('url', 'ghostPaths.url', 'config.blogUrl', function () {
            var blogUrl = this.get('config.blogUrl'),
                postUrl = this.get('url');
            return this.get('ghostPaths.url').join(blogUrl, postUrl);
        }),

        previewUrl: Ember['default'].computed('uuid', 'ghostPaths.url', 'config.blogUrl', 'config.routeKeywords.preview', function () {
            var blogUrl = this.get('config.blogUrl'),
                uuid = this.get('uuid'),
                previewKeyword = this.get('config.routeKeywords.preview');
            // New posts don't have a preview
            if (!uuid) {
                return '';
            }
            return this.get('ghostPaths.url').join(blogUrl, previewKeyword, uuid);
        }),

        scratch: null,
        titleScratch: null,

        // Computed post properties

        isPublished: Ember['default'].computed.equal('status', 'published'),
        isDraft: Ember['default'].computed.equal('status', 'draft'),

        // remove client-generated tags, which have `id: null`.
        // Ember Data won't recognize/update them automatically
        // when returned from the server with ids.
        // https://github.com/emberjs/data/issues/1829
        updateTags: function updateTags() {
            var tags = this.get('tags'),
                oldTags = tags.filterBy('id', null);

            tags.removeObjects(oldTags);
            oldTags.invoke('deleteRecord');
        },

        isAuthoredByUser: function isAuthoredByUser(user) {
            return parseInt(user.get('id'), 10) === parseInt(this.get('author_id'), 10);
        }

    });

});
define('ghost/models/role', ['exports', 'ember', 'ember-data'], function (exports, Ember, DS) {

    'use strict';

    var Role = DS['default'].Model.extend({
        uuid: DS['default'].attr('string'),
        name: DS['default'].attr('string'),
        description: DS['default'].attr('string'),
        created_at: DS['default'].attr('moment-date'),
        updated_at: DS['default'].attr('moment-date'),
        created_by: DS['default'].attr(),
        updated_by: DS['default'].attr(),

        lowerCaseName: Ember['default'].computed('name', function () {
            return this.get('name').toLocaleLowerCase();
        })
    });

    exports['default'] = Role;

});
define('ghost/models/setting', ['exports', 'ember-data', 'ghost/mixins/validation-engine'], function (exports, DS, ValidationEngine) {

    'use strict';

    var Setting = DS['default'].Model.extend(ValidationEngine['default'], {
        validationType: 'setting',

        title: DS['default'].attr('string'),
        description: DS['default'].attr('string'),
        logo: DS['default'].attr('string'),
        cover: DS['default'].attr('string'),
        defaultLang: DS['default'].attr('string'),
        postsPerPage: DS['default'].attr('number'),
        forceI18n: DS['default'].attr('boolean'),
        permalinks: DS['default'].attr('string'),
        activeTheme: DS['default'].attr('string'),
        availableThemes: DS['default'].attr(),
        ghost_head: DS['default'].attr('string'),
        ghost_foot: DS['default'].attr('string'),
        labs: DS['default'].attr('string'),
        navigation: DS['default'].attr('string'),
        isPrivate: DS['default'].attr('boolean'),
        password: DS['default'].attr('string')
    });

    exports['default'] = Setting;

});
define('ghost/models/slug-generator', ['exports', 'ember', 'ic-ajax'], function (exports, Ember, ic_ajax) {

    'use strict';

    exports['default'] = Ember['default'].Object.extend({
        slugType: null,
        value: null,

        ghostPaths: Ember['default'].inject.service('ghost-paths'),

        toString: function toString() {
            return this.get('value');
        },

        generateSlug: function generateSlug(textToSlugify) {
            var self = this,
                url;

            if (!textToSlugify) {
                return Ember['default'].RSVP.resolve('');
            }

            url = this.get('ghostPaths.url').api('slugs', this.get('slugType'), encodeURIComponent(textToSlugify));

            return ic_ajax.request(url, {
                type: 'GET'
            }).then(function (response) {
                var slug = response.slugs[0].slug;

                self.set('value', slug);

                return slug;
            });
        }
    });

});
define('ghost/models/tag', ['exports', 'ember-data', 'ghost/mixins/validation-engine'], function (exports, DS, ValidationEngine) {

    'use strict';

    var Tag = DS['default'].Model.extend(ValidationEngine['default'], {
        validationType: 'tag',

        uuid: DS['default'].attr('string'),
        name: DS['default'].attr('string'),
        slug: DS['default'].attr('string'),
        description: DS['default'].attr('string'),
        parent: DS['default'].attr(),
        meta_title: DS['default'].attr('string'),
        meta_description: DS['default'].attr('string'),
        image: DS['default'].attr('string'),
        hidden: DS['default'].attr('boolean'),
        created_at: DS['default'].attr('moment-date'),
        updated_at: DS['default'].attr('moment-date'),
        created_by: DS['default'].attr(),
        updated_by: DS['default'].attr(),
        post_count: DS['default'].attr('number')
    });

    exports['default'] = Tag;

});
define('ghost/models/user', ['exports', 'ember', 'ember-data', 'ic-ajax', 'ghost/mixins/validation-engine'], function (exports, Ember, DS, ic_ajax, ValidationEngine) {

    'use strict';

    exports['default'] = DS['default'].Model.extend(ValidationEngine['default'], {
        validationType: 'user',

        uuid: DS['default'].attr('string'),
        name: DS['default'].attr('string'),
        slug: DS['default'].attr('string'),
        email: DS['default'].attr('string'),
        image: DS['default'].attr('string'),
        cover: DS['default'].attr('string'),
        bio: DS['default'].attr('string'),
        website: DS['default'].attr('string'),
        location: DS['default'].attr('string'),
        accessibility: DS['default'].attr('string'),
        status: DS['default'].attr('string'),
        language: DS['default'].attr('string', { defaultValue: 'en_US' }),
        meta_title: DS['default'].attr('string'),
        meta_description: DS['default'].attr('string'),
        last_login: DS['default'].attr('moment-date'),
        created_at: DS['default'].attr('moment-date'),
        created_by: DS['default'].attr('number'),
        updated_at: DS['default'].attr('moment-date'),
        updated_by: DS['default'].attr('number'),
        roles: DS['default'].hasMany('role', { embedded: 'always' }),

        ghostPaths: Ember['default'].inject.service('ghost-paths'),

        role: Ember['default'].computed('roles', {
            get: function get() {
                return this.get('roles.firstObject');
            },
            set: function set(key, value) {
                // Only one role per user, so remove any old data.
                this.get('roles').clear();
                this.get('roles').pushObject(value);

                return value;
            }
        }),

        // TODO: Once client-side permissions are in place,
        // remove the hard role check.
        isAuthor: Ember['default'].computed.equal('role.name', 'Author'),
        isEditor: Ember['default'].computed.equal('role.name', 'Editor'),
        isAdmin: Ember['default'].computed.equal('role.name', 'Administrator'),
        isOwner: Ember['default'].computed.equal('role.name', 'Owner'),

        saveNewPassword: function saveNewPassword() {
            var url = this.get('ghostPaths.url').api('users', 'password');

            return ic_ajax.request(url, {
                type: 'PUT',
                data: {
                    password: [{
                        user_id: this.get('id'),
                        oldPassword: this.get('password'),
                        newPassword: this.get('newPassword'),
                        ne2Password: this.get('ne2Password')
                    }]
                }
            });
        },

        resendInvite: function resendInvite() {
            var fullUserData = this.toJSON(),
                userData = {
                email: fullUserData.email,
                roles: fullUserData.roles
            };

            return ic_ajax.request(this.get('ghostPaths.url').api('users'), {
                type: 'POST',
                data: JSON.stringify({ users: [userData] }),
                contentType: 'application/json'
            });
        },

        passwordValidationErrors: Ember['default'].computed('password', 'newPassword', 'ne2Password', function () {
            var validationErrors = [];

            if (!validator.equals(this.get('newPassword'), this.get('ne2Password'))) {
                validationErrors.push({ message: 'Your new passwords do not match' });
            }

            if (!validator.isLength(this.get('newPassword'), 8)) {
                validationErrors.push({ message: 'Your password is not long enough. It must be at least 8 characters long.' });
            }

            return validationErrors;
        }),

        isPasswordValid: Ember['default'].computed.empty('passwordValidationErrors.[]'),

        active: Ember['default'].computed('status', function () {
            return ['active', 'warn-1', 'warn-2', 'warn-3', 'warn-4', 'locked'].indexOf(this.get('status')) > -1;
        }),

        invited: Ember['default'].computed('status', function () {
            return ['invited', 'invited-pending'].indexOf(this.get('status')) > -1;
        }),

        pending: Ember['default'].computed.equal('status', 'invited-pending').property('status')
    });

});
define('ghost/router', ['exports', 'ember', 'ghost/utils/ghost-paths', 'ghost/utils/document-title'], function (exports, Ember, ghostPaths, documentTitle) {

    'use strict';

    var Router = Ember['default'].Router.extend({
        location: 'trailing-history', // use HTML5 History API instead of hash-tag based URLs
        rootURL: ghostPaths['default']().adminRoot, // admin interface lives under sub-directory /ghost

        notifications: Ember['default'].inject.service(),

        displayDelayedNotifications: Ember['default'].on('didTransition', function () {
            this.get('notifications').displayDelayed();
        })
    });

    documentTitle['default']();

    Router.map(function () {
        this.route('setup', function () {
            this.route('one');
            this.route('two');
            this.route('three');
        });

        this.route('signin');
        this.route('signout');
        this.route('signup', { path: '/signup/:token' });
        this.route('reset', { path: '/reset/:token' });
        this.route('about', { path: '/about' });

        this.route('posts', { path: '/' }, function () {
            this.route('post', { path: ':post_id' });
        });

        this.route('editor', function () {
            this.route('new', { path: '' });
            this.route('edit', { path: ':post_id' });
        });

        this.route('team', { path: '/team' }, function () {
            this.route('user', { path: ':slug' });
        });

        this.route('settings.general', { path: '/settings/general' });
        this.route('settings.tags', { path: '/settings/tags' });
        this.route('settings.labs', { path: '/settings/labs' });
        this.route('settings.code-injection', { path: '/settings/code-injection' });
        this.route('settings.navigation', { path: '/settings/navigation' });

        this.route('error404', { path: '/*path' });
    });

    exports['default'] = Router;

});
define('ghost/routes/about', ['exports', 'ember', 'ic-ajax', 'ghost/routes/authenticated', 'ghost/mixins/style-body'], function (exports, Ember, ic_ajax, AuthenticatedRoute, styleBody) {

    'use strict';

    exports['default'] = AuthenticatedRoute['default'].extend(styleBody['default'], {
        titleToken: 'About',

        classNames: ['view-about'],

        ghostPaths: Ember['default'].inject.service('ghost-paths'),

        cachedConfig: false,

        model: function model() {
            var cachedConfig = this.get('cachedConfig'),
                self = this;

            if (cachedConfig) {
                return cachedConfig;
            }

            return ic_ajax.request(this.get('ghostPaths.url').api('configuration')).then(function (configurationResponse) {
                var configKeyValues = configurationResponse.configuration;

                cachedConfig = {};
                configKeyValues.forEach(function (configKeyValue) {
                    cachedConfig[configKeyValue.key] = configKeyValue.value;
                });
                self.set('cachedConfig', cachedConfig);

                return cachedConfig;
            });
        }
    });

});
define('ghost/routes/application', ['exports', 'ember', 'simple-auth/mixins/application-route-mixin', 'simple-auth/configuration', 'ghost/mixins/shortcuts-route', 'ghost/utils/ctrl-or-cmd'], function (exports, Ember, ApplicationRouteMixin, Configuration, ShortcutsRoute, ctrlOrCmd) {

    'use strict';

    /* global key */

    var shortcuts = {};

    shortcuts.esc = { action: 'closeMenus', scope: 'all' };
    shortcuts.enter = { action: 'confirmModal', scope: 'modal' };
    shortcuts[ctrlOrCmd['default'] + '+s'] = { action: 'save', scope: 'all' };

    exports['default'] = Ember['default'].Route.extend(ApplicationRouteMixin['default'], ShortcutsRoute['default'], {
        shortcuts: shortcuts,

        config: Ember['default'].inject.service(),
        dropdown: Ember['default'].inject.service(),
        notifications: Ember['default'].inject.service(),

        afterModel: function afterModel(model, transition) {
            if (this.get('session').isAuthenticated) {
                transition.send('loadServerNotifications');
            }
        },

        title: function title(tokens) {
            return tokens.join(' - ') + ' - ' + this.get('config.blogTitle');
        },

        actions: {
            openMobileMenu: function openMobileMenu() {
                this.controller.set('showMobileMenu', true);
            },

            openSettingsMenu: function openSettingsMenu() {
                this.controller.set('showSettingsMenu', true);
            },

            closeMenus: function closeMenus() {
                this.get('dropdown').closeDropdowns();
                this.send('closeModal');
                this.controller.setProperties({
                    showSettingsMenu: false,
                    showMobileMenu: false
                });
            },

            didTransition: function didTransition() {
                this.send('closeMenus');
            },

            signedIn: function signedIn() {
                this.send('loadServerNotifications', true);
            },

            invalidateSession: function invalidateSession() {
                this.get('session').invalidate();
            },

            sessionAuthenticationFailed: function sessionAuthenticationFailed(error) {
                if (error.errors) {
                    // These are server side errors, which can be marked as htmlSafe
                    error.errors.forEach(function (err) {
                        err.message = err.message.htmlSafe();
                    });
                } else {
                    // Connection errors don't return proper status message, only req.body
                    this.get('notifications').showAlert('There was a problem on the server.', { type: 'error' });
                }
            },

            sessionAuthenticationSucceeded: function sessionAuthenticationSucceeded() {
                var appController = this.controllerFor('application'),
                    self = this;

                if (appController && appController.get('skipAuthSuccessHandler')) {
                    return;
                }

                this.get('session.user').then(function (user) {
                    self.send('signedIn', user);
                    var attemptedTransition = self.get('session').get('attemptedTransition');
                    if (attemptedTransition) {
                        attemptedTransition.retry();
                        self.get('session').set('attemptedTransition', null);
                    } else {
                        self.transitionTo(Configuration['default'].routeAfterAuthentication);
                    }
                });
            },

            sessionInvalidationFailed: function sessionInvalidationFailed(error) {
                this.get('notifications').showAlert(error.message, { type: 'error' });
            },

            openModal: function openModal(modalName, model, type) {
                this.get('dropdown').closeDropdowns();
                key.setScope('modal');
                modalName = 'modals/' + modalName;
                this.set('modalName', modalName);

                // We don't always require a modal to have a controller
                // so we're skipping asserting if one exists
                if (this.controllerFor(modalName, true)) {
                    this.controllerFor(modalName).set('model', model);

                    if (type) {
                        this.controllerFor(modalName).set('imageType', type);
                        this.controllerFor(modalName).set('src', model.get(type));
                    }
                }

                return this.render(modalName, {
                    into: 'application',
                    outlet: 'modal'
                });
            },

            confirmModal: function confirmModal() {
                var modalName = this.get('modalName');

                this.send('closeModal');

                if (this.controllerFor(modalName, true)) {
                    this.controllerFor(modalName).send('confirmAccept');
                }
            },

            closeModal: function closeModal() {
                this.disconnectOutlet({
                    outlet: 'modal',
                    parentView: 'application'
                });

                key.setScope('default');
            },

            loadServerNotifications: function loadServerNotifications(isDelayed) {
                var self = this;

                if (this.session.isAuthenticated) {
                    this.get('session.user').then(function (user) {
                        if (!user.get('isAuthor') && !user.get('isEditor')) {
                            self.store.findAll('notification').then(function (serverNotifications) {
                                serverNotifications.forEach(function (notification) {
                                    self.get('notifications').handleNotification(notification, isDelayed);
                                });
                            });
                        }
                    });
                }
            },

            // noop default for unhandled save (used from shortcuts)
            save: Ember['default'].K
        }
    });

});
define('ghost/routes/authenticated', ['exports', 'ember', 'simple-auth/mixins/authenticated-route-mixin'], function (exports, Ember, AuthenticatedRouteMixin) {

	'use strict';

	var AuthenticatedRoute = Ember['default'].Route.extend(AuthenticatedRouteMixin['default']);

	exports['default'] = AuthenticatedRoute;

});
define('ghost/routes/editor/edit', ['exports', 'ghost/routes/authenticated', 'ghost/mixins/editor-base-route', 'ghost/utils/isNumber', 'ghost/utils/isFinite'], function (exports, AuthenticatedRoute, base, isNumber, isFinite) {

    'use strict';

    var EditorEditRoute = AuthenticatedRoute['default'].extend(base['default'], {
        titleToken: 'Editor',

        beforeModel: function beforeModel(transition) {
            this.set('_transitionedFromNew', transition.data.fromNew);

            this._super.apply(this, arguments);
        },

        model: function model(params) {
            var self = this,
                postId,
                query;

            postId = Number(params.post_id);

            if (!isNumber['default'](postId) || !isFinite['default'](postId) || postId % 1 !== 0 || postId <= 0) {
                return this.transitionTo('error404', 'editor/' + params.post_id);
            }

            query = {
                id: postId,
                status: 'all',
                staticPages: 'all'
            };

            return self.store.find('post', query).then(function (records) {
                var post = records.get('firstObject');

                if (post) {
                    return post;
                }

                return self.replaceWith('posts.index');
            });
        },

        afterModel: function afterModel(post) {
            var self = this;

            return self.get('session.user').then(function (user) {
                if (user.get('isAuthor') && !post.isAuthoredByUser(user)) {
                    return self.replaceWith('posts.index');
                }
            });
        },

        setupController: function setupController(controller /*, model */) {
            this._super.apply(this, arguments);

            controller.set('shouldFocusEditor', this.get('_transitionedFromNew'));
        },

        actions: {
            authorizationFailed: function authorizationFailed() {
                this.send('openModal', 'signin');
            }
        }
    });

    exports['default'] = EditorEditRoute;

});
define('ghost/routes/editor/index', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    var EditorRoute = Ember['default'].Route.extend({
        beforeModel: function beforeModel() {
            this.transitionTo('editor.new');
        }
    });

    exports['default'] = EditorRoute;

});
define('ghost/routes/editor/new', ['exports', 'ghost/routes/authenticated', 'ghost/mixins/editor-base-route'], function (exports, AuthenticatedRoute, base) {

    'use strict';

    exports['default'] = AuthenticatedRoute['default'].extend(base['default'], {
        titleToken: 'Editor',

        model: function model() {
            var self = this;
            return this.get('session.user').then(function (user) {
                return self.store.createRecord('post', {
                    author: user
                });
            });
        },

        renderTemplate: function renderTemplate(controller, model) {
            this.render('editor/edit', {
                controller: controller,
                model: model
            });

            this.render('post-settings-menu', {
                into: 'application',
                outlet: 'settings-menu',
                model: model
            });
        },

        setupController: function setupController(controller, model) {
            var psm = this.controllerFor('post-settings-menu');

            // make sure there are no titleObserver functions hanging around
            // from previous posts
            psm.removeObserver('titleScratch', psm, 'titleObserver');

            // Ensure that the PSM Image Uploader and Publish Date selector resets
            psm.send('resetUploader');
            psm.send('resetPubDate');

            this._super(controller, model);
        },

        actions: {
            willTransition: function willTransition(transition) {
                // decorate the transition object so the editor.edit route
                // knows this was the previous active route
                transition.data.fromNew = true;

                this._super.apply(this, arguments);
            }
        }
    });

});
define('ghost/routes/error404', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    var Error404Route = Ember['default'].Route.extend({
        controllerName: 'error',
        templateName: 'error',
        titleToken: 'Error',

        model: function model() {
            return {
                status: 404
            };
        }
    });

    exports['default'] = Error404Route;

});
define('ghost/routes/mobile-index-route', ['exports', 'ember', 'ghost/utils/mobile'], function (exports, Ember, mobileQuery) {

    'use strict';

    var MobileIndexRoute = Ember['default'].Route.extend({
        desktopTransition: Ember['default'].K,

        activate: function attachDesktopTransition() {
            this._super();
            mobileQuery['default'].addListener(this.desktopTransitionMQ);
        },

        deactivate: function removeDesktopTransition() {
            this._super();
            mobileQuery['default'].removeListener(this.desktopTransitionMQ);
        },

        setDesktopTransitionMQ: Ember['default'].on('init', function () {
            var self = this;
            this.set('desktopTransitionMQ', function desktopTransitionMQ() {
                if (!mobileQuery['default'].matches) {
                    self.desktopTransition();
                }
            });
        })
    });

    exports['default'] = MobileIndexRoute;

});
define('ghost/routes/posts', ['exports', 'ember', 'ghost/routes/authenticated', 'ghost/mixins/shortcuts-route', 'ghost/mixins/pagination-route'], function (exports, Ember, AuthenticatedRoute, ShortcutsRoute, PaginationRouteMixin) {

    'use strict';

    var paginationSettings = {
        status: 'all',
        staticPages: 'all',
        page: 1
    };

    exports['default'] = AuthenticatedRoute['default'].extend(ShortcutsRoute['default'], PaginationRouteMixin['default'], {
        titleToken: 'Content',

        model: function model() {
            var self = this;

            return this.get('session.user').then(function (user) {
                if (user.get('isAuthor')) {
                    paginationSettings.author = user.get('slug');
                }

                // using `.filter` allows the template to auto-update when new models are pulled in from the server.
                // we just need to 'return true' to allow all models by default.
                return self.store.filter('post', paginationSettings, function (post) {
                    if (user.get('isAuthor')) {
                        return post.isAuthoredByUser(user);
                    }

                    return true;
                });
            });
        },

        setupController: function setupController(controller, model) {
            this._super(controller, model);
            this.setupPagination(paginationSettings);
        },

        stepThroughPosts: function stepThroughPosts(step) {
            var currentPost = this.get('controller.currentPost'),
                posts = this.get('controller.sortedPosts'),
                length = posts.get('length'),
                newPosition;

            newPosition = posts.indexOf(currentPost) + step;

            // if we are on the first or last item
            // just do nothing (desired behavior is to not
            // loop around)
            if (newPosition >= length) {
                return;
            } else if (newPosition < 0) {
                return;
            }

            this.transitionTo('posts.post', posts.objectAt(newPosition));
        },

        scrollContent: function scrollContent(amount) {
            var content = Ember['default'].$('.js-content-preview'),
                scrolled = content.scrollTop();

            content.scrollTop(scrolled + 50 * amount);
        },

        shortcuts: {
            'up, k': 'moveUp',
            'down, j': 'moveDown',
            left: 'focusList',
            right: 'focusContent',
            c: 'newPost'
        },

        actions: {
            focusList: function focusList() {
                this.controller.set('keyboardFocus', 'postList');
            },
            focusContent: function focusContent() {
                this.controller.set('keyboardFocus', 'postContent');
            },
            newPost: function newPost() {
                this.transitionTo('editor.new');
            },

            moveUp: function moveUp() {
                if (this.controller.get('postContentFocused')) {
                    this.scrollContent(-1);
                } else {
                    this.stepThroughPosts(-1);
                }
            },

            moveDown: function moveDown() {
                if (this.controller.get('postContentFocused')) {
                    this.scrollContent(1);
                } else {
                    this.stepThroughPosts(1);
                }
            }
        }
    });

});
define('ghost/routes/posts/index', ['exports', 'simple-auth/mixins/authenticated-route-mixin', 'ghost/routes/mobile-index-route', 'ghost/utils/mobile'], function (exports, AuthenticatedRouteMixin, MobileIndexRoute, mobileQuery) {

    'use strict';

    var PostsIndexRoute = MobileIndexRoute['default'].extend(AuthenticatedRouteMixin['default'], {
        noPosts: false,

        // Transition to a specific post if we're not on mobile
        beforeModel: function beforeModel() {
            if (!mobileQuery['default'].matches) {
                return this.goToPost();
            }
        },

        setupController: function setupController(controller, model) {
            /*jshint unused:false*/
            controller.set('noPosts', this.get('noPosts'));
        },

        goToPost: function goToPost() {
            var self = this,

            // the store has been populated by PostsRoute
            posts = this.store.all('post'),
                post;

            return this.get('session.user').then(function (user) {
                post = posts.find(function (post) {
                    // Authors can only see posts they've written
                    if (user.get('isAuthor')) {
                        return post.isAuthoredByUser(user);
                    }

                    return true;
                });

                if (post) {
                    return self.transitionTo('posts.post', post);
                }

                self.set('noPosts', true);
            });
        },

        // Mobile posts route callback
        desktopTransition: function desktopTransition() {
            this.goToPost();
        }
    });

    exports['default'] = PostsIndexRoute;

});
define('ghost/routes/posts/post', ['exports', 'ghost/routes/authenticated', 'ghost/mixins/shortcuts-route', 'ghost/utils/isNumber', 'ghost/utils/isFinite'], function (exports, AuthenticatedRoute, ShortcutsRoute, isNumber, isFinite) {

    'use strict';

    var PostsPostRoute = AuthenticatedRoute['default'].extend(ShortcutsRoute['default'], {
        model: function model(params) {
            var self = this,
                post,
                postId,
                query;

            postId = Number(params.post_id);

            if (!isNumber['default'](postId) || !isFinite['default'](postId) || postId % 1 !== 0 || postId <= 0) {
                return this.transitionTo('error404', params.post_id);
            }

            post = this.store.getById('post', postId);
            if (post) {
                return post;
            }

            query = {
                id: postId,
                status: 'all',
                staticPages: 'all'
            };

            return self.store.find('post', query).then(function (records) {
                var post = records.get('firstObject');

                if (post) {
                    return post;
                }

                return self.replaceWith('posts.index');
            });
        },

        afterModel: function afterModel(post) {
            var self = this;

            return self.get('session.user').then(function (user) {
                if (user.get('isAuthor') && !post.isAuthoredByUser(user)) {
                    return self.replaceWith('posts.index');
                }
            });
        },

        setupController: function setupController(controller, model) {
            this._super(controller, model);

            this.controllerFor('posts').set('currentPost', model);
        },

        shortcuts: {
            'enter, o': 'openEditor',
            'command+backspace, ctrl+backspace': 'deletePost'
        },

        actions: {
            openEditor: function openEditor(post) {
                post = post || this.get('controller.model');

                if (!post) {
                    return;
                }

                this.transitionTo('editor.edit', post.get('id'));
            },

            deletePost: function deletePost() {
                this.send('openModal', 'delete-post', this.get('controller.model'));
            }
        }
    });

    exports['default'] = PostsPostRoute;

});
define('ghost/routes/reset', ['exports', 'ember', 'simple-auth/configuration', 'ghost/mixins/style-body'], function (exports, Ember, Configuration, styleBody) {

    'use strict';

    exports['default'] = Ember['default'].Route.extend(styleBody['default'], {
        classNames: ['ghost-reset'],

        notifications: Ember['default'].inject.service(),

        beforeModel: function beforeModel() {
            if (this.get('session').isAuthenticated) {
                this.get('notifications').showAlert('You can\'t reset your password while you\'re signed in.', { type: 'warn', delayed: true });
                this.transitionTo(Configuration['default'].routeAfterAuthentication);
            }
        },

        setupController: function setupController(controller, params) {
            controller.token = params.token;
        },

        // Clear out any sensitive information
        deactivate: function deactivate() {
            this._super();
            this.controller.clearData();
        }
    });

});
define('ghost/routes/settings/code-injection', ['exports', 'ghost/routes/authenticated', 'ghost/mixins/current-user-settings', 'ghost/mixins/style-body'], function (exports, AuthenticatedRoute, CurrentUserSettings, styleBody) {

    'use strict';

    exports['default'] = AuthenticatedRoute['default'].extend(styleBody['default'], CurrentUserSettings['default'], {
        titleToken: 'Settings - Code Injection',
        classNames: ['settings-view-code'],

        beforeModel: function beforeModel(transition) {
            this._super(transition);
            return this.get('session.user').then(this.transitionAuthor()).then(this.transitionEditor());
        },

        model: function model() {
            return this.store.find('setting', { type: 'blog,theme' }).then(function (records) {
                return records.get('firstObject');
            });
        },

        actions: {
            save: function save() {
                this.get('controller').send('save');
            }
        }
    });

});
define('ghost/routes/settings/general', ['exports', 'ghost/routes/authenticated', 'ghost/mixins/current-user-settings', 'ghost/mixins/style-body'], function (exports, AuthenticatedRoute, CurrentUserSettings, styleBody) {

    'use strict';

    exports['default'] = AuthenticatedRoute['default'].extend(styleBody['default'], CurrentUserSettings['default'], {
        titleToken: 'Settings - General',

        classNames: ['settings-view-general'],

        beforeModel: function beforeModel(transition) {
            this._super(transition);
            return this.get('session.user').then(this.transitionAuthor()).then(this.transitionEditor());
        },

        model: function model() {
            return this.store.find('setting', { type: 'blog,theme,private' }).then(function (records) {
                return records.get('firstObject');
            });
        },

        actions: {
            save: function save() {
                this.get('controller').send('save');
            }
        }
    });

});
define('ghost/routes/settings/labs', ['exports', 'ghost/routes/authenticated', 'ghost/mixins/style-body', 'ghost/mixins/current-user-settings'], function (exports, AuthenticatedRoute, styleBody, CurrentUserSettings) {

    'use strict';

    exports['default'] = AuthenticatedRoute['default'].extend(styleBody['default'], CurrentUserSettings['default'], {
        titleToken: 'Settings - Labs',

        classNames: ['settings'],

        beforeModel: function beforeModel(transition) {
            this._super(transition);
            return this.get('session.user').then(this.transitionAuthor()).then(this.transitionEditor());
        },

        model: function model() {
            return this.store.find('setting', { type: 'blog,theme' }).then(function (records) {
                return records.get('firstObject');
            });
        }
    });

});
define('ghost/routes/settings/navigation', ['exports', 'ghost/routes/authenticated', 'ghost/mixins/current-user-settings', 'ghost/mixins/style-body'], function (exports, AuthenticatedRoute, CurrentUserSettings, styleBody) {

    'use strict';

    var NavigationRoute = AuthenticatedRoute['default'].extend(styleBody['default'], CurrentUserSettings['default'], {
        titleToken: 'Settings - Navigation',

        classNames: ['settings-view-navigation'],

        beforeModel: function beforeModel(transition) {
            this._super(transition);
            return this.get('session.user').then(this.transitionAuthor());
        },

        model: function model() {
            return this.store.find('setting', { type: 'blog,theme' }).then(function (records) {
                return records.get('firstObject');
            });
        },

        actions: {
            save: function save() {
                // since shortcuts are run on the route, we have to signal to the components
                // on the page that we're about to save.
                $('.page-actions .btn-blue').focus();

                this.get('controller').send('save');
            }
        }
    });

    exports['default'] = NavigationRoute;

});
define('ghost/routes/settings/tags', ['exports', 'ghost/routes/authenticated', 'ghost/mixins/current-user-settings', 'ghost/mixins/pagination-route'], function (exports, AuthenticatedRoute, CurrentUserSettings, PaginationRouteMixin) {

    'use strict';

    var TagsRoute, paginationSettings;

    paginationSettings = {
        page: 1,
        include: 'post_count',
        limit: 15
    };

    TagsRoute = AuthenticatedRoute['default'].extend(CurrentUserSettings['default'], PaginationRouteMixin['default'], {
        titleToken: 'Settings - Tags',

        beforeModel: function beforeModel(transition) {
            this._super(transition);
            return this.get('session.user').then(this.transitionAuthor());
        },

        model: function model() {
            this.store.unloadAll('tag');

            return this.store.filter('tag', paginationSettings, function (tag) {
                return !tag.get('isNew');
            });
        },

        setupController: function setupController(controller, model) {
            this._super(controller, model);
            this.setupPagination(paginationSettings);
        },

        renderTemplate: function renderTemplate(controller, model) {
            this._super(controller, model);
            this.render('settings/tags/settings-menu', {
                into: 'application',
                outlet: 'settings-menu'
            });
        },

        deactivate: function deactivate() {
            this.controller.send('resetPagination');
        }
    });

    exports['default'] = TagsRoute;

});
define('ghost/routes/setup', ['exports', 'ember', 'ic-ajax', 'simple-auth/configuration', 'ghost/mixins/style-body'], function (exports, Ember, ic_ajax, Configuration, styleBody) {

    'use strict';

    exports['default'] = Ember['default'].Route.extend(styleBody['default'], {
        titleToken: 'Setup',

        classNames: ['ghost-setup'],

        ghostPaths: Ember['default'].inject.service('ghost-paths'),

        // use the beforeModel hook to check to see whether or not setup has been
        // previously completed.  If it has, stop the transition into the setup page.
        beforeModel: function beforeModel() {
            var self = this;

            // If user is logged in, setup has already been completed.
            if (this.get('session').isAuthenticated) {
                this.transitionTo(Configuration['default'].routeAfterAuthentication);
                return;
            }

            // If user is not logged in, check the state of the setup process via the API
            return ic_ajax.request(this.get('ghostPaths.url').api('authentication/setup'), {
                type: 'GET'
            }).then(function (result) {
                var setup = result.setup[0].status;

                if (setup) {
                    return self.transitionTo('signin');
                }
            });
        },
        deactivate: function deactivate() {
            this._super();
            this.controllerFor('setup/two').set('password', '');
        }
    });

});
define('ghost/routes/setup/index', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    var SetupRoute = Ember['default'].Route.extend({
        beforeModel: function beforeModel() {
            this.transitionTo('setup.one');
        }
    });

    exports['default'] = SetupRoute;

});
define('ghost/routes/setup/one', ['exports', 'ember', 'ic-ajax'], function (exports, Ember, ic_ajax) {

    'use strict';

    var DownloadCountPoller = Ember['default'].Object.extend({
        url: null,
        count: '',
        runId: null,

        init: function init() {
            this.downloadCounter();
            this.poll();
        },

        poll: function poll() {
            var interval = 2000,
                runId;

            runId = Ember['default'].run.later(this, function () {
                this.downloadCounter();
                this.poll();
            }, interval);

            this.set('runId', runId);
        },

        downloadCounter: function downloadCounter() {
            var self = this;

            ic_ajax.request(this.get('url')).then(function (data) {
                var count = data.count.toString(),
                    pattern = /(-?\d+)(\d{3})/;

                while (pattern.test(count)) {
                    count = count.replace(pattern, '$1,$2');
                }

                self.set('count', count);
            })['catch'](function () {
                self.set('count', '');
            });
        }
    });

    exports['default'] = Ember['default'].Route.extend({
        ghostPaths: Ember['default'].inject.service('ghost-paths'),

        model: function model() {
            return DownloadCountPoller.create({ url: this.get('ghostPaths.count') });
        },

        resetController: function resetController(controller, isExiting) {
            if (isExiting) {
                Ember['default'].run.cancel(controller.get('model.runId'));
                controller.set('model', null);
            }
        }
    });

});
define('ghost/routes/setup/three', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    exports['default'] = Ember['default'].Route.extend({
        beforeModel: function beforeModel() {
            if (!this.controllerFor('setup.two').get('blogCreated')) {
                this.transitionTo('setup.two');
            }
        }
    });

});
define('ghost/routes/signin', ['exports', 'ember', 'simple-auth/configuration', 'ghost/mixins/style-body', 'ember-data'], function (exports, Ember, Configuration, styleBody, DS) {

    'use strict';

    var SigninRoute = Ember['default'].Route.extend(styleBody['default'], {
        titleToken: 'Sign In',

        classNames: ['ghost-login'],

        beforeModel: function beforeModel() {
            if (this.get('session').isAuthenticated) {
                this.transitionTo(Configuration['default'].routeAfterAuthentication);
            }
        },

        model: function model() {
            return Ember['default'].Object.create({
                identification: '',
                password: '',
                errors: DS['default'].Errors.create()
            });
        },

        // the deactivate hook is called after a route has been exited.
        deactivate: function deactivate() {
            this._super();

            var controller = this.controllerFor('signin');

            // clear the properties that hold the credentials when we're no longer on the signin screen
            controller.set('model.identification', '');
            controller.set('model.password', '');
        }
    });

    exports['default'] = SigninRoute;

});
define('ghost/routes/signout', ['exports', 'ember', 'ghost/routes/authenticated', 'ghost/mixins/style-body'], function (exports, Ember, AuthenticatedRoute, styleBody) {

    'use strict';

    exports['default'] = AuthenticatedRoute['default'].extend(styleBody['default'], {
        titleToken: 'Sign Out',

        classNames: ['ghost-signout'],

        notifications: Ember['default'].inject.service(),

        afterModel: function afterModel(model, transition) {
            this.get('notifications').closeAll();
            if (Ember['default'].canInvoke(transition, 'send')) {
                transition.send('invalidateSession');
                transition.abort();
            } else {
                this.send('invalidateSession');
            }
        }
    });

});
define('ghost/routes/signup', ['exports', 'ember', 'ember-data', 'ic-ajax', 'simple-auth/configuration', 'ghost/mixins/style-body'], function (exports, Ember, DS, ic_ajax, Configuration, styleBody) {

    'use strict';

    exports['default'] = Ember['default'].Route.extend(styleBody['default'], {
        classNames: ['ghost-signup'],

        ghostPaths: Ember['default'].inject.service('ghost-paths'),
        notifications: Ember['default'].inject.service(),

        beforeModel: function beforeModel() {
            if (this.get('session').isAuthenticated) {
                this.get('notifications').showAlert('You need to sign out to register as a new user.', { type: 'warn', delayed: true });
                this.transitionTo(Configuration['default'].routeAfterAuthentication);
            }
        },

        model: function model(params) {
            var self = this,
                tokenText,
                email,
                model = Ember['default'].Object.create(),
                re = /^(?:[A-Za-z0-9_\-]{4})*(?:[A-Za-z0-9_\-]{2}|[A-Za-z0-9_\-]{3})?$/;

            return new Ember['default'].RSVP.Promise(function (resolve) {
                if (!re.test(params.token)) {
                    self.get('notifications').showAlert('Invalid token.', { type: 'error', delayed: true });

                    return resolve(self.transitionTo('signin'));
                }

                tokenText = atob(params.token);
                email = tokenText.split('|')[1];

                model.set('email', email);
                model.set('token', params.token);
                model.set('errors', DS['default'].Errors.create());

                return ic_ajax.request({
                    url: self.get('ghostPaths.url').api('authentication', 'invitation'),
                    type: 'GET',
                    dataType: 'json',
                    data: {
                        email: email
                    }
                }).then(function (response) {
                    if (response && response.invitation && response.invitation[0].valid === false) {
                        self.get('notifications').showAlert('The invitation does not exist or is no longer valid.', { type: 'warn', delayed: true });

                        return resolve(self.transitionTo('signin'));
                    }

                    resolve(model);
                })['catch'](function () {
                    resolve(model);
                });
            });
        },

        deactivate: function deactivate() {
            this._super();

            // clear the properties that hold the sensitive data from the controller
            this.controllerFor('signup').setProperties({ email: '', password: '', token: '' });
        }
    });

});
define('ghost/routes/team/index', ['exports', 'ghost/routes/authenticated', 'ghost/mixins/current-user-settings', 'ghost/mixins/pagination-route', 'ghost/mixins/style-body'], function (exports, AuthenticatedRoute, CurrentUserSettings, PaginationRouteMixin, styleBody) {

    'use strict';

    var paginationSettings;

    paginationSettings = {
        page: 1,
        limit: 20,
        status: 'active'
    };

    exports['default'] = AuthenticatedRoute['default'].extend(styleBody['default'], CurrentUserSettings['default'], PaginationRouteMixin['default'], {
        titleToken: 'Team',

        classNames: ['view-team'],

        setupController: function setupController(controller, model) {
            this._super(controller, model);
            this.setupPagination(paginationSettings);
        },

        beforeModel: function beforeModel(transition) {
            this._super(transition);
        },

        model: function model() {
            var self = this;

            return self.store.find('user', { limit: 'all', status: 'invited' }).then(function () {
                return self.store.filter('user', paginationSettings, function () {
                    return true;
                });
            });
        },

        actions: {
            reload: function reload() {
                this.refresh();
            }
        }
    });

});
define('ghost/routes/team/user', ['exports', 'ghost/routes/authenticated', 'ghost/mixins/current-user-settings', 'ghost/mixins/style-body'], function (exports, AuthenticatedRoute, CurrentUserSettings, styleBody) {

    'use strict';

    var TeamUserRoute = AuthenticatedRoute['default'].extend(styleBody['default'], CurrentUserSettings['default'], {
        titleToken: 'Team - User',

        classNames: ['team-view-user'],

        model: function model(params) {
            var self = this;
            // TODO: Make custom user adapter that uses /api/users/:slug endpoint
            // return this.store.find('user', { slug: params.slug });

            // Instead, get all the users and then find by slug
            return this.store.find('user').then(function (result) {
                var user = result.findBy('slug', params.slug);

                if (!user) {
                    return self.transitionTo('error404', 'team/' + params.slug);
                }

                return user;
            });
        },

        afterModel: function afterModel(user) {
            var self = this;
            return this.get('session.user').then(function (currentUser) {
                var isOwnProfile = user.get('id') === currentUser.get('id'),
                    isAuthor = currentUser.get('isAuthor'),
                    isEditor = currentUser.get('isEditor');
                if (isAuthor && !isOwnProfile) {
                    self.transitionTo('team.user', currentUser);
                } else if (isEditor && !isOwnProfile && !user.get('isAuthor')) {
                    self.transitionTo('team');
                }
            });
        },

        deactivate: function deactivate() {
            var model = this.modelFor('team.user');

            // we want to revert any unsaved changes on exit
            if (model && model.get('isDirty')) {
                model.rollback();
            }

            model.get('errors').clear();

            this._super();
        },

        actions: {
            didTransition: function didTransition() {
                this.modelFor('team.user').get('errors').clear();
            },

            save: function save() {
                this.get('controller').send('save');
            }
        }
    });

    exports['default'] = TeamUserRoute;

});
define('ghost/serializers/application', ['exports', 'ember', 'ember-data'], function (exports, Ember, DS) {

    'use strict';

    var ApplicationSerializer = DS['default'].RESTSerializer.extend({
        serializeIntoHash: function serializeIntoHash(hash, type, record, options) {
            // Our API expects an id on the posted object
            options = options || {};
            options.includeId = true;

            // We have a plural root in the API
            var root = Ember['default'].String.pluralize(type.modelName),
                data = this.serialize(record, options);

            // Don't ever pass uuid's
            delete data.uuid;

            hash[root] = [data];
        }
    });

    exports['default'] = ApplicationSerializer;

});
define('ghost/serializers/post', ['exports', 'ember', 'ember-data', 'ghost/serializers/application'], function (exports, Ember, DS, ApplicationSerializer) {

    'use strict';

    var PostSerializer = ApplicationSerializer['default'].extend(DS['default'].EmbeddedRecordsMixin, {
        // settings for the EmbeddedRecordsMixin.
        attrs: {
            tags: { embedded: 'always' }
        },

        normalize: function normalize(type, hash) {
            // this is to enable us to still access the raw author_id
            // without requiring an extra get request (since it is an
            // async relationship).
            hash.author_id = hash.author;

            return this._super(type, hash);
        },

        extractSingle: function extractSingle(store, primaryType, payload) {
            var root = this.keyForAttribute(primaryType.modelName),
                pluralizedRoot = Ember['default'].String.pluralize(primaryType.modelName);

            // make payload { post: { title: '', tags: [obj, obj], etc. } }.
            // this allows ember-data to pull the embedded tags out again,
            // in the function `updatePayloadWithEmbeddedHasMany` of the
            // EmbeddedRecordsMixin (line: `if (!partial[attribute])`):
            // https://github.com/emberjs/data/blob/master/packages/activemodel-adapter/lib/system/embedded_records_mixin.js#L499
            payload[root] = payload[pluralizedRoot][0];
            delete payload[pluralizedRoot];

            return this._super.apply(this, arguments);
        },

        serializeIntoHash: function serializeIntoHash(hash, type, record, options) {
            options = options || {};
            options.includeId = true;

            // We have a plural root in the API
            var root = Ember['default'].String.pluralize(type.modelName),
                data = this.serialize(record, options);

            // Properties that exist on the model but we don't want sent in the payload

            delete data.uuid;
            delete data.html;
            // Inserted locally as a convenience.
            delete data.author_id;
            // Read-only virtual property.
            delete data.url;

            hash[root] = [data];
        }
    });

    exports['default'] = PostSerializer;

});
define('ghost/serializers/setting', ['exports', 'ember', 'ghost/serializers/application'], function (exports, Ember, ApplicationSerializer) {

    'use strict';

    var SettingSerializer = ApplicationSerializer['default'].extend({
        serializeIntoHash: function serializeIntoHash(hash, type, record, options) {
            // Settings API does not want ids
            options = options || {};
            options.includeId = false;

            var root = Ember['default'].String.pluralize(type.modelName),
                data = this.serialize(record, options),
                payload = [];

            delete data.id;

            Object.keys(data).forEach(function (k) {
                payload.push({ key: k, value: data[k] });
            });

            hash[root] = payload;
        },

        extractArray: function extractArray(store, type, _payload) {
            var payload = { id: '0' };

            _payload.settings.forEach(function (setting) {
                payload[setting.key] = setting.value;
            });

            payload = this.normalize(type, payload);

            return [payload];
        },

        extractSingle: function extractSingle(store, type, payload) {
            return this.extractArray(store, type, payload).pop();
        }
    });

    exports['default'] = SettingSerializer;

});
define('ghost/serializers/tag', ['exports', 'ember', 'ghost/serializers/application'], function (exports, Ember, ApplicationSerializer) {

    'use strict';

    var TagSerializer = ApplicationSerializer['default'].extend({
        serializeIntoHash: function serializeIntoHash(hash, type, record, options) {
            options = options || {};
            options.includeId = true;

            var root = Ember['default'].String.pluralize(type.modelName),
                data = this.serialize(record, options);

            // Properties that exist on the model but we don't want sent in the payload

            delete data.uuid;
            delete data.post_count;

            hash[root] = [data];
        }
    });

    exports['default'] = TagSerializer;

});
define('ghost/serializers/user', ['exports', 'ember', 'ember-data', 'ghost/serializers/application'], function (exports, Ember, DS, ApplicationSerializer) {

    'use strict';

    var UserSerializer = ApplicationSerializer['default'].extend(DS['default'].EmbeddedRecordsMixin, {
        attrs: {
            roles: { embedded: 'always' }
        },

        extractSingle: function extractSingle(store, primaryType, payload) {
            var root = this.keyForAttribute(primaryType.modelName),
                pluralizedRoot = Ember['default'].String.pluralize(primaryType.modelName);

            payload[root] = payload[pluralizedRoot][0];
            delete payload[pluralizedRoot];

            return this._super.apply(this, arguments);
        }
    });

    exports['default'] = UserSerializer;

});
define('ghost/services/config', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    function isNumeric(num) {
        return !isNaN(num);
    }

    function _mapType(val) {
        if (val === '') {
            return null;
        } else if (val === 'true') {
            return true;
        } else if (val === 'false') {
            return false;
        } else if (isNumeric(val)) {
            return +val;
        } else if (val.indexOf('{') === 0) {
            try {
                return JSON.parse(val);
            } catch (e) {
                /*jshint unused:false */
                return val;
            }
        } else {
            return val;
        }
    }

    exports['default'] = Ember['default'].Service.extend(Ember['default']._ProxyMixin, {
        content: Ember['default'].computed(function () {
            var metaConfigTags = Ember['default'].$('meta[name^="env-"]'),
                config = {};

            metaConfigTags.each(function (i, el) {
                var key = el.name,
                    value = el.content,
                    propertyName = key.substring(4);

                config[propertyName] = _mapType(value);
            });

            return config;
        })
    });

});
define('ghost/services/dropdown', ['exports', 'ember', 'ghost/mixins/body-event-listener'], function (exports, Ember, BodyEventListener) {

    'use strict';

    exports['default'] = Ember['default'].Service.extend(Ember['default'].Evented, BodyEventListener['default'], {
        bodyClick: function bodyClick(event) {
            /*jshint unused:false */
            this.closeDropdowns();
        },

        closeDropdowns: function closeDropdowns() {
            this.trigger('close');
        },

        toggleDropdown: function toggleDropdown(dropdownName, dropdownButton) {
            this.trigger('toggle', { target: dropdownName, button: dropdownButton });
        }
    });

});
define('ghost/services/ghost-paths', ['exports', 'ember', 'ghost/utils/ghost-paths'], function (exports, Ember, ghostPaths) {

    'use strict';

    exports['default'] = Ember['default'].Service.extend(Ember['default']._ProxyMixin, {
        content: ghostPaths['default']()
    });

});
define('ghost/services/notifications', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    exports['default'] = Ember['default'].Service.extend({
        delayedNotifications: Ember['default'].A(),
        content: Ember['default'].A(),

        alerts: Ember['default'].computed.filter('content', function (notification) {
            var status = Ember['default'].get(notification, 'status');
            return status === 'alert';
        }),

        notifications: Ember['default'].computed.filter('content', function (notification) {
            var status = Ember['default'].get(notification, 'status');
            return status === 'notification';
        }),

        handleNotification: function handleNotification(message, delayed) {
            // If this is an alert message from the server, treat it as html safe
            if (typeof message.toJSON === 'function' && message.get('status') === 'alert') {
                message.set('message', message.get('message').htmlSafe());
            }

            if (!Ember['default'].get(message, 'status')) {
                Ember['default'].set(message, 'status', 'notification');
            }

            if (!delayed) {
                this.get('content').pushObject(message);
            } else {
                this.get('delayedNotifications').pushObject(message);
            }
        },

        showAlert: function showAlert(message, options) {
            options = options || {};

            this.handleNotification({
                message: message,
                status: 'alert',
                type: options.type
            }, options.delayed);
        },

        showNotification: function showNotification(message, options) {
            options = options || {};

            if (!options.doNotCloseNotifications) {
                this.closeNotifications();
            }

            this.handleNotification({
                message: message,
                status: 'notification',
                type: options.type
            }, options.delayed);
        },

        // TODO: review whether this can be removed once no longer used by validations
        showErrors: function showErrors(errors, options) {
            options = options || {};

            if (!options.doNotCloseNotifications) {
                this.closeNotifications();
            }

            for (var i = 0; i < errors.length; i += 1) {
                this.showNotification(errors[i].message || errors[i], { type: 'error', doNotCloseNotifications: true });
            }
        },

        showAPIError: function showAPIError(resp, options) {
            options = options || {};
            options.type = options.type || 'error';

            if (!options.doNotCloseNotifications) {
                this.closeNotifications();
            }

            options.defaultErrorText = options.defaultErrorText || 'There was a problem on the server, please try again.';

            if (resp && resp.jqXHR && resp.jqXHR.responseJSON && resp.jqXHR.responseJSON.error) {
                this.showAlert(resp.jqXHR.responseJSON.error, options);
            } else if (resp && resp.jqXHR && resp.jqXHR.responseJSON && resp.jqXHR.responseJSON.errors) {
                this.showErrors(resp.jqXHR.responseJSON.errors, options);
            } else if (resp && resp.jqXHR && resp.jqXHR.responseJSON && resp.jqXHR.responseJSON.message) {
                this.showAlert(resp.jqXHR.responseJSON.message, options);
            } else {
                this.showAlert(options.defaultErrorText, { type: options.type, doNotCloseNotifications: true });
            }
        },

        displayDelayed: function displayDelayed() {
            var self = this;

            self.delayedNotifications.forEach(function (message) {
                self.get('content').pushObject(message);
            });
            self.delayedNotifications = [];
        },

        closeNotification: function closeNotification(notification) {
            var content = this.get('content');

            if (typeof notification.toJSON === 'function') {
                notification.deleteRecord();
                notification.save()['finally'](function () {
                    content.removeObject(notification);
                });
            } else {
                content.removeObject(notification);
            }
        },

        closeNotifications: function closeNotifications() {
            this.set('content', this.get('content').rejectBy('status', 'notification'));
        },

        closeAll: function closeAll() {
            this.get('content').clear();
        }
    });

});
define('ghost/services/resize', ['exports', 'ember-resize/services/resize'], function (exports, resize) {

	'use strict';



	exports.default = resize.default;

});
define('ghost/templates/-contributors', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 90,
            "column": 10
          }
        },
        "moduleName": "ghost/templates/-contributors.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createElement("article");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("a");
        dom.setAttribute(el2,"href","https://github.com/ErisDS");
        dom.setAttribute(el2,"title","ErisDS");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("img");
        dom.setAttribute(el3,"alt","ErisDS");
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createElement("article");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("a");
        dom.setAttribute(el2,"href","https://github.com/JohnONolan");
        dom.setAttribute(el2,"title","JohnONolan");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("img");
        dom.setAttribute(el3,"alt","JohnONolan");
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createElement("article");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("a");
        dom.setAttribute(el2,"href","https://github.com/kevinansfield");
        dom.setAttribute(el2,"title","kevinansfield");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("img");
        dom.setAttribute(el3,"alt","kevinansfield");
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createElement("article");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("a");
        dom.setAttribute(el2,"href","https://github.com/cobbspur");
        dom.setAttribute(el2,"title","cobbspur");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("img");
        dom.setAttribute(el3,"alt","cobbspur");
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createElement("article");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("a");
        dom.setAttribute(el2,"href","https://github.com/acburdine");
        dom.setAttribute(el2,"title","acburdine");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("img");
        dom.setAttribute(el3,"alt","acburdine");
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createElement("article");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("a");
        dom.setAttribute(el2,"href","https://github.com/jaswilli");
        dom.setAttribute(el2,"title","jaswilli");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("img");
        dom.setAttribute(el3,"alt","jaswilli");
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createElement("article");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("a");
        dom.setAttribute(el2,"href","https://github.com/halfdan");
        dom.setAttribute(el2,"title","halfdan");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("img");
        dom.setAttribute(el3,"alt","halfdan");
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createElement("article");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("a");
        dom.setAttribute(el2,"href","https://github.com/sebgie");
        dom.setAttribute(el2,"title","sebgie");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("img");
        dom.setAttribute(el3,"alt","sebgie");
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createElement("article");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("a");
        dom.setAttribute(el2,"href","https://github.com/jomahoney");
        dom.setAttribute(el2,"title","jomahoney");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("img");
        dom.setAttribute(el3,"alt","jomahoney");
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createElement("article");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("a");
        dom.setAttribute(el2,"href","https://github.com/novaugust");
        dom.setAttribute(el2,"title","novaugust");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("img");
        dom.setAttribute(el3,"alt","novaugust");
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createElement("article");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("a");
        dom.setAttribute(el2,"href","https://github.com/kowsheek");
        dom.setAttribute(el2,"title","kowsheek");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("img");
        dom.setAttribute(el3,"alt","kowsheek");
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createElement("article");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("a");
        dom.setAttribute(el2,"href","https://github.com/Remchi");
        dom.setAttribute(el2,"title","Remchi");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("img");
        dom.setAttribute(el3,"alt","Remchi");
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createElement("article");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("a");
        dom.setAttribute(el2,"href","https://github.com/rwjblue");
        dom.setAttribute(el2,"title","rwjblue");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("img");
        dom.setAttribute(el3,"alt","rwjblue");
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createElement("article");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("a");
        dom.setAttribute(el2,"href","https://github.com/hex337");
        dom.setAttribute(el2,"title","hex337");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("img");
        dom.setAttribute(el3,"alt","hex337");
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createElement("article");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("a");
        dom.setAttribute(el2,"href","https://github.com/lukaszklis");
        dom.setAttribute(el2,"title","lukaszklis");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("img");
        dom.setAttribute(el3,"alt","lukaszklis");
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createElement("article");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("a");
        dom.setAttribute(el2,"href","https://github.com/josephwegner");
        dom.setAttribute(el2,"title","josephwegner");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("img");
        dom.setAttribute(el3,"alt","josephwegner");
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createElement("article");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("a");
        dom.setAttribute(el2,"href","https://github.com/augbog");
        dom.setAttribute(el2,"title","augbog");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("img");
        dom.setAttribute(el3,"alt","augbog");
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createElement("article");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("a");
        dom.setAttribute(el2,"href","https://github.com/Rovak");
        dom.setAttribute(el2,"title","Rovak");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("img");
        dom.setAttribute(el3,"alt","Rovak");
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var element0 = dom.childAt(fragment, [0, 1, 1]);
        var element1 = dom.childAt(fragment, [2, 1, 1]);
        var element2 = dom.childAt(fragment, [4, 1, 1]);
        var element3 = dom.childAt(fragment, [6, 1, 1]);
        var element4 = dom.childAt(fragment, [8, 1, 1]);
        var element5 = dom.childAt(fragment, [10, 1, 1]);
        var element6 = dom.childAt(fragment, [12, 1, 1]);
        var element7 = dom.childAt(fragment, [14, 1, 1]);
        var element8 = dom.childAt(fragment, [16, 1, 1]);
        var element9 = dom.childAt(fragment, [18, 1, 1]);
        var element10 = dom.childAt(fragment, [20, 1, 1]);
        var element11 = dom.childAt(fragment, [22, 1, 1]);
        var element12 = dom.childAt(fragment, [24, 1, 1]);
        var element13 = dom.childAt(fragment, [26, 1, 1]);
        var element14 = dom.childAt(fragment, [28, 1, 1]);
        var element15 = dom.childAt(fragment, [30, 1, 1]);
        var element16 = dom.childAt(fragment, [32, 1, 1]);
        var element17 = dom.childAt(fragment, [34, 1, 1]);
        var morphs = new Array(18);
        morphs[0] = dom.createAttrMorph(element0, 'src');
        morphs[1] = dom.createAttrMorph(element1, 'src');
        morphs[2] = dom.createAttrMorph(element2, 'src');
        morphs[3] = dom.createAttrMorph(element3, 'src');
        morphs[4] = dom.createAttrMorph(element4, 'src');
        morphs[5] = dom.createAttrMorph(element5, 'src');
        morphs[6] = dom.createAttrMorph(element6, 'src');
        morphs[7] = dom.createAttrMorph(element7, 'src');
        morphs[8] = dom.createAttrMorph(element8, 'src');
        morphs[9] = dom.createAttrMorph(element9, 'src');
        morphs[10] = dom.createAttrMorph(element10, 'src');
        morphs[11] = dom.createAttrMorph(element11, 'src');
        morphs[12] = dom.createAttrMorph(element12, 'src');
        morphs[13] = dom.createAttrMorph(element13, 'src');
        morphs[14] = dom.createAttrMorph(element14, 'src');
        morphs[15] = dom.createAttrMorph(element15, 'src');
        morphs[16] = dom.createAttrMorph(element16, 'src');
        morphs[17] = dom.createAttrMorph(element17, 'src');
        return morphs;
      },
      statements: [
        ["attribute","src",["concat",[["subexpr","gh-path",["admin","/img/contributors"],[]],"/ErisDS"]]],
        ["attribute","src",["concat",[["subexpr","gh-path",["admin","/img/contributors"],[]],"/JohnONolan"]]],
        ["attribute","src",["concat",[["subexpr","gh-path",["admin","/img/contributors"],[]],"/kevinansfield"]]],
        ["attribute","src",["concat",[["subexpr","gh-path",["admin","/img/contributors"],[]],"/cobbspur"]]],
        ["attribute","src",["concat",[["subexpr","gh-path",["admin","/img/contributors"],[]],"/acburdine"]]],
        ["attribute","src",["concat",[["subexpr","gh-path",["admin","/img/contributors"],[]],"/jaswilli"]]],
        ["attribute","src",["concat",[["subexpr","gh-path",["admin","/img/contributors"],[]],"/halfdan"]]],
        ["attribute","src",["concat",[["subexpr","gh-path",["admin","/img/contributors"],[]],"/sebgie"]]],
        ["attribute","src",["concat",[["subexpr","gh-path",["admin","/img/contributors"],[]],"/jomahoney"]]],
        ["attribute","src",["concat",[["subexpr","gh-path",["admin","/img/contributors"],[]],"/novaugust"]]],
        ["attribute","src",["concat",[["subexpr","gh-path",["admin","/img/contributors"],[]],"/kowsheek"]]],
        ["attribute","src",["concat",[["subexpr","gh-path",["admin","/img/contributors"],[]],"/Remchi"]]],
        ["attribute","src",["concat",[["subexpr","gh-path",["admin","/img/contributors"],[]],"/rwjblue"]]],
        ["attribute","src",["concat",[["subexpr","gh-path",["admin","/img/contributors"],[]],"/hex337"]]],
        ["attribute","src",["concat",[["subexpr","gh-path",["admin","/img/contributors"],[]],"/lukaszklis"]]],
        ["attribute","src",["concat",[["subexpr","gh-path",["admin","/img/contributors"],[]],"/josephwegner"]]],
        ["attribute","src",["concat",[["subexpr","gh-path",["admin","/img/contributors"],[]],"/augbog"]]],
        ["attribute","src",["concat",[["subexpr","gh-path",["admin","/img/contributors"],[]],"/Rovak"]]]
      ],
      locals: [],
      templates: []
    };
  }()));

});
define('ghost/templates/-import-errors', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      var child0 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 3,
                "column": 0
              },
              "end": {
                "line": 5,
                "column": 0
              }
            },
            "moduleName": "ghost/templates/-import-errors.hbs"
          },
          arity: 1,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createTextNode("    ");
            dom.appendChild(el0, el1);
            var el1 = dom.createElement("tr");
            var el2 = dom.createElement("td");
            var el3 = dom.createComment("");
            dom.appendChild(el2, el3);
            dom.appendChild(el1, el2);
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
            var morphs = new Array(1);
            morphs[0] = dom.createMorphAt(dom.childAt(fragment, [1, 0]),0,0);
            return morphs;
          },
          statements: [
            ["content","error.message"]
          ],
          locals: ["error"],
          templates: []
        };
      }());
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 1,
              "column": 0
            },
            "end": {
              "line": 7,
              "column": 0
            }
          },
          "moduleName": "ghost/templates/-import-errors.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createElement("table");
          dom.setAttribute(el1,"class","table");
          var el2 = dom.createTextNode("\n");
          dom.appendChild(el1, el2);
          var el2 = dom.createComment("");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(1);
          morphs[0] = dom.createMorphAt(dom.childAt(fragment, [0]),1,1);
          return morphs;
        },
        statements: [
          ["block","each",[["get","importErrors"]],[],0,null]
        ],
        locals: [],
        templates: [child0]
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 8,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/-import-errors.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(1);
        morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
        dom.insertBoundary(fragment, 0);
        dom.insertBoundary(fragment, null);
        return morphs;
      },
      statements: [
        ["block","if",[["get","importErrors"]],[],0,null]
      ],
      locals: [],
      templates: [child0]
    };
  }()));

});
define('ghost/templates/-user-list-item', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      var child0 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 14,
                "column": 8
              },
              "end": {
                "line": 16,
                "column": 8
              }
            },
            "moduleName": "ghost/templates/-user-list-item.hbs"
          },
          arity: 1,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createTextNode("            ");
            dom.appendChild(el0, el1);
            var el1 = dom.createElement("span");
            var el2 = dom.createComment("");
            dom.appendChild(el1, el2);
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
            var element0 = dom.childAt(fragment, [1]);
            var morphs = new Array(2);
            morphs[0] = dom.createAttrMorph(element0, 'class');
            morphs[1] = dom.createMorphAt(element0,0,0);
            return morphs;
          },
          statements: [
            ["attribute","class",["concat",["role-label ",["get","role.lowerCaseName"]]]],
            ["content","role.name"]
          ],
          locals: ["role"],
          templates: []
        };
      }());
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 13,
              "column": 4
            },
            "end": {
              "line": 17,
              "column": 4
            }
          },
          "moduleName": "ghost/templates/-user-list-item.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(1);
          morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
          dom.insertBoundary(fragment, 0);
          dom.insertBoundary(fragment, null);
          return morphs;
        },
        statements: [
          ["block","each",[["get","user.roles"]],[],0,null]
        ],
        locals: [],
        templates: [child0]
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 19,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/-user-list-item.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createElement("span");
        dom.setAttribute(el1,"class","user-list-item-figure");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("span");
        dom.setAttribute(el2,"class","hidden");
        var el3 = dom.createTextNode("Photo of ");
        dom.appendChild(el2, el3);
        var el3 = dom.createComment("");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createElement("div");
        dom.setAttribute(el1,"class","user-list-item-body");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("span");
        dom.setAttribute(el2,"class","name");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createComment("");
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("br");
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("span");
        dom.setAttribute(el2,"class","description");
        var el3 = dom.createTextNode("Last seen: ");
        dom.appendChild(el2, el3);
        var el3 = dom.createComment("");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createElement("aside");
        dom.setAttribute(el1,"class","user-list-item-aside");
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        var el2 = dom.createComment("");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var element1 = dom.childAt(fragment, [0]);
        var element2 = dom.childAt(fragment, [2]);
        var morphs = new Array(5);
        morphs[0] = dom.createAttrMorph(element1, 'style');
        morphs[1] = dom.createMorphAt(dom.childAt(element1, [1]),1,1);
        morphs[2] = dom.createMorphAt(dom.childAt(element2, [1]),1,1);
        morphs[3] = dom.createMorphAt(dom.childAt(element2, [5]),1,1);
        morphs[4] = dom.createMorphAt(dom.childAt(fragment, [4]),1,1);
        return morphs;
      },
      statements: [
        ["attribute","style",["get","component.userImageBackground"]],
        ["content","user.name"],
        ["content","user.name"],
        ["content","component.lastLogin"],
        ["block","unless",[["get","session.user.isAuthor"]],[],0,null]
      ],
      locals: [],
      templates: [child0]
    };
  }()));

});
define('ghost/templates/about', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 3,
              "column": 8
            },
            "end": {
              "line": 3,
              "column": 82
            }
          },
          "moduleName": "ghost/templates/about.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createElement("span");
          var el2 = dom.createTextNode("About Ghost");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes() { return []; },
        statements: [

        ],
        locals: [],
        templates: []
      };
    }());
    var child1 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 17,
              "column": 42
            },
            "end": {
              "line": 17,
              "column": 74
            }
          },
          "moduleName": "ghost/templates/about.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(1);
          morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
          dom.insertBoundary(fragment, 0);
          dom.insertBoundary(fragment, null);
          return morphs;
        },
        statements: [
          ["content","model.mail"]
        ],
        locals: [],
        templates: []
      };
    }());
    var child2 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 17,
              "column": 74
            },
            "end": {
              "line": 17,
              "column": 88
            }
          },
          "moduleName": "ghost/templates/about.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("Native");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes() { return []; },
        statements: [

        ],
        locals: [],
        templates: []
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 45,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/about.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createElement("section");
        dom.setAttribute(el1,"class","gh-view js-settings-content");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("header");
        dom.setAttribute(el2,"class","view-header");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createComment("");
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("section");
        dom.setAttribute(el2,"class","view-content");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("header");
        dom.setAttribute(el3,"class","gh-about-header");
        var el4 = dom.createTextNode("\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createElement("img");
        dom.setAttribute(el4,"class","gh-logo");
        dom.setAttribute(el4,"alt","Ghost");
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createComment("");
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n        ");
        dom.appendChild(el3, el4);
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("section");
        dom.setAttribute(el3,"class","gh-env-details");
        var el4 = dom.createTextNode("\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createElement("ul");
        dom.setAttribute(el4,"class","gh-env-list");
        var el5 = dom.createTextNode("\n                ");
        dom.appendChild(el4, el5);
        var el5 = dom.createElement("li");
        dom.setAttribute(el5,"class","gh-env-list-version");
        var el6 = dom.createElement("strong");
        var el7 = dom.createTextNode("Version");
        dom.appendChild(el6, el7);
        dom.appendChild(el5, el6);
        var el6 = dom.createTextNode(" ");
        dom.appendChild(el5, el6);
        var el6 = dom.createComment("");
        dom.appendChild(el5, el6);
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n                ");
        dom.appendChild(el4, el5);
        var el5 = dom.createElement("li");
        var el6 = dom.createElement("strong");
        var el7 = dom.createTextNode("Environment");
        dom.appendChild(el6, el7);
        dom.appendChild(el5, el6);
        var el6 = dom.createTextNode(" ");
        dom.appendChild(el5, el6);
        var el6 = dom.createComment("");
        dom.appendChild(el5, el6);
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n                ");
        dom.appendChild(el4, el5);
        var el5 = dom.createElement("li");
        dom.setAttribute(el5,"class","gh-env-list-database-type");
        var el6 = dom.createElement("strong");
        var el7 = dom.createTextNode("Database");
        dom.appendChild(el6, el7);
        dom.appendChild(el5, el6);
        var el6 = dom.createTextNode(" ");
        dom.appendChild(el5, el6);
        var el6 = dom.createComment("");
        dom.appendChild(el5, el6);
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n                ");
        dom.appendChild(el4, el5);
        var el5 = dom.createElement("li");
        var el6 = dom.createElement("strong");
        var el7 = dom.createTextNode("Mail");
        dom.appendChild(el6, el7);
        dom.appendChild(el5, el6);
        var el6 = dom.createTextNode(" ");
        dom.appendChild(el5, el6);
        var el6 = dom.createComment("");
        dom.appendChild(el5, el6);
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n            ");
        dom.appendChild(el4, el5);
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createElement("div");
        dom.setAttribute(el4,"class","gh-env-help");
        var el5 = dom.createTextNode("\n                ");
        dom.appendChild(el4, el5);
        var el5 = dom.createElement("a");
        dom.setAttribute(el5,"href","http://support.ghost.org");
        dom.setAttribute(el5,"class","btn btn-minor");
        dom.setAttribute(el5,"target","_blank");
        var el6 = dom.createTextNode("User Documentation");
        dom.appendChild(el5, el6);
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n                ");
        dom.appendChild(el4, el5);
        var el5 = dom.createElement("a");
        dom.setAttribute(el5,"href","https://ghost.org/slack/");
        dom.setAttribute(el5,"class","btn btn-minor");
        dom.setAttribute(el5,"target","_blank");
        var el6 = dom.createTextNode("Get Help With Ghost");
        dom.appendChild(el5, el6);
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n            ");
        dom.appendChild(el4, el5);
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n        ");
        dom.appendChild(el3, el4);
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("section");
        dom.setAttribute(el3,"class","gh-credits");
        var el4 = dom.createTextNode("\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createElement("h2");
        var el5 = dom.createTextNode("The People Who Made it Possible");
        dom.appendChild(el4, el5);
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createElement("section");
        dom.setAttribute(el4,"class","gh-contributors");
        var el5 = dom.createTextNode("\n                ");
        dom.appendChild(el4, el5);
        var el5 = dom.createComment("");
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n            ");
        dom.appendChild(el4, el5);
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createElement("p");
        var el5 = dom.createTextNode("Ghost is built by an incredible group of contributors from all over the world. Here are just a few of the people who helped create the version you’re using right now.");
        dom.appendChild(el4, el5);
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createElement("a");
        dom.setAttribute(el4,"href","https://ghost.org/about/contribute/");
        dom.setAttribute(el4,"class","btn btn-blue btn-lg");
        var el5 = dom.createTextNode("Find out how you can get involved");
        dom.appendChild(el4, el5);
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n\n        ");
        dom.appendChild(el3, el4);
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("footer");
        dom.setAttribute(el3,"class","gh-copyright-info");
        var el4 = dom.createTextNode("\n            Copyright 2013 - 2015 Ghost Foundation, released under the ");
        dom.appendChild(el3, el4);
        var el4 = dom.createElement("a");
        dom.setAttribute(el4,"href","https://github.com/TryGhost/Ghost/blob/master/LICENSE");
        var el5 = dom.createTextNode("MIT license");
        dom.appendChild(el4, el5);
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode(".\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createElement("br");
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createElement("a");
        dom.setAttribute(el4,"href","https://ghost.org/");
        var el5 = dom.createTextNode("Ghost");
        dom.appendChild(el4, el5);
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode(" is a trademark of the ");
        dom.appendChild(el3, el4);
        var el4 = dom.createElement("a");
        dom.setAttribute(el4,"href","https://ghost.org/about/");
        var el5 = dom.createTextNode("Ghost Foundation");
        dom.appendChild(el4, el5);
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode(".\n        ");
        dom.appendChild(el3, el4);
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var element0 = dom.childAt(fragment, [0]);
        var element1 = dom.childAt(element0, [3]);
        var element2 = dom.childAt(element1, [1]);
        var element3 = dom.childAt(element2, [1]);
        var element4 = dom.childAt(element1, [3, 1]);
        var morphs = new Array(8);
        morphs[0] = dom.createMorphAt(dom.childAt(element0, [1]),1,1);
        morphs[1] = dom.createAttrMorph(element3, 'src');
        morphs[2] = dom.createMorphAt(element2,3,3);
        morphs[3] = dom.createMorphAt(dom.childAt(element4, [1]),2,2);
        morphs[4] = dom.createMorphAt(dom.childAt(element4, [3]),2,2);
        morphs[5] = dom.createMorphAt(dom.childAt(element4, [5]),2,2);
        morphs[6] = dom.createMorphAt(dom.childAt(element4, [7]),2,2);
        morphs[7] = dom.createMorphAt(dom.childAt(element1, [5, 3]),1,1);
        return morphs;
      },
      statements: [
        ["block","gh-view-title",[],["openMobileMenu","openMobileMenu"],0,null],
        ["attribute","src",["concat",[["subexpr","gh-path",["admin","/img/ghost-logo.png"],[]]]]],
        ["inline","gh-notifications",[],["location","about-upgrade","notify","updateNotificationChange"]],
        ["content","model.version"],
        ["content","model.environment"],
        ["content","model.database"],
        ["block","if",[["get","model.mail"]],[],1,2],
        ["inline","partial",["contributors"],[]]
      ],
      locals: [],
      templates: [child0, child1, child2]
    };
  }()));

});
define('ghost/templates/application', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      var child0 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 2,
                "column": 4
              },
              "end": {
                "line": 2,
                "column": 59
              }
            },
            "moduleName": "ghost/templates/application.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createTextNode("Skip to main content");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes() { return []; },
          statements: [

          ],
          locals: [],
          templates: []
        };
      }());
      var child1 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 7,
                "column": 8
              },
              "end": {
                "line": 9,
                "column": 8
              }
            },
            "moduleName": "ghost/templates/application.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createTextNode("            ");
            dom.appendChild(el0, el1);
            var el1 = dom.createComment("");
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
            var morphs = new Array(1);
            morphs[0] = dom.createMorphAt(fragment,1,1,contextualElement);
            return morphs;
          },
          statements: [
            ["inline","gh-nav-menu",[],["open",["subexpr","@mut",[["get","autoNavOpen"]],[]],"toggleMaximise","toggleAutoNav","openAutoNav","openAutoNav","openModal","openModal","closeMobileMenu","closeMobileMenu"]]
          ],
          locals: [],
          templates: []
        };
      }());
      var child2 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 11,
                "column": 8
              },
              "end": {
                "line": 13,
                "column": 8
              }
            },
            "moduleName": "ghost/templates/application.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createTextNode("            ");
            dom.appendChild(el0, el1);
            var el1 = dom.createComment("");
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
            var morphs = new Array(1);
            morphs[0] = dom.createMorphAt(fragment,1,1,contextualElement);
            return morphs;
          },
          statements: [
            ["content","outlet"]
          ],
          locals: [],
          templates: []
        };
      }());
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 1,
              "column": 0
            },
            "end": {
              "line": 23,
              "column": 0
            }
          },
          "moduleName": "ghost/templates/application.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n\n    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n\n    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("div");
          var el2 = dom.createTextNode("\n");
          dom.appendChild(el1, el2);
          var el2 = dom.createComment("");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n");
          dom.appendChild(el1, el2);
          var el2 = dom.createComment("");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n\n        ");
          dom.appendChild(el1, el2);
          var el2 = dom.createComment("");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n\n        ");
          dom.appendChild(el1, el2);
          var el2 = dom.createComment("");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n\n        ");
          dom.appendChild(el1, el2);
          var el2 = dom.createComment("");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n        ");
          dom.appendChild(el1, el2);
          var el2 = dom.createComment("");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n    ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var element0 = dom.childAt(fragment, [5]);
          var morphs = new Array(9);
          morphs[0] = dom.createMorphAt(fragment,1,1,contextualElement);
          morphs[1] = dom.createMorphAt(fragment,3,3,contextualElement);
          morphs[2] = dom.createAttrMorph(element0, 'class');
          morphs[3] = dom.createMorphAt(element0,1,1);
          morphs[4] = dom.createMorphAt(element0,3,3);
          morphs[5] = dom.createMorphAt(element0,5,5);
          morphs[6] = dom.createMorphAt(element0,7,7);
          morphs[7] = dom.createMorphAt(element0,9,9);
          morphs[8] = dom.createMorphAt(element0,11,11);
          return morphs;
        },
        statements: [
          ["block","gh-skip-link",[],["anchor",".gh-main"],0,null],
          ["inline","gh-alerts",[],["notify","topNotificationChange"]],
          ["attribute","class",["concat",["gh-viewport ",["subexpr","if",[["get","autoNav"],"gh-autonav"],[]]," ",["subexpr","if",[["get","showSettingsMenu"],"settings-menu-expanded"],[]]," ",["subexpr","if",[["get","showMobileMenu"],"mobile-menu-expanded"],[]]]]],
          ["block","unless",[["get","signedOut"]],[],1,null],
          ["block","gh-main",[],["onMouseEnter","closeAutoNav","data-notification-count",["subexpr","@mut",[["get","topNotificationCount"]],[]]],2,null],
          ["content","gh-notifications"],
          ["inline","gh-content-cover",[],["onClick","closeMenus","onMouseEnter","closeAutoNav"]],
          ["inline","outlet",["modal"],[]],
          ["inline","outlet",["settings-menu"],[]]
        ],
        locals: [],
        templates: [child0, child1, child2]
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 24,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/application.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(1);
        morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
        dom.insertBoundary(fragment, 0);
        dom.insertBoundary(fragment, null);
        return morphs;
      },
      statements: [
        ["block","gh-app",[],["showSettingsMenu",["subexpr","@mut",[["get","showSettingsMenu"]],[]]],0,null]
      ],
      locals: [],
      templates: [child0]
    };
  }()));

});
define('ghost/templates/components/gh-activating-list-item', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 1,
              "column": 0
            },
            "end": {
              "line": 1,
              "column": 105
            }
          },
          "moduleName": "ghost/templates/components/gh-activating-list-item.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(2);
          morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
          morphs[1] = dom.createMorphAt(fragment,1,1,contextualElement);
          dom.insertBoundary(fragment, 0);
          dom.insertBoundary(fragment, null);
          return morphs;
        },
        statements: [
          ["content","title"],
          ["content","yield"]
        ],
        locals: [],
        templates: []
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 2,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/components/gh-activating-list-item.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(1);
        morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
        dom.insertBoundary(fragment, 0);
        return morphs;
      },
      statements: [
        ["block","link-to",[["get","route"]],["alternateActive",["subexpr","action",["setActive"],[]],"class",["subexpr","concat",[["subexpr","if",[["get","linkClasses"],["subexpr","-normalize-class",["linkClasses",["get","linkClasses"]],[]]],[]]," "],[]]],0,null]
      ],
      locals: [],
      templates: [child0]
    };
  }()));

});
define('ghost/templates/components/gh-alert', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 4,
            "column": 111
          }
        },
        "moduleName": "ghost/templates/components/gh-alert.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createElement("div");
        dom.setAttribute(el1,"class","gh-alert-content");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createComment("");
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createElement("button");
        dom.setAttribute(el1,"class","gh-alert-close icon-x");
        var el2 = dom.createElement("span");
        dom.setAttribute(el2,"class","hidden");
        var el3 = dom.createTextNode("Close");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var element0 = dom.childAt(fragment, [2]);
        var morphs = new Array(2);
        morphs[0] = dom.createMorphAt(dom.childAt(fragment, [0]),1,1);
        morphs[1] = dom.createElementMorph(element0);
        return morphs;
      },
      statements: [
        ["content","message.message"],
        ["element","action",["closeNotification"],[]]
      ],
      locals: [],
      templates: []
    };
  }()));

});
define('ghost/templates/components/gh-alerts', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 1,
              "column": 0
            },
            "end": {
              "line": 3,
              "column": 0
            }
          },
          "moduleName": "ghost/templates/components/gh-alerts.hbs"
        },
        arity: 1,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(1);
          morphs[0] = dom.createMorphAt(fragment,1,1,contextualElement);
          return morphs;
        },
        statements: [
          ["inline","gh-alert",[],["message",["subexpr","@mut",[["get","message"]],[]]]]
        ],
        locals: ["message"],
        templates: []
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 3,
            "column": 9
          }
        },
        "moduleName": "ghost/templates/components/gh-alerts.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(1);
        morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
        dom.insertBoundary(fragment, 0);
        dom.insertBoundary(fragment, null);
        return morphs;
      },
      statements: [
        ["block","each",[["get","messages"]],[],0,null]
      ],
      locals: [],
      templates: [child0]
    };
  }()));

});
define('ghost/templates/components/gh-app', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 2,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/components/gh-app.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(1);
        morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
        dom.insertBoundary(fragment, 0);
        return morphs;
      },
      statements: [
        ["content","yield"]
      ],
      locals: [],
      templates: []
    };
  }()));

});
define('ghost/templates/components/gh-blog-url', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 1,
            "column": 20
          }
        },
        "moduleName": "ghost/templates/components/gh-blog-url.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(1);
        morphs[0] = dom.createUnsafeMorphAt(fragment,0,0,contextualElement);
        dom.insertBoundary(fragment, 0);
        dom.insertBoundary(fragment, null);
        return morphs;
      },
      statements: [
        ["content","config.blogUrl"]
      ],
      locals: [],
      templates: []
    };
  }()));

});
define('ghost/templates/components/gh-content-preview-content', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 2,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/components/gh-content-preview-content.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(1);
        morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
        dom.insertBoundary(fragment, 0);
        return morphs;
      },
      statements: [
        ["content","yield"]
      ],
      locals: [],
      templates: []
    };
  }()));

});
define('ghost/templates/components/gh-content-view-container', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 2,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/components/gh-content-view-container.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(1);
        morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
        dom.insertBoundary(fragment, 0);
        return morphs;
      },
      statements: [
        ["inline","yield",[["get","this"]],[]]
      ],
      locals: [],
      templates: []
    };
  }()));

});
define('ghost/templates/components/gh-ed-preview', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 2,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/components/gh-ed-preview.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(1);
        morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
        dom.insertBoundary(fragment, 0);
        return morphs;
      },
      statements: [
        ["inline","gh-format-markdown",[["get","markdown"]],[]]
      ],
      locals: [],
      templates: []
    };
  }()));

});
define('ghost/templates/components/gh-editor-save-button', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 1,
              "column": 0
            },
            "end": {
              "line": 1,
              "column": 162
            }
          },
          "moduleName": "ghost/templates/components/gh-editor-save-button.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(1);
          morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
          dom.insertBoundary(fragment, 0);
          dom.insertBoundary(fragment, null);
          return morphs;
        },
        statements: [
          ["content","saveText"]
        ],
        locals: [],
        templates: []
      };
    }());
    var child1 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 3,
              "column": 0
            },
            "end": {
              "line": 6,
              "column": 0
            }
          },
          "moduleName": "ghost/templates/components/gh-editor-save-button.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("i");
          dom.setAttribute(el1,"class","options icon-arrow2");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("span");
          dom.setAttribute(el1,"class","sr-only");
          var el2 = dom.createTextNode("Toggle Settings Menu");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes() { return []; },
        statements: [

        ],
        locals: [],
        templates: []
      };
    }());
    var child2 = (function() {
      var child0 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 15,
                "column": 8
              },
              "end": {
                "line": 20,
                "column": 8
              }
            },
            "moduleName": "ghost/templates/components/gh-editor-save-button.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createTextNode("            ");
            dom.appendChild(el0, el1);
            var el1 = dom.createElement("li");
            dom.setAttribute(el1,"class","divider delete");
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n            ");
            dom.appendChild(el0, el1);
            var el1 = dom.createElement("li");
            dom.setAttribute(el1,"class","delete");
            var el2 = dom.createTextNode("\n                ");
            dom.appendChild(el1, el2);
            var el2 = dom.createElement("a");
            dom.setAttribute(el2,"href","#");
            var el3 = dom.createComment("");
            dom.appendChild(el2, el3);
            dom.appendChild(el1, el2);
            var el2 = dom.createTextNode("\n            ");
            dom.appendChild(el1, el2);
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
            var element0 = dom.childAt(fragment, [3, 1]);
            var morphs = new Array(2);
            morphs[0] = dom.createElementMorph(element0);
            morphs[1] = dom.createMorphAt(element0,0,0);
            return morphs;
          },
          statements: [
            ["element","action",["delete"],[]],
            ["content","deleteText"]
          ],
          locals: [],
          templates: []
        };
      }());
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 7,
              "column": 0
            },
            "end": {
              "line": 22,
              "column": 0
            }
          },
          "moduleName": "ghost/templates/components/gh-editor-save-button.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("ul");
          dom.setAttribute(el1,"class","dropdown-menu dropdown-triangle-bottom-right");
          var el2 = dom.createTextNode("\n        ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("li");
          var el3 = dom.createTextNode("\n            ");
          dom.appendChild(el2, el3);
          var el3 = dom.createElement("a");
          dom.setAttribute(el3,"href","#");
          var el4 = dom.createComment("");
          dom.appendChild(el3, el4);
          dom.appendChild(el2, el3);
          var el3 = dom.createTextNode("\n        ");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n        ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("li");
          var el3 = dom.createTextNode("\n            ");
          dom.appendChild(el2, el3);
          var el3 = dom.createElement("a");
          dom.setAttribute(el3,"href","#");
          var el4 = dom.createComment("");
          dom.appendChild(el3, el4);
          dom.appendChild(el2, el3);
          var el3 = dom.createTextNode("\n        ");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n");
          dom.appendChild(el1, el2);
          var el2 = dom.createComment("");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("    ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var element1 = dom.childAt(fragment, [1]);
          var element2 = dom.childAt(element1, [1]);
          var element3 = dom.childAt(element2, [1]);
          var element4 = dom.childAt(element1, [3]);
          var element5 = dom.childAt(element4, [1]);
          var morphs = new Array(7);
          morphs[0] = dom.createAttrMorph(element2, 'class');
          morphs[1] = dom.createElementMorph(element3);
          morphs[2] = dom.createMorphAt(element3,0,0);
          morphs[3] = dom.createAttrMorph(element4, 'class');
          morphs[4] = dom.createElementMorph(element5);
          morphs[5] = dom.createMorphAt(element5,0,0);
          morphs[6] = dom.createMorphAt(element1,5,5);
          return morphs;
        },
        statements: [
          ["attribute","class",["concat",["post-save-publish ",["subexpr","if",[["get","willPublish"],"active"],[]]]]],
          ["element","action",["setSaveType","publish"],[]],
          ["content","publishText"],
          ["attribute","class",["concat",["post-save-draft ",["subexpr","unless",[["get","willPublish"],"active"],[]]]]],
          ["element","action",["setSaveType","draft"],[]],
          ["content","draftText"],
          ["block","unless",[["get","isNew"]],[],0,null]
        ],
        locals: [],
        templates: [child0]
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 23,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/components/gh-editor-save-button.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(3);
        morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
        morphs[1] = dom.createMorphAt(fragment,2,2,contextualElement);
        morphs[2] = dom.createMorphAt(fragment,3,3,contextualElement);
        dom.insertBoundary(fragment, 0);
        dom.insertBoundary(fragment, null);
        return morphs;
      },
      statements: [
        ["block","gh-spin-button",[],["type","button","action","save","submitting",["subexpr","@mut",[["get","submitting"]],[]],"class",["subexpr","concat",["btn"," ","btn-sm"," ","js-publish-button"," ",["subexpr","if",[["get","isDangerous"],"btn-red","btn-blue"],[]]," "],[]]],0,null],
        ["block","gh-dropdown-button",[],["dropdownName","post-save-menu","class",["subexpr","concat",["btn"," ","btn-sm"," ",["subexpr","if",[["get","isDangerous"],"btn-red","btn-blue"],[]]," ",["subexpr","if",[["get","btnopen"],"active"],[]]," ","dropdown-toggle"," ","up"," "],[]]],1,null],
        ["block","gh-dropdown",[],["name","post-save-menu","closeOnClick","true","classNames","editor-options"],2,null]
      ],
      locals: [],
      templates: [child0, child1, child2]
    };
  }()));

});
define('ghost/templates/components/gh-editor', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 2,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/components/gh-editor.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(1);
        morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
        dom.insertBoundary(fragment, 0);
        return morphs;
      },
      statements: [
        ["inline","yield",[["get","this"]],[]]
      ],
      locals: [],
      templates: []
    };
  }()));

});
define('ghost/templates/components/gh-error-message', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 2,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/components/gh-error-message.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(1);
        morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
        dom.insertBoundary(fragment, 0);
        return morphs;
      },
      statements: [
        ["content","message"]
      ],
      locals: [],
      templates: []
    };
  }()));

});
define('ghost/templates/components/gh-file-upload', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 5,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/components/gh-file-upload.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createElement("input");
        dom.setAttribute(el1,"data-url","upload");
        dom.setAttribute(el1,"class","gh-input btn-block");
        dom.setAttribute(el1,"type","file");
        dom.setAttribute(el1,"name","importfile");
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createElement("button");
        dom.setAttribute(el1,"type","submit");
        dom.setAttribute(el1,"class","btn btn-green btn-block");
        dom.setAttribute(el1,"id","startupload");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createComment("");
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var element0 = dom.childAt(fragment, [0]);
        var element1 = dom.childAt(fragment, [2]);
        var morphs = new Array(4);
        morphs[0] = dom.createAttrMorph(element0, 'accept');
        morphs[1] = dom.createAttrMorph(element1, 'disabled');
        morphs[2] = dom.createElementMorph(element1);
        morphs[3] = dom.createMorphAt(element1,1,1);
        return morphs;
      },
      statements: [
        ["attribute","accept",["concat",[["get","options.acceptEncoding"]]]],
        ["attribute","disabled",["get","uploadButtonDisabled"]],
        ["element","action",["upload"],[]],
        ["content","uploadButtonText"]
      ],
      locals: [],
      templates: []
    };
  }()));

});
define('ghost/templates/components/gh-infinite-scroll-box', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 2,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/components/gh-infinite-scroll-box.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(1);
        morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
        dom.insertBoundary(fragment, 0);
        return morphs;
      },
      statements: [
        ["content","yield"]
      ],
      locals: [],
      templates: []
    };
  }()));

});
define('ghost/templates/components/gh-infinite-scroll', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 2,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/components/gh-infinite-scroll.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(1);
        morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
        dom.insertBoundary(fragment, 0);
        return morphs;
      },
      statements: [
        ["content","yield"]
      ],
      locals: [],
      templates: []
    };
  }()));

});
define('ghost/templates/components/gh-menu-toggle', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 2,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/components/gh-menu-toggle.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createElement("i");
        dom.setAttribute(el1,"role","button");
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var element0 = dom.childAt(fragment, [0]);
        var morphs = new Array(1);
        morphs[0] = dom.createAttrMorph(element0, 'class');
        return morphs;
      },
      statements: [
        ["attribute","class",["concat",[["get","iconClass"]]]]
      ],
      locals: [],
      templates: []
    };
  }()));

});
define('ghost/templates/components/gh-modal-dialog', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 4,
              "column": 12
            },
            "end": {
              "line": 4,
              "column": 81
            }
          },
          "moduleName": "ghost/templates/components/gh-modal-dialog.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createElement("header");
          dom.setAttribute(el1,"class","modal-header");
          var el2 = dom.createElement("h1");
          var el3 = dom.createComment("");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(1);
          morphs[0] = dom.createMorphAt(dom.childAt(fragment, [0, 0]),0,0);
          return morphs;
        },
        statements: [
          ["content","title"]
        ],
        locals: [],
        templates: []
      };
    }());
    var child1 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 5,
              "column": 12
            },
            "end": {
              "line": 5,
              "column": 136
            }
          },
          "moduleName": "ghost/templates/components/gh-modal-dialog.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createElement("a");
          dom.setAttribute(el1,"class","close icon-x");
          dom.setAttribute(el1,"href","");
          dom.setAttribute(el1,"title","Close");
          var el2 = dom.createElement("span");
          dom.setAttribute(el2,"class","hidden");
          var el3 = dom.createTextNode("Close");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var element3 = dom.childAt(fragment, [0]);
          var morphs = new Array(1);
          morphs[0] = dom.createElementMorph(element3);
          return morphs;
        },
        statements: [
          ["element","action",["closeModal"],[]]
        ],
        locals: [],
        templates: []
      };
    }());
    var child2 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 9,
              "column": 12
            },
            "end": {
              "line": 14,
              "column": 12
            }
          },
          "moduleName": "ghost/templates/components/gh-modal-dialog.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("            ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("footer");
          dom.setAttribute(el1,"class","modal-footer");
          var el2 = dom.createTextNode("\n                ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("button");
          dom.setAttribute(el2,"type","button");
          var el3 = dom.createComment("");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("button");
          dom.setAttribute(el2,"type","button");
          var el3 = dom.createComment("");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n            ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var element0 = dom.childAt(fragment, [1]);
          var element1 = dom.childAt(element0, [1]);
          var element2 = dom.childAt(element0, [2]);
          var morphs = new Array(6);
          morphs[0] = dom.createAttrMorph(element1, 'class');
          morphs[1] = dom.createElementMorph(element1);
          morphs[2] = dom.createMorphAt(element1,0,0);
          morphs[3] = dom.createAttrMorph(element2, 'class');
          morphs[4] = dom.createElementMorph(element2);
          morphs[5] = dom.createMorphAt(element2,0,0);
          return morphs;
        },
        statements: [
          ["attribute","class",["concat",[["get","rejectButtonClass"]," btn-minor js-button-reject"]]],
          ["element","action",["confirm","reject"],[]],
          ["content","confirm.reject.text"],
          ["attribute","class",["concat",[["get","acceptButtonClass"]," js-button-accept"]]],
          ["element","action",["confirm","accept"],[]],
          ["content","confirm.accept.text"]
        ],
        locals: [],
        templates: []
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 19,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/components/gh-modal-dialog.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createElement("div");
        dom.setAttribute(el1,"class","modal-container js-modal-container");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("article");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("section");
        dom.setAttribute(el3,"class","modal-content");
        var el4 = dom.createTextNode("\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createComment("");
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createComment("");
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createElement("section");
        dom.setAttribute(el4,"class","modal-body");
        var el5 = dom.createTextNode("\n                ");
        dom.appendChild(el4, el5);
        var el5 = dom.createComment("");
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n            ");
        dom.appendChild(el4, el5);
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n");
        dom.appendChild(el3, el4);
        var el4 = dom.createComment("");
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("        ");
        dom.appendChild(el3, el4);
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createElement("div");
        dom.setAttribute(el1,"class","modal-background js-modal-background");
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var element4 = dom.childAt(fragment, [0]);
        var element5 = dom.childAt(element4, [1]);
        var element6 = dom.childAt(element5, [1]);
        var morphs = new Array(7);
        morphs[0] = dom.createElementMorph(element4);
        morphs[1] = dom.createAttrMorph(element5, 'class');
        morphs[2] = dom.createElementMorph(element6);
        morphs[3] = dom.createMorphAt(element6,1,1);
        morphs[4] = dom.createMorphAt(element6,3,3);
        morphs[5] = dom.createMorphAt(dom.childAt(element6, [5]),1,1);
        morphs[6] = dom.createMorphAt(element6,7,7);
        return morphs;
      },
      statements: [
        ["element","action",["closeModal"],[]],
        ["attribute","class",["concat",[["get","klass"]," js-modal"]]],
        ["element","action",["noBubble"],["bubbles",false,"preventDefault",false]],
        ["block","if",[["get","title"]],[],0,null],
        ["block","if",[["get","showClose"]],[],1,null],
        ["content","yield"],
        ["block","if",[["get","confirm"]],[],2,null]
      ],
      locals: [],
      templates: [child0, child1, child2]
    };
  }()));

});
define('ghost/templates/components/gh-nav-menu', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 1,
              "column": 0
            },
            "end": {
              "line": 8,
              "column": 0
            }
          },
          "moduleName": "ghost/templates/components/gh-nav-menu.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("div");
          dom.setAttribute(el1,"class","gh-nav-menu-icon");
          dom.setAttribute(el1,"style","background-image: url(https://s3.amazonaws.com/f.cl.ly/items/3I0g431b2b3q00253K1V/d16dc430c9c4f5c09d6ca09be3e5c72fdb21c1ac.png)");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("div");
          dom.setAttribute(el1,"class","gh-nav-menu-details");
          var el2 = dom.createTextNode("\n        ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("div");
          dom.setAttribute(el2,"class","gh-nav-menu-details-blog");
          var el3 = dom.createComment("");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n        ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("div");
          dom.setAttribute(el2,"class","gh-nav-menu-details-user");
          var el3 = dom.createComment("");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n    ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("i");
          dom.setAttribute(el1,"class","icon-arrow");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var element3 = dom.childAt(fragment, [3]);
          var morphs = new Array(2);
          morphs[0] = dom.createMorphAt(dom.childAt(element3, [1]),0,0);
          morphs[1] = dom.createMorphAt(dom.childAt(element3, [3]),0,0);
          return morphs;
        },
        statements: [
          ["content","config.blogTitle"],
          ["content","session.user.name"]
        ],
        locals: [],
        templates: []
      };
    }());
    var child1 = (function() {
      var child0 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 11,
                "column": 32
              },
              "end": {
                "line": 11,
                "column": 176
              }
            },
            "moduleName": "ghost/templates/components/gh-nav-menu.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createElement("i");
            dom.setAttribute(el1,"class","icon-shop");
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode(" About Ghost");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes() { return []; },
          statements: [

          ],
          locals: [],
          templates: []
        };
      }());
      var child1 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 13,
                "column": 32
              },
              "end": {
                "line": 13,
                "column": 199
              }
            },
            "moduleName": "ghost/templates/components/gh-nav-menu.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createElement("i");
            dom.setAttribute(el1,"class","icon-user");
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode(" Your Profile");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes() { return []; },
          statements: [

          ],
          locals: [],
          templates: []
        };
      }());
      var child2 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 14,
                "column": 32
              },
              "end": {
                "line": 14,
                "column": 166
              }
            },
            "moduleName": "ghost/templates/components/gh-nav-menu.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createElement("i");
            dom.setAttribute(el1,"class","icon-signout");
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode(" Sign Out");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes() { return []; },
          statements: [

          ],
          locals: [],
          templates: []
        };
      }());
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 9,
              "column": 0
            },
            "end": {
              "line": 16,
              "column": 0
            }
          },
          "moduleName": "ghost/templates/components/gh-nav-menu.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("ul");
          dom.setAttribute(el1,"class","dropdown-menu dropdown-triangle-top js-user-menu-dropdown-menu");
          dom.setAttribute(el1,"role","menu");
          dom.setAttribute(el1,"style","right:-20px;left:auto;");
          var el2 = dom.createTextNode("\n        ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("li");
          dom.setAttribute(el2,"role","presentation");
          var el3 = dom.createComment("");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n        ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("li");
          dom.setAttribute(el2,"class","divider");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n        ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("li");
          dom.setAttribute(el2,"role","presentation");
          var el3 = dom.createComment("");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n        ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("li");
          dom.setAttribute(el2,"role","presentation");
          var el3 = dom.createComment("");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n    ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var element2 = dom.childAt(fragment, [1]);
          var morphs = new Array(3);
          morphs[0] = dom.createMorphAt(dom.childAt(element2, [1]),0,0);
          morphs[1] = dom.createMorphAt(dom.childAt(element2, [5]),0,0);
          morphs[2] = dom.createMorphAt(dom.childAt(element2, [7]),0,0);
          return morphs;
        },
        statements: [
          ["block","link-to",["about"],["classNames","gh-nav-menu-about dropdown-item js-nav-item","role","menuitem","tabindex","-1"],0,null],
          ["block","link-to",["team.user",["get","session.user.slug"]],["classNames","dropdown-item user-menu-profile js-nav-item","role","menuitem","tabindex","-1"],1,null],
          ["block","link-to",["signout"],["classNames","dropdown-item user-menu-signout","role","menuitem","tabindex","-1"],2,null]
        ],
        locals: [],
        templates: [child0, child1, child2]
      };
    }());
    var child2 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 23,
              "column": 12
            },
            "end": {
              "line": 23,
              "column": 101
            }
          },
          "moduleName": "ghost/templates/components/gh-nav-menu.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createElement("i");
          dom.setAttribute(el1,"class","icon-pen");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("New Post");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes() { return []; },
        statements: [

        ],
        locals: [],
        templates: []
      };
    }());
    var child3 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 24,
              "column": 12
            },
            "end": {
              "line": 24,
              "column": 100
            }
          },
          "moduleName": "ghost/templates/components/gh-nav-menu.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createElement("i");
          dom.setAttribute(el1,"class","icon-content");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("Content");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes() { return []; },
        statements: [

        ],
        locals: [],
        templates: []
      };
    }());
    var child4 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 26,
              "column": 12
            },
            "end": {
              "line": 26,
              "column": 91
            }
          },
          "moduleName": "ghost/templates/components/gh-nav-menu.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createElement("i");
          dom.setAttribute(el1,"class","icon-team");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("Team");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes() { return []; },
        statements: [

        ],
        locals: [],
        templates: []
      };
    }());
    var child5 = (function() {
      var child0 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 32,
                "column": 16
              },
              "end": {
                "line": 32,
                "column": 120
              }
            },
            "moduleName": "ghost/templates/components/gh-nav-menu.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createElement("i");
            dom.setAttribute(el1,"class","icon-settings");
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("General");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes() { return []; },
          statements: [

          ],
          locals: [],
          templates: []
        };
      }());
      var child1 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 34,
                "column": 16
              },
              "end": {
                "line": 34,
                "column": 128
              }
            },
            "moduleName": "ghost/templates/components/gh-nav-menu.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createElement("i");
            dom.setAttribute(el1,"class","icon-compass");
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("Navigation");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes() { return []; },
          statements: [

          ],
          locals: [],
          templates: []
        };
      }());
      var child2 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 35,
                "column": 16
              },
              "end": {
                "line": 35,
                "column": 106
              }
            },
            "moduleName": "ghost/templates/components/gh-nav-menu.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createElement("i");
            dom.setAttribute(el1,"class","icon-tag");
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("Tags");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes() { return []; },
          statements: [

          ],
          locals: [],
          templates: []
        };
      }());
      var child3 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 36,
                "column": 16
              },
              "end": {
                "line": 36,
                "column": 137
              }
            },
            "moduleName": "ghost/templates/components/gh-nav-menu.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createElement("i");
            dom.setAttribute(el1,"class","icon-code");
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("Code Injection");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes() { return []; },
          statements: [

          ],
          locals: [],
          templates: []
        };
      }());
      var child4 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 37,
                "column": 16
              },
              "end": {
                "line": 37,
                "column": 107
              }
            },
            "moduleName": "ghost/templates/components/gh-nav-menu.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createElement("i");
            dom.setAttribute(el1,"class","icon-apps");
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("Labs");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes() { return []; },
          statements: [

          ],
          locals: [],
          templates: []
        };
      }());
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 29,
              "column": 4
            },
            "end": {
              "line": 39,
              "column": 4
            }
          },
          "moduleName": "ghost/templates/components/gh-nav-menu.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("        ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("ul");
          dom.setAttribute(el1,"class","gh-nav-list gh-nav-settings");
          var el2 = dom.createTextNode("\n            ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("li");
          dom.setAttribute(el2,"class","gh-nav-list-h");
          var el3 = dom.createTextNode("Settings");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n            ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("li");
          var el3 = dom.createComment("");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n            ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("li");
          var el3 = dom.createComment("");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n            ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("li");
          var el3 = dom.createComment("");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n            ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("li");
          var el3 = dom.createComment("");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n            ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("li");
          var el3 = dom.createComment("");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n        ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var element1 = dom.childAt(fragment, [1]);
          var morphs = new Array(5);
          morphs[0] = dom.createMorphAt(dom.childAt(element1, [3]),0,0);
          morphs[1] = dom.createMorphAt(dom.childAt(element1, [5]),0,0);
          morphs[2] = dom.createMorphAt(dom.childAt(element1, [7]),0,0);
          morphs[3] = dom.createMorphAt(dom.childAt(element1, [9]),0,0);
          morphs[4] = dom.createMorphAt(dom.childAt(element1, [11]),0,0);
          return morphs;
        },
        statements: [
          ["block","link-to",["settings.general"],["classNames","gh-nav-settings-general"],0,null],
          ["block","link-to",["settings.navigation"],["classNames","gh-nav-settings-navigation"],1,null],
          ["block","link-to",["settings.tags"],["classNames","gh-nav-settings-tags"],2,null],
          ["block","link-to",["settings.code-injection"],["classNames","gh-nav-settings-code-injection"],3,null],
          ["block","link-to",["settings.labs"],["classNames","gh-nav-settings-labs"],4,null]
        ],
        locals: [],
        templates: [child0, child1, child2, child3, child4]
      };
    }());
    var child6 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 45,
              "column": 8
            },
            "end": {
              "line": 49,
              "column": 8
            }
          },
          "moduleName": "ghost/templates/components/gh-nav-menu.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("            ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("div");
          dom.setAttribute(el1,"class","gh-help-button");
          var el2 = dom.createTextNode("\n                ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("i");
          dom.setAttribute(el2,"class","icon-question");
          var el3 = dom.createElement("span");
          dom.setAttribute(el3,"class","hidden");
          var el4 = dom.createTextNode("Help");
          dom.appendChild(el3, el4);
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n            ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes() { return []; },
        statements: [

        ],
        locals: [],
        templates: []
      };
    }());
    var child7 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 50,
              "column": 8
            },
            "end": {
              "line": 60,
              "column": 8
            }
          },
          "moduleName": "ghost/templates/components/gh-nav-menu.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("            ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("ul");
          dom.setAttribute(el1,"class","dropdown-menu dropdown-triangle-bottom");
          dom.setAttribute(el1,"role","menu");
          var el2 = dom.createTextNode("\n                ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("li");
          dom.setAttribute(el2,"role","presentation");
          var el3 = dom.createElement("a");
          dom.setAttribute(el3,"class","dropdown-item help-menu-support");
          dom.setAttribute(el3,"role","menuitem");
          dom.setAttribute(el3,"tabindex","-1");
          dom.setAttribute(el3,"href","http://support.ghost.org/");
          dom.setAttribute(el3,"target","_blank");
          var el4 = dom.createElement("i");
          dom.setAttribute(el4,"class","icon-ambulance");
          dom.appendChild(el3, el4);
          var el4 = dom.createTextNode(" Support Center");
          dom.appendChild(el3, el4);
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n                ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("li");
          dom.setAttribute(el2,"role","presentation");
          var el3 = dom.createElement("a");
          dom.setAttribute(el3,"class","dropdown-item help-menu-tweet");
          dom.setAttribute(el3,"role","menuitem");
          dom.setAttribute(el3,"tabindex","-1");
          dom.setAttribute(el3,"href","https://twitter.com/intent/tweet?text=%40TryGhost+Hi%21+Can+you+help+me+with+&related=TryGhost");
          dom.setAttribute(el3,"target","_blank");
          dom.setAttribute(el3,"onclick","window.open(this.href, 'twitter-share', 'width=550,height=235');return false;");
          var el4 = dom.createElement("i");
          dom.setAttribute(el4,"class","icon-twitter");
          dom.appendChild(el3, el4);
          var el4 = dom.createTextNode(" Tweet @TryGhost!");
          dom.appendChild(el3, el4);
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n                ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("li");
          dom.setAttribute(el2,"class","divider");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n                ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("li");
          dom.setAttribute(el2,"role","presentation");
          var el3 = dom.createElement("a");
          dom.setAttribute(el3,"class","dropdown-item help-menu-how-to");
          dom.setAttribute(el3,"role","menuitem");
          dom.setAttribute(el3,"tabindex","-1");
          dom.setAttribute(el3,"href","http://support.ghost.org/how-to-use-ghost/");
          dom.setAttribute(el3,"target","_blank");
          var el4 = dom.createElement("i");
          dom.setAttribute(el4,"class","icon-book");
          dom.appendChild(el3, el4);
          var el4 = dom.createTextNode(" How to Use Ghost");
          dom.appendChild(el3, el4);
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n                ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("li");
          dom.setAttribute(el2,"role","presentation");
          var el3 = dom.createElement("a");
          dom.setAttribute(el3,"class","dropdown-item help-menu-markdown");
          dom.setAttribute(el3,"role","menuitem");
          dom.setAttribute(el3,"tabindex","-1");
          dom.setAttribute(el3,"href","");
          var el4 = dom.createElement("i");
          dom.setAttribute(el4,"class","icon-markdown");
          dom.appendChild(el3, el4);
          var el4 = dom.createTextNode(" Markdown Help");
          dom.appendChild(el3, el4);
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n                ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("li");
          dom.setAttribute(el2,"class","divider");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n                ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("li");
          dom.setAttribute(el2,"role","presentation");
          var el3 = dom.createElement("a");
          dom.setAttribute(el3,"class","dropdown-item help-menu-wishlist");
          dom.setAttribute(el3,"role","menuitem");
          dom.setAttribute(el3,"tabindex","-1");
          dom.setAttribute(el3,"href","http://ideas.ghost.org/");
          dom.setAttribute(el3,"target","_blank");
          var el4 = dom.createElement("i");
          dom.setAttribute(el4,"class","icon-idea");
          dom.appendChild(el3, el4);
          var el4 = dom.createTextNode(" Wishlist");
          dom.appendChild(el3, el4);
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n            ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var element0 = dom.childAt(fragment, [1, 9, 0]);
          var morphs = new Array(1);
          morphs[0] = dom.createElementMorph(element0);
          return morphs;
        },
        statements: [
          ["element","action",["openModal","markdown"],[]]
        ],
        locals: [],
        templates: []
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 64,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/components/gh-nav-menu.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        var el1 = dom.createElement("section");
        dom.setAttribute(el1,"class","gh-nav-body");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("section");
        dom.setAttribute(el2,"class","gh-nav-search");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createComment("");
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("ul");
        dom.setAttribute(el2,"class","gh-nav-list gh-nav-main");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("li");
        var el4 = dom.createComment("");
        dom.appendChild(el3, el4);
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("li");
        var el4 = dom.createComment("");
        dom.appendChild(el3, el4);
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("li");
        var el4 = dom.createComment("");
        dom.appendChild(el3, el4);
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        var el2 = dom.createComment("");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createElement("footer");
        dom.setAttribute(el1,"class","gh-nav-footer");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createComment("");
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("a");
        dom.setAttribute(el2,"class","gh-nav-footer-sitelink");
        dom.setAttribute(el2,"target","_blank");
        var el3 = dom.createTextNode("View blog");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("div");
        dom.setAttribute(el2,"class","gh-help-menu");
        var el3 = dom.createTextNode("\n");
        dom.appendChild(el2, el3);
        var el3 = dom.createComment("");
        dom.appendChild(el2, el3);
        var el3 = dom.createComment("");
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createElement("div");
        dom.setAttribute(el1,"class","gh-autonav-toggle");
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var element4 = dom.childAt(fragment, [2]);
        var element5 = dom.childAt(element4, [3]);
        var element6 = dom.childAt(fragment, [4]);
        var element7 = dom.childAt(element6, [3]);
        var element8 = dom.childAt(element6, [5]);
        var element9 = dom.childAt(fragment, [6]);
        var morphs = new Array(12);
        morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
        morphs[1] = dom.createMorphAt(fragment,1,1,contextualElement);
        morphs[2] = dom.createMorphAt(dom.childAt(element4, [1]),1,1);
        morphs[3] = dom.createMorphAt(dom.childAt(element5, [1]),0,0);
        morphs[4] = dom.createMorphAt(dom.childAt(element5, [3]),0,0);
        morphs[5] = dom.createMorphAt(dom.childAt(element5, [5]),0,0);
        morphs[6] = dom.createMorphAt(element4,5,5);
        morphs[7] = dom.createMorphAt(element6,1,1);
        morphs[8] = dom.createAttrMorph(element7, 'href');
        morphs[9] = dom.createMorphAt(element8,1,1);
        morphs[10] = dom.createMorphAt(element8,2,2);
        morphs[11] = dom.createElementMorph(element9);
        dom.insertBoundary(fragment, 0);
        return morphs;
      },
      statements: [
        ["block","gh-dropdown-button",[],["tagName","header","class","gh-nav-menu","dropdownName","user-menu"],0,null],
        ["block","gh-dropdown",[],["tagName","div","name","user-menu","closeOnClick","true"],1,null],
        ["inline","gh-search-input",[],["class","gh-nav-search-input"]],
        ["block","link-to",["editor.new"],["classNames","gh-nav-main-editor"],2,null],
        ["block","link-to",["posts"],["classNames","gh-nav-main-content"],3,null],
        ["block","link-to",["team"],["classNames","gh-nav-main-users"],4,null],
        ["block","if",[["subexpr","gh-user-can-admin",[["get","session.user"]],[]]],[],5,null],
        ["inline","gh-menu-toggle",[],["desktopAction","toggleAutoNav","mobileAction","closeMobileMenu"]],
        ["attribute","href",["concat",[["get","config.blogUrl"],"/"]]],
        ["block","gh-dropdown-button",[],["dropdownName","help-menu","tagName","div"],6,null],
        ["block","gh-dropdown",[],["tagName","div","name","help-menu","closeOnClick","true"],7,null],
        ["element","action",["openAutoNav"],["on","mouseEnter"]]
      ],
      locals: [],
      templates: [child0, child1, child2, child3, child4, child5, child6, child7]
    };
  }()));

});
define('ghost/templates/components/gh-navigation', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 2,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/components/gh-navigation.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(1);
        morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
        dom.insertBoundary(fragment, 0);
        return morphs;
      },
      statements: [
        ["content","yield"]
      ],
      locals: [],
      templates: []
    };
  }()));

});
define('ghost/templates/components/gh-navitem', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 1,
              "column": 0
            },
            "end": {
              "line": 5,
              "column": 0
            }
          },
          "moduleName": "ghost/templates/components/gh-navitem.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("span");
          dom.setAttribute(el1,"class","gh-blognav-grab icon-grab");
          var el2 = dom.createTextNode("\n        ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("span");
          dom.setAttribute(el2,"class","sr-only");
          var el3 = dom.createTextNode("Reorder");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n    ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes() { return []; },
        statements: [

        ],
        locals: [],
        templates: []
      };
    }());
    var child1 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 16,
              "column": 0
            },
            "end": {
              "line": 20,
              "column": 0
            }
          },
          "moduleName": "ghost/templates/components/gh-navitem.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("button");
          dom.setAttribute(el1,"type","button");
          dom.setAttribute(el1,"class","gh-blognav-add");
          var el2 = dom.createTextNode("\n        ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("i");
          dom.setAttribute(el2,"class","icon-add2");
          var el3 = dom.createElement("span");
          dom.setAttribute(el3,"class","sr-only");
          var el4 = dom.createTextNode("Add");
          dom.appendChild(el3, el4);
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n    ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var element1 = dom.childAt(fragment, [1]);
          var morphs = new Array(1);
          morphs[0] = dom.createElementMorph(element1);
          return morphs;
        },
        statements: [
          ["element","action",["addItem"],[]]
        ],
        locals: [],
        templates: []
      };
    }());
    var child2 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 20,
              "column": 0
            },
            "end": {
              "line": 24,
              "column": 0
            }
          },
          "moduleName": "ghost/templates/components/gh-navitem.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("button");
          dom.setAttribute(el1,"type","button");
          dom.setAttribute(el1,"class","gh-blognav-delete");
          var el2 = dom.createTextNode("\n        ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("i");
          dom.setAttribute(el2,"class","icon-trash");
          var el3 = dom.createElement("span");
          dom.setAttribute(el3,"class","sr-only");
          var el4 = dom.createTextNode("Delete");
          dom.appendChild(el3, el4);
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n    ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var element0 = dom.childAt(fragment, [1]);
          var morphs = new Array(1);
          morphs[0] = dom.createElementMorph(element0);
          return morphs;
        },
        statements: [
          ["element","action",["deleteItem",["get","navItem"]],[]]
        ],
        locals: [],
        templates: []
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 25,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/components/gh-navitem.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createElement("div");
        dom.setAttribute(el1,"class","gh-blognav-line");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("span");
        dom.setAttribute(el2,"class","gh-blognav-label");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createComment("");
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("span");
        dom.setAttribute(el2,"class","gh-blognav-url");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createComment("");
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var element2 = dom.childAt(fragment, [2]);
        var morphs = new Array(4);
        morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
        morphs[1] = dom.createMorphAt(dom.childAt(element2, [1]),1,1);
        morphs[2] = dom.createMorphAt(dom.childAt(element2, [3]),1,1);
        morphs[3] = dom.createMorphAt(fragment,4,4,contextualElement);
        dom.insertBoundary(fragment, 0);
        dom.insertBoundary(fragment, null);
        return morphs;
      },
      statements: [
        ["block","unless",[["get","navItem.last"]],[],0,null],
        ["inline","gh-trim-focus-input",[],["class","gh-input","focus",["subexpr","@mut",[["get","navItem.last"]],[]],"placeholder","Label","value",["subexpr","@mut",[["get","navItem.label"]],[]]]],
        ["inline","gh-navitem-url-input",[],["class","gh-input","baseUrl",["subexpr","@mut",[["get","baseUrl"]],[]],"url",["subexpr","@mut",[["get","navItem.url"]],[]],"last",["subexpr","@mut",[["get","navItem.last"]],[]],"change","updateUrl"]],
        ["block","if",[["get","navItem.last"]],[],1,2]
      ],
      locals: [],
      templates: [child0, child1, child2]
    };
  }()));

});
define('ghost/templates/components/gh-notification', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 4,
            "column": 118
          }
        },
        "moduleName": "ghost/templates/components/gh-notification.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createElement("div");
        dom.setAttribute(el1,"class","gh-notification-content");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createComment("");
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createElement("button");
        dom.setAttribute(el1,"class","gh-notification-close icon-x");
        var el2 = dom.createElement("span");
        dom.setAttribute(el2,"class","hidden");
        var el3 = dom.createTextNode("Close");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var element0 = dom.childAt(fragment, [2]);
        var morphs = new Array(2);
        morphs[0] = dom.createMorphAt(dom.childAt(fragment, [0]),1,1);
        morphs[1] = dom.createElementMorph(element0);
        return morphs;
      },
      statements: [
        ["content","message.message"],
        ["element","action",["closeNotification"],[]]
      ],
      locals: [],
      templates: []
    };
  }()));

});
define('ghost/templates/components/gh-notifications', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 1,
              "column": 0
            },
            "end": {
              "line": 3,
              "column": 0
            }
          },
          "moduleName": "ghost/templates/components/gh-notifications.hbs"
        },
        arity: 1,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(1);
          morphs[0] = dom.createMorphAt(fragment,1,1,contextualElement);
          return morphs;
        },
        statements: [
          ["inline","gh-notification",[],["message",["subexpr","@mut",[["get","message"]],[]]]]
        ],
        locals: ["message"],
        templates: []
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 4,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/components/gh-notifications.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(1);
        morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
        dom.insertBoundary(fragment, 0);
        dom.insertBoundary(fragment, null);
        return morphs;
      },
      statements: [
        ["block","each",[["get","messages"]],[],0,null]
      ],
      locals: [],
      templates: [child0]
    };
  }()));

});
define('ghost/templates/components/gh-posts-list-item', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 2,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/components/gh-posts-list-item.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(1);
        morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
        dom.insertBoundary(fragment, 0);
        return morphs;
      },
      statements: [
        ["inline","yield",[["get","this"]],[]]
      ],
      locals: [],
      templates: []
    };
  }()));

});
define('ghost/templates/components/gh-profile-image', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      var child0 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 5,
                "column": 8
              },
              "end": {
                "line": 9,
                "column": 8
              }
            },
            "moduleName": "ghost/templates/components/gh-profile-image.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createTextNode("            ");
            dom.appendChild(el0, el1);
            var el1 = dom.createElement("div");
            dom.setAttribute(el1,"id","account-image");
            dom.setAttribute(el1,"class","gravatar-img");
            var el2 = dom.createTextNode("\n                ");
            dom.appendChild(el1, el2);
            var el2 = dom.createElement("span");
            dom.setAttribute(el2,"class","sr-only");
            var el3 = dom.createTextNode("User image");
            dom.appendChild(el2, el3);
            dom.appendChild(el1, el2);
            var el2 = dom.createTextNode("\n            ");
            dom.appendChild(el1, el2);
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
            var element0 = dom.childAt(fragment, [1]);
            var morphs = new Array(1);
            morphs[0] = dom.createAttrMorph(element0, 'style');
            return morphs;
          },
          statements: [
            ["attribute","style",["get","imageBackground"]]
          ],
          locals: [],
          templates: []
        };
      }());
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 2,
              "column": 4
            },
            "end": {
              "line": 10,
              "column": 4
            }
          },
          "moduleName": "ghost/templates/components/gh-profile-image.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("        ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("div");
          dom.setAttribute(el1,"class","placeholder-img");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n\n");
          dom.appendChild(el0, el1);
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var element1 = dom.childAt(fragment, [1]);
          var morphs = new Array(2);
          morphs[0] = dom.createAttrMorph(element1, 'style');
          morphs[1] = dom.createMorphAt(fragment,3,3,contextualElement);
          dom.insertBoundary(fragment, null);
          return morphs;
        },
        statements: [
          ["attribute","style",["get","defaultImage"]],
          ["block","if",[["get","hasEmail"]],[],0,null]
        ],
        locals: [],
        templates: [child0]
      };
    }());
    var child1 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 19,
              "column": 4
            },
            "end": {
              "line": 19,
              "column": 97
            }
          },
          "moduleName": "ghost/templates/components/gh-profile-image.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createElement("input");
          dom.setAttribute(el1,"type","file");
          dom.setAttribute(el1,"class","file-uploader js-file-input");
          dom.setAttribute(el1,"name","uploadimage");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes() { return []; },
        statements: [

        ],
        locals: [],
        templates: []
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 21,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/components/gh-profile-image.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createElement("figure");
        dom.setAttribute(el1,"class","account-image js-file-upload");
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        var el2 = dom.createComment("");
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("div");
        dom.setAttribute(el2,"class","js-img-preview");
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("span");
        dom.setAttribute(el2,"class","edit-account-image js-img-dropzone");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("i");
        dom.setAttribute(el3,"class","icon-photos");
        var el4 = dom.createTextNode("\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createElement("span");
        dom.setAttribute(el4,"class","sr-only");
        var el5 = dom.createTextNode("Upload an image");
        dom.appendChild(el4, el5);
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n        ");
        dom.appendChild(el3, el4);
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createComment("");
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var element2 = dom.childAt(fragment, [0]);
        var morphs = new Array(2);
        morphs[0] = dom.createMorphAt(element2,1,1);
        morphs[1] = dom.createMorphAt(element2,7,7);
        return morphs;
      },
      statements: [
        ["block","unless",[["get","hasUploadedImage"]],[],0,null],
        ["block","if",[["get","fileStorage"]],[],1,null]
      ],
      locals: [],
      templates: [child0, child1]
    };
  }()));

});
define('ghost/templates/components/gh-search-input', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 17,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/components/gh-search-input.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createElement("button");
        dom.setAttribute(el1,"class","gh-nav-search-button");
        var el2 = dom.createElement("i");
        dom.setAttribute(el2,"class","icon-search");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("span");
        dom.setAttribute(el2,"class","sr-only");
        var el3 = dom.createTextNode("Search");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var element0 = dom.childAt(fragment, [2]);
        var morphs = new Array(2);
        morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
        morphs[1] = dom.createElementMorph(element0);
        dom.insertBoundary(fragment, 0);
        return morphs;
      },
      statements: [
        ["inline","gh-selectize",[],["placeholder","Search","selection",["subexpr","@mut",[["get","selection"]],[]],"content",["subexpr","@mut",[["get","content"]],[]],"loading",["subexpr","@mut",[["get","isLoading"]],[]],"optionValuePath","content.id","optionLabelPath","content.title","optionGroupPath","content.category","openOnFocus",false,"maxItems","1","on-init","onInit","on-focus","onFocus","on-blur","onBlur","update-filter","onType","select-item","openSelected"]],
        ["element","action",["focusInput"],[]]
      ],
      locals: [],
      templates: []
    };
  }()));

});
define('ghost/templates/components/gh-select-native', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 2,
              "column": 4
            },
            "end": {
              "line": 6,
              "column": 4
            }
          },
          "moduleName": "ghost/templates/components/gh-select-native.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("        ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("option");
          dom.setAttribute(el1,"disabled","");
          var el2 = dom.createTextNode("\n          ");
          dom.appendChild(el1, el2);
          var el2 = dom.createComment("");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n        ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var element1 = dom.childAt(fragment, [1]);
          var morphs = new Array(2);
          morphs[0] = dom.createAttrMorph(element1, 'selected');
          morphs[1] = dom.createMorphAt(element1,1,1);
          return morphs;
        },
        statements: [
          ["attribute","selected",["subexpr","is-not",[["get","selection"]],[]]],
          ["content","prompt"]
        ],
        locals: [],
        templates: []
      };
    }());
    var child1 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 8,
              "column": 4
            },
            "end": {
              "line": 13,
              "column": 4
            }
          },
          "moduleName": "ghost/templates/components/gh-select-native.hbs"
        },
        arity: 1,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("        ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("option");
          var el2 = dom.createTextNode("\n            ");
          dom.appendChild(el1, el2);
          var el2 = dom.createComment("");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n        ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var element0 = dom.childAt(fragment, [1]);
          var morphs = new Array(3);
          morphs[0] = dom.createAttrMorph(element0, 'value');
          morphs[1] = dom.createAttrMorph(element0, 'selected');
          morphs[2] = dom.createMorphAt(element0,1,1);
          return morphs;
        },
        statements: [
          ["attribute","value",["concat",[["subexpr","read-path",[["get","item"],["get","optionValuePath"]],[]]]]],
          ["attribute","selected",["subexpr","is-equal",[["get","item"],["get","selection"]],[]]],
          ["inline","read-path",[["get","item"],["get","optionLabelPath"]],[]]
        ],
        locals: ["item"],
        templates: []
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 15,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/components/gh-select-native.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createElement("select");
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        var el2 = dom.createComment("");
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        var el2 = dom.createComment("");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var element2 = dom.childAt(fragment, [0]);
        var morphs = new Array(3);
        morphs[0] = dom.createElementMorph(element2);
        morphs[1] = dom.createMorphAt(element2,1,1);
        morphs[2] = dom.createMorphAt(element2,3,3);
        return morphs;
      },
      statements: [
        ["element","action",["change"],["on","change"]],
        ["block","if",[["get","prompt"]],[],0,null],
        ["block","each",[["get","content"]],[],1,null]
      ],
      locals: [],
      templates: [child0, child1]
    };
  }()));

});
define('ghost/templates/components/gh-spin-button', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 1,
              "column": 0
            },
            "end": {
              "line": 3,
              "column": 0
            }
          },
          "moduleName": "ghost/templates/components/gh-spin-button.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("span");
          dom.setAttribute(el1,"class","spinner");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes() { return []; },
        statements: [

        ],
        locals: [],
        templates: []
      };
    }());
    var child1 = (function() {
      var child0 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 4,
                "column": 4
              },
              "end": {
                "line": 6,
                "column": 4
              }
            },
            "moduleName": "ghost/templates/components/gh-spin-button.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createTextNode("        ");
            dom.appendChild(el0, el1);
            var el1 = dom.createComment("");
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
            var morphs = new Array(1);
            morphs[0] = dom.createMorphAt(fragment,1,1,contextualElement);
            return morphs;
          },
          statements: [
            ["content","buttonText"]
          ],
          locals: [],
          templates: []
        };
      }());
      var child1 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 6,
                "column": 4
              },
              "end": {
                "line": 8,
                "column": 4
              }
            },
            "moduleName": "ghost/templates/components/gh-spin-button.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createTextNode("        ");
            dom.appendChild(el0, el1);
            var el1 = dom.createComment("");
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
            var morphs = new Array(1);
            morphs[0] = dom.createUnsafeMorphAt(fragment,1,1,contextualElement);
            return morphs;
          },
          statements: [
            ["content","yield"]
          ],
          locals: [],
          templates: []
        };
      }());
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 3,
              "column": 0
            },
            "end": {
              "line": 9,
              "column": 0
            }
          },
          "moduleName": "ghost/templates/components/gh-spin-button.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(1);
          morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
          dom.insertBoundary(fragment, 0);
          dom.insertBoundary(fragment, null);
          return morphs;
        },
        statements: [
          ["block","if",[["get","buttonText"]],[],0,1]
        ],
        locals: [],
        templates: [child0, child1]
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 9,
            "column": 7
          }
        },
        "moduleName": "ghost/templates/components/gh-spin-button.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(1);
        morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
        dom.insertBoundary(fragment, 0);
        dom.insertBoundary(fragment, null);
        return morphs;
      },
      statements: [
        ["block","if",[["get","showSpinner"]],[],0,1]
      ],
      locals: [],
      templates: [child0, child1]
    };
  }()));

});
define('ghost/templates/components/gh-uploader', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 4,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/components/gh-uploader.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createElement("img");
        dom.setAttribute(el1,"class","js-upload-target");
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createElement("div");
        dom.setAttribute(el1,"class","description");
        var el2 = dom.createComment("");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("strong");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createElement("input");
        dom.setAttribute(el1,"data-url","upload");
        dom.setAttribute(el1,"class","gh-input js-fileupload main fileupload");
        dom.setAttribute(el1,"type","file");
        dom.setAttribute(el1,"name","uploadimage");
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var element0 = dom.childAt(fragment, [0]);
        var morphs = new Array(2);
        morphs[0] = dom.createAttrMorph(element0, 'src');
        morphs[1] = dom.createMorphAt(dom.childAt(fragment, [2]),0,0);
        return morphs;
      },
      statements: [
        ["attribute","src",["concat",[["get","imageSource"]]]],
        ["content","description"]
      ],
      locals: [],
      templates: []
    };
  }()));

});
define('ghost/templates/components/gh-url-preview', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 2,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/components/gh-url-preview.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(1);
        morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
        dom.insertBoundary(fragment, 0);
        return morphs;
      },
      statements: [
        ["content","url"]
      ],
      locals: [],
      templates: []
    };
  }()));

});
define('ghost/templates/components/gh-user-active', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 2,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/components/gh-user-active.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(1);
        morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
        dom.insertBoundary(fragment, 0);
        return morphs;
      },
      statements: [
        ["inline","yield",[["get","this"]],[]]
      ],
      locals: [],
      templates: []
    };
  }()));

});
define('ghost/templates/components/gh-user-invited', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 2,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/components/gh-user-invited.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(1);
        morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
        dom.insertBoundary(fragment, 0);
        return morphs;
      },
      statements: [
        ["inline","yield",[["get","this"]],[]]
      ],
      locals: [],
      templates: []
    };
  }()));

});
define('ghost/templates/components/gh-view-title', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 3,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/components/gh-view-title.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createElement("button");
        dom.setAttribute(el1,"class","gh-mobilemenu-button");
        dom.setAttribute(el1,"role","presentation");
        var el2 = dom.createElement("i");
        dom.setAttribute(el2,"class","icon-gh");
        var el3 = dom.createElement("span");
        dom.setAttribute(el3,"class","sr-only");
        var el4 = dom.createTextNode("Menu");
        dom.appendChild(el3, el4);
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode(" \n");
        dom.appendChild(el0, el1);
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var element0 = dom.childAt(fragment, [0]);
        var morphs = new Array(2);
        morphs[0] = dom.createElementMorph(element0);
        morphs[1] = dom.createMorphAt(fragment,2,2,contextualElement);
        return morphs;
      },
      statements: [
        ["element","action",["openMobileMenu"],[]],
        ["content","yield"]
      ],
      locals: [],
      templates: []
    };
  }()));

});
define('ghost/templates/editor/edit', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      var child0 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 3,
                "column": 8
              },
              "end": {
                "line": 6,
                "column": 8
              }
            },
            "moduleName": "ghost/templates/editor/edit.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createTextNode("            ");
            dom.appendChild(el0, el1);
            var el1 = dom.createComment("");
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
            var morphs = new Array(1);
            morphs[0] = dom.createMorphAt(fragment,1,1,contextualElement);
            return morphs;
          },
          statements: [
            ["inline","gh-trim-focus-input",[],["type","text","id","entry-title","placeholder","Your Post Title","value",["subexpr","@mut",[["get","model.titleScratch"]],[]],"tabindex","1","focus",["subexpr","@mut",[["get","shouldFocusTitle"]],[]]]]
          ],
          locals: [],
          templates: []
        };
      }());
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 1,
              "column": 0
            },
            "end": {
              "line": 55,
              "column": 0
            }
          },
          "moduleName": "ghost/templates/editor/edit.hbs"
        },
        arity: 1,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("header");
          dom.setAttribute(el1,"class","view-header");
          var el2 = dom.createTextNode("\n");
          dom.appendChild(el1, el2);
          var el2 = dom.createComment("");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("        ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("section");
          dom.setAttribute(el2,"class","view-actions");
          var el3 = dom.createTextNode("\n            ");
          dom.appendChild(el2, el3);
          var el3 = dom.createElement("button");
          dom.setAttribute(el3,"type","button");
          dom.setAttribute(el3,"class","post-settings");
          var el4 = dom.createTextNode("\n                ");
          dom.appendChild(el3, el4);
          var el4 = dom.createElement("i");
          dom.setAttribute(el4,"class","icon-settings");
          dom.appendChild(el3, el4);
          var el4 = dom.createTextNode("\n            ");
          dom.appendChild(el3, el4);
          dom.appendChild(el2, el3);
          var el3 = dom.createTextNode("\n            ");
          dom.appendChild(el2, el3);
          var el3 = dom.createComment("");
          dom.appendChild(el2, el3);
          var el3 = dom.createTextNode("\n        ");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n    ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n\n    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("section");
          dom.setAttribute(el1,"class","view-container view-editor");
          var el2 = dom.createTextNode("\n        ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("section");
          var el3 = dom.createTextNode("\n            ");
          dom.appendChild(el2, el3);
          var el3 = dom.createElement("header");
          dom.setAttribute(el3,"class","floatingheader");
          var el4 = dom.createTextNode("\n                ");
          dom.appendChild(el3, el4);
          var el4 = dom.createElement("span");
          dom.setAttribute(el4,"class","desktop-tabs");
          var el5 = dom.createTextNode("Markdown");
          dom.appendChild(el4, el5);
          dom.appendChild(el3, el4);
          var el4 = dom.createTextNode("\n                ");
          dom.appendChild(el3, el4);
          var el4 = dom.createElement("span");
          dom.setAttribute(el4,"class","mobile-tabs");
          var el5 = dom.createTextNode("\n                    ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("a");
          dom.setAttribute(el5,"href","#");
          var el6 = dom.createTextNode("Markdown");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n                    ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("a");
          dom.setAttribute(el5,"href","#");
          var el6 = dom.createTextNode("Preview");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          dom.appendChild(el3, el4);
          var el4 = dom.createTextNode("\n                ");
          dom.appendChild(el3, el4);
          var el4 = dom.createElement("a");
          dom.setAttribute(el4,"class","markdown-help");
          dom.setAttribute(el4,"href","");
          var el5 = dom.createElement("i");
          dom.setAttribute(el5,"class","icon-markdown");
          dom.appendChild(el4, el5);
          dom.appendChild(el3, el4);
          var el4 = dom.createTextNode("\n            ");
          dom.appendChild(el3, el4);
          dom.appendChild(el2, el3);
          var el3 = dom.createTextNode("\n            ");
          dom.appendChild(el2, el3);
          var el3 = dom.createElement("section");
          dom.setAttribute(el3,"id","entry-markdown-content");
          dom.setAttribute(el3,"class","entry-markdown-content");
          var el4 = dom.createTextNode("\n                ");
          dom.appendChild(el3, el4);
          var el4 = dom.createComment("");
          dom.appendChild(el3, el4);
          var el4 = dom.createTextNode("\n            ");
          dom.appendChild(el3, el4);
          dom.appendChild(el2, el3);
          var el3 = dom.createTextNode("\n        ");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n\n        ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("section");
          var el3 = dom.createTextNode("\n            ");
          dom.appendChild(el2, el3);
          var el3 = dom.createElement("header");
          dom.setAttribute(el3,"class","floatingheader");
          var el4 = dom.createTextNode("\n                ");
          dom.appendChild(el3, el4);
          var el4 = dom.createElement("span");
          dom.setAttribute(el4,"class","desktop-tabs");
          var el5 = dom.createTextNode("Preview");
          dom.appendChild(el4, el5);
          dom.appendChild(el3, el4);
          var el4 = dom.createTextNode("\n                ");
          dom.appendChild(el3, el4);
          var el4 = dom.createElement("span");
          dom.setAttribute(el4,"class","mobile-tabs");
          var el5 = dom.createTextNode("\n                    ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("a");
          dom.setAttribute(el5,"href","#");
          var el6 = dom.createTextNode("Markdown");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n                    ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("a");
          dom.setAttribute(el5,"href","#");
          var el6 = dom.createTextNode("Preview");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          dom.appendChild(el3, el4);
          var el4 = dom.createTextNode("\n                ");
          dom.appendChild(el3, el4);
          var el4 = dom.createElement("span");
          dom.setAttribute(el4,"class","entry-word-count");
          var el5 = dom.createComment("");
          dom.appendChild(el4, el5);
          dom.appendChild(el3, el4);
          var el4 = dom.createTextNode("\n            ");
          dom.appendChild(el3, el4);
          dom.appendChild(el2, el3);
          var el3 = dom.createTextNode("\n            ");
          dom.appendChild(el2, el3);
          var el3 = dom.createElement("section");
          dom.setAttribute(el3,"class","entry-preview-content js-entry-preview-content");
          var el4 = dom.createTextNode("\n                ");
          dom.appendChild(el3, el4);
          var el4 = dom.createComment("");
          dom.appendChild(el3, el4);
          var el4 = dom.createTextNode("\n            ");
          dom.appendChild(el3, el4);
          dom.appendChild(el2, el3);
          var el3 = dom.createTextNode("\n        ");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n    ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var element0 = dom.childAt(fragment, [1]);
          var element1 = dom.childAt(element0, [3]);
          var element2 = dom.childAt(element1, [1]);
          var element3 = dom.childAt(fragment, [3]);
          var element4 = dom.childAt(element3, [1]);
          var element5 = dom.childAt(element4, [1]);
          var element6 = dom.childAt(element5, [3]);
          var element7 = dom.childAt(element6, [1]);
          var element8 = dom.childAt(element6, [3]);
          var element9 = dom.childAt(element5, [5]);
          var element10 = dom.childAt(element3, [3]);
          var element11 = dom.childAt(element10, [1]);
          var element12 = dom.childAt(element11, [3]);
          var element13 = dom.childAt(element12, [1]);
          var element14 = dom.childAt(element12, [3]);
          var morphs = new Array(17);
          morphs[0] = dom.createMorphAt(element0,1,1);
          morphs[1] = dom.createElementMorph(element2);
          morphs[2] = dom.createMorphAt(element1,3,3);
          morphs[3] = dom.createAttrMorph(element4, 'class');
          morphs[4] = dom.createAttrMorph(element7, 'class');
          morphs[5] = dom.createElementMorph(element7);
          morphs[6] = dom.createAttrMorph(element8, 'class');
          morphs[7] = dom.createElementMorph(element8);
          morphs[8] = dom.createElementMorph(element9);
          morphs[9] = dom.createMorphAt(dom.childAt(element4, [3]),1,1);
          morphs[10] = dom.createAttrMorph(element10, 'class');
          morphs[11] = dom.createAttrMorph(element13, 'class');
          morphs[12] = dom.createElementMorph(element13);
          morphs[13] = dom.createAttrMorph(element14, 'class');
          morphs[14] = dom.createElementMorph(element14);
          morphs[15] = dom.createMorphAt(dom.childAt(element11, [5]),0,0);
          morphs[16] = dom.createMorphAt(dom.childAt(element10, [3]),1,1);
          return morphs;
        },
        statements: [
          ["block","gh-view-title",[],["classNames","gh-editor-title","openMobileMenu","openMobileMenu"],0,null],
          ["element","action",["openSettingsMenu"],[]],
          ["inline","gh-editor-save-button",[],["isPublished",["subexpr","@mut",[["get","model.isPublished"]],[]],"willPublish",["subexpr","@mut",[["get","willPublish"]],[]],"postOrPage",["subexpr","@mut",[["get","postOrPage"]],[]],"isNew",["subexpr","@mut",[["get","model.isNew"]],[]],"save","save","setSaveType","setSaveType","delete","openDeleteModal","submitting",["subexpr","@mut",[["get","submitting"]],[]]]],
          ["attribute","class",["concat",["entry-markdown js-entry-markdown ",["subexpr","if",[["get","ghEditor.markdownActive"],"active"],[]]]]],
          ["attribute","class",["concat",[["subexpr","if",[["get","ghEditor.markdownActive"],"active"],[]]]]],
          ["element","action",["selectTab","markdown"],["target",["get","ghEditor"]]],
          ["attribute","class",["concat",[["subexpr","if",[["get","ghEditor.previewActive"],"active"],[]]]]],
          ["element","action",["selectTab","preview"],["target",["get","ghEditor"]]],
          ["element","action",["openModal","markdown"],[]],
          ["inline","gh-ed-editor",[],["classNames","markdown-editor js-markdown-editor","tabindex","1","spellcheck","true","value",["subexpr","@mut",[["get","model.scratch"]],[]],"setEditor","setEditor","updateScrollInfo","updateEditorScrollInfo","openModal","openModal","onFocusIn","autoSaveNew","height",["subexpr","@mut",[["get","height"]],[]],"focus",["subexpr","@mut",[["get","shouldFocusEditor"]],[]]]],
          ["attribute","class",["concat",["entry-preview js-entry-preview ",["subexpr","if",[["get","ghEditor.previewActive"],"active"],[]]]]],
          ["attribute","class",["concat",[["subexpr","if",[["get","ghEditor.markdownActive"],"active"],[]]]]],
          ["element","action",["selectTab","markdown"],["target",["get","ghEditor"]]],
          ["attribute","class",["concat",[["subexpr","if",[["get","ghEditor.previewActive"],"active"],[]]]]],
          ["element","action",["selectTab","preview"],["target",["get","ghEditor"]]],
          ["inline","gh-count-words",[["get","model.scratch"]],[]],
          ["inline","gh-ed-preview",[],["classNames","rendered-markdown js-rendered-markdown","markdown",["subexpr","@mut",[["get","model.scratch"]],[]],"scrollPosition",["subexpr","@mut",[["get","ghEditor.scrollPosition"]],[]],"updateHeight","updateHeight","uploadStarted","disableEditor","uploadFinished","enableEditor","uploadSuccess","handleImgUpload"]]
        ],
        locals: ["ghEditor"],
        templates: [child0]
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 56,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/editor/edit.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(1);
        morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
        dom.insertBoundary(fragment, 0);
        dom.insertBoundary(fragment, null);
        return morphs;
      },
      statements: [
        ["block","gh-editor",[],["editorScrollInfo",["subexpr","@mut",[["get","editorScrollInfo"]],[]]],0,null]
      ],
      locals: [],
      templates: [child0]
    };
  }()));

});
define('ghost/templates/error', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      var child0 = (function() {
        var child0 = (function() {
          return {
            meta: {
              "revision": "Ember@1.13.2",
              "loc": {
                "source": null,
                "start": {
                  "line": 20,
                  "column": 24
                },
                "end": {
                  "line": 20,
                  "column": 100
                }
              },
              "moduleName": "ghost/templates/error.hbs"
            },
            arity: 0,
            cachedFragment: null,
            hasRendered: false,
            buildFragment: function buildFragment(dom) {
              var el0 = dom.createDocumentFragment();
              var el1 = dom.createElement("em");
              dom.setAttribute(el1,"class","error-stack-function");
              var el2 = dom.createComment("");
              dom.appendChild(el1, el2);
              dom.appendChild(el0, el1);
              return el0;
            },
            buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
              var morphs = new Array(1);
              morphs[0] = dom.createMorphAt(dom.childAt(fragment, [0]),0,0);
              return morphs;
            },
            statements: [
              ["content","item.function"]
            ],
            locals: [],
            templates: []
          };
        }());
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 17,
                "column": 16
              },
              "end": {
                "line": 23,
                "column": 16
              }
            },
            "moduleName": "ghost/templates/error.hbs"
          },
          arity: 1,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createTextNode("                    ");
            dom.appendChild(el0, el1);
            var el1 = dom.createElement("li");
            var el2 = dom.createTextNode("\n                        at\n                        ");
            dom.appendChild(el1, el2);
            var el2 = dom.createComment("");
            dom.appendChild(el1, el2);
            var el2 = dom.createTextNode("\n                        ");
            dom.appendChild(el1, el2);
            var el2 = dom.createElement("span");
            dom.setAttribute(el2,"class","error-stack-file");
            var el3 = dom.createTextNode("(");
            dom.appendChild(el2, el3);
            var el3 = dom.createComment("");
            dom.appendChild(el2, el3);
            var el3 = dom.createTextNode(")");
            dom.appendChild(el2, el3);
            dom.appendChild(el1, el2);
            var el2 = dom.createTextNode("\n                    ");
            dom.appendChild(el1, el2);
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
            var element0 = dom.childAt(fragment, [1]);
            var morphs = new Array(2);
            morphs[0] = dom.createMorphAt(element0,1,1);
            morphs[1] = dom.createMorphAt(dom.childAt(element0, [3]),1,1);
            return morphs;
          },
          statements: [
            ["block","if",[["get","item.function"]],[],0,null],
            ["content","item.at"]
          ],
          locals: ["item"],
          templates: [child0]
        };
      }());
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 12,
              "column": 4
            },
            "end": {
              "line": 26,
              "column": 4
            }
          },
          "moduleName": "ghost/templates/error.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("        ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("section");
          dom.setAttribute(el1,"class","error-stack");
          var el2 = dom.createTextNode("\n            ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("h3");
          var el3 = dom.createTextNode("Stack Trace");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n            ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("p");
          var el3 = dom.createElement("strong");
          var el4 = dom.createComment("");
          dom.appendChild(el3, el4);
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n            ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("ul");
          dom.setAttribute(el2,"class","error-stack-list");
          var el3 = dom.createTextNode("\n");
          dom.appendChild(el2, el3);
          var el3 = dom.createComment("");
          dom.appendChild(el2, el3);
          var el3 = dom.createTextNode("            ");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n        ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var element1 = dom.childAt(fragment, [1]);
          var morphs = new Array(2);
          morphs[0] = dom.createMorphAt(dom.childAt(element1, [3, 0]),0,0);
          morphs[1] = dom.createMorphAt(dom.childAt(element1, [5]),1,1);
          return morphs;
        },
        statements: [
          ["content","message"],
          ["block","each",[["get","stack"]],[],0,null]
        ],
        locals: [],
        templates: [child0]
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 28,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/error.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createElement("div");
        dom.setAttribute(el1,"class","gh-view");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("section");
        dom.setAttribute(el2,"class","error-content error-404 js-error-container");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("section");
        dom.setAttribute(el3,"class","error-details");
        var el4 = dom.createTextNode("\n             ");
        dom.appendChild(el3, el4);
        var el4 = dom.createElement("img");
        dom.setAttribute(el4,"class","error-ghost");
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n             ");
        dom.appendChild(el3, el4);
        var el4 = dom.createElement("section");
        dom.setAttribute(el4,"class","error-message");
        var el5 = dom.createTextNode("\n                 ");
        dom.appendChild(el4, el5);
        var el5 = dom.createElement("h1");
        dom.setAttribute(el5,"class","error-code");
        var el6 = dom.createComment("");
        dom.appendChild(el5, el6);
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n                 ");
        dom.appendChild(el4, el5);
        var el5 = dom.createElement("h2");
        dom.setAttribute(el5,"class","error-description");
        var el6 = dom.createComment("");
        dom.appendChild(el5, el6);
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n             ");
        dom.appendChild(el4, el5);
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n        ");
        dom.appendChild(el3, el4);
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n\n");
        dom.appendChild(el1, el2);
        var el2 = dom.createComment("");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var element2 = dom.childAt(fragment, [0]);
        var element3 = dom.childAt(element2, [1, 1]);
        var element4 = dom.childAt(element3, [1]);
        var element5 = dom.childAt(element3, [3]);
        var morphs = new Array(5);
        morphs[0] = dom.createAttrMorph(element4, 'src');
        morphs[1] = dom.createAttrMorph(element4, 'srcset');
        morphs[2] = dom.createMorphAt(dom.childAt(element5, [1]),0,0);
        morphs[3] = dom.createMorphAt(dom.childAt(element5, [3]),0,0);
        morphs[4] = dom.createMorphAt(element2,3,3);
        return morphs;
      },
      statements: [
        ["attribute","src",["concat",[["subexpr","gh-path",["admin","/img/404-ghost@2x.png"],[]]]]],
        ["attribute","srcset",["concat",[["subexpr","gh-path",["admin","/img/404-ghost.png"],[]]," 1x, ",["subexpr","gh-path",["admin","/img/404-ghost@2x.png"],[]]," 2x"]]],
        ["content","code"],
        ["content","message"],
        ["block","if",[["get","stack"]],[],0,null]
      ],
      locals: [],
      templates: [child0]
    };
  }()));

});
define('ghost/templates/modals/copy-html', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 1,
              "column": 0
            },
            "end": {
              "line": 6,
              "column": 0
            }
          },
          "moduleName": "ghost/templates/modals/copy-html.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("\n    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(1);
          morphs[0] = dom.createMorphAt(fragment,1,1,contextualElement);
          return morphs;
        },
        statements: [
          ["inline","textarea",[],["value",["subexpr","@mut",[["get","generatedHTML"]],[]],"rows","6"]]
        ],
        locals: [],
        templates: []
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 7,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/modals/copy-html.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(1);
        morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
        dom.insertBoundary(fragment, 0);
        dom.insertBoundary(fragment, null);
        return morphs;
      },
      statements: [
        ["block","gh-modal-dialog",[],["action","closeModal","showClose",true,"type","action","title","Generated HTML","confirm",["subexpr","@mut",[["get","confirm"]],[]],"class","copy-html"],0,null]
      ],
      locals: [],
      templates: [child0]
    };
  }()));

});
define('ghost/templates/modals/delete-all', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 1,
              "column": 0
            },
            "end": {
              "line": 6,
              "column": 0
            }
          },
          "moduleName": "ghost/templates/modals/delete-all.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("\n    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("p");
          var el2 = dom.createTextNode("This is permanent! No backups, no restores, no magic undo button. ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("br");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode(" We warned you, ok?");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes() { return []; },
        statements: [

        ],
        locals: [],
        templates: []
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 7,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/modals/delete-all.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(1);
        morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
        dom.insertBoundary(fragment, 0);
        dom.insertBoundary(fragment, null);
        return morphs;
      },
      statements: [
        ["block","gh-modal-dialog",[],["action","closeModal","type","action","style","wide","title","Would you really like to delete all content from your blog?","confirm",["subexpr","@mut",[["get","confirm"]],[]]],0,null]
      ],
      locals: [],
      templates: [child0]
    };
  }()));

});
define('ghost/templates/modals/delete-post', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 1,
              "column": 0
            },
            "end": {
              "line": 6,
              "column": 0
            }
          },
          "moduleName": "ghost/templates/modals/delete-post.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("\n    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("p");
          var el2 = dom.createTextNode("You're about to delete \"");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("strong");
          var el3 = dom.createComment("");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\".");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("br");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("This is permanent! No backups, no restores, no magic undo button. ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("br");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode(" We warned you, ok?");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(1);
          morphs[0] = dom.createMorphAt(dom.childAt(fragment, [1, 1]),0,0);
          return morphs;
        },
        statements: [
          ["content","model.title"]
        ],
        locals: [],
        templates: []
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 7,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/modals/delete-post.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(1);
        morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
        dom.insertBoundary(fragment, 0);
        dom.insertBoundary(fragment, null);
        return morphs;
      },
      statements: [
        ["block","gh-modal-dialog",[],["action","closeModal","showClose",true,"type","action","style","wide","title","Are you sure you want to delete this post?","confirm",["subexpr","@mut",[["get","confirm"]],[]]],0,null]
      ],
      locals: [],
      templates: [child0]
    };
  }()));

});
define('ghost/templates/modals/delete-tag', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      var child0 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 4,
                "column": 4
              },
              "end": {
                "line": 6,
                "column": 4
              }
            },
            "moduleName": "ghost/templates/modals/delete-tag.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createTextNode("        ");
            dom.appendChild(el0, el1);
            var el1 = dom.createElement("strong");
            var el2 = dom.createTextNode("WARNING:");
            dom.appendChild(el1, el2);
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode(" ");
            dom.appendChild(el0, el1);
            var el1 = dom.createElement("span");
            dom.setAttribute(el1,"class","red");
            var el2 = dom.createTextNode("This tag is attached to ");
            dom.appendChild(el1, el2);
            var el2 = dom.createComment("");
            dom.appendChild(el1, el2);
            var el2 = dom.createTextNode(" ");
            dom.appendChild(el1, el2);
            var el2 = dom.createComment("");
            dom.appendChild(el1, el2);
            var el2 = dom.createTextNode(".");
            dom.appendChild(el1, el2);
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode(" You're about to delete \"");
            dom.appendChild(el0, el1);
            var el1 = dom.createElement("strong");
            var el2 = dom.createComment("");
            dom.appendChild(el1, el2);
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\". This is permanent! No backups, no restores, no magic undo button. We warned you, ok?\n");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
            var element0 = dom.childAt(fragment, [3]);
            var morphs = new Array(3);
            morphs[0] = dom.createMorphAt(element0,1,1);
            morphs[1] = dom.createMorphAt(element0,3,3);
            morphs[2] = dom.createMorphAt(dom.childAt(fragment, [5]),0,0);
            return morphs;
          },
          statements: [
            ["content","model.post_count"],
            ["content","postInflection"],
            ["content","model.name"]
          ],
          locals: [],
          templates: []
        };
      }());
      var child1 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 6,
                "column": 4
              },
              "end": {
                "line": 8,
                "column": 4
              }
            },
            "moduleName": "ghost/templates/modals/delete-tag.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createTextNode("        ");
            dom.appendChild(el0, el1);
            var el1 = dom.createElement("strong");
            var el2 = dom.createTextNode("WARNING:");
            dom.appendChild(el1, el2);
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode(" You're about to delete \"");
            dom.appendChild(el0, el1);
            var el1 = dom.createElement("strong");
            var el2 = dom.createComment("");
            dom.appendChild(el1, el2);
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\". This is permanent! No backups, no restores, no magic undo button. We warned you, ok?\n");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
            var morphs = new Array(1);
            morphs[0] = dom.createMorphAt(dom.childAt(fragment, [3]),0,0);
            return morphs;
          },
          statements: [
            ["content","model.name"]
          ],
          locals: [],
          templates: []
        };
      }());
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 1,
              "column": 0
            },
            "end": {
              "line": 9,
              "column": 0
            }
          },
          "moduleName": "ghost/templates/modals/delete-tag.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(1);
          morphs[0] = dom.createMorphAt(fragment,1,1,contextualElement);
          dom.insertBoundary(fragment, null);
          return morphs;
        },
        statements: [
          ["block","if",[["get","model.post_count"]],[],0,1]
        ],
        locals: [],
        templates: [child0, child1]
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 10,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/modals/delete-tag.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(1);
        morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
        dom.insertBoundary(fragment, 0);
        dom.insertBoundary(fragment, null);
        return morphs;
      },
      statements: [
        ["block","gh-modal-dialog",[],["action","closeModal","showClose",true,"type","action","style","wide","title","Are you sure you want to delete this tag?","confirm",["subexpr","@mut",[["get","confirm"]],[]]],0,null]
      ],
      locals: [],
      templates: [child0]
    };
  }()));

});
define('ghost/templates/modals/delete-user', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      var child0 = (function() {
        var child0 = (function() {
          return {
            meta: {
              "revision": "Ember@1.13.2",
              "loc": {
                "source": null,
                "start": {
                  "line": 5,
                  "column": 8
                },
                "end": {
                  "line": 7,
                  "column": 8
                }
              },
              "moduleName": "ghost/templates/modals/delete-user.hbs"
            },
            arity: 0,
            cachedFragment: null,
            hasRendered: false,
            buildFragment: function buildFragment(dom) {
              var el0 = dom.createDocumentFragment();
              var el1 = dom.createTextNode("            ");
              dom.appendChild(el0, el1);
              var el1 = dom.createElement("strong");
              var el2 = dom.createTextNode("WARNING:");
              dom.appendChild(el1, el2);
              dom.appendChild(el0, el1);
              var el1 = dom.createTextNode(" ");
              dom.appendChild(el0, el1);
              var el1 = dom.createElement("span");
              dom.setAttribute(el1,"class","red");
              var el2 = dom.createTextNode("This user is the author of ");
              dom.appendChild(el1, el2);
              var el2 = dom.createComment("");
              dom.appendChild(el1, el2);
              var el2 = dom.createTextNode(" ");
              dom.appendChild(el1, el2);
              var el2 = dom.createComment("");
              dom.appendChild(el1, el2);
              var el2 = dom.createTextNode(".");
              dom.appendChild(el1, el2);
              dom.appendChild(el0, el1);
              var el1 = dom.createTextNode(" All posts and user data will be deleted. There is no way to recover this.\n");
              dom.appendChild(el0, el1);
              return el0;
            },
            buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
              var element0 = dom.childAt(fragment, [3]);
              var morphs = new Array(2);
              morphs[0] = dom.createMorphAt(element0,1,1);
              morphs[1] = dom.createMorphAt(element0,3,3);
              return morphs;
            },
            statements: [
              ["content","userPostCount.count"],
              ["content","userPostCount.inflection"]
            ],
            locals: [],
            templates: []
          };
        }());
        var child1 = (function() {
          return {
            meta: {
              "revision": "Ember@1.13.2",
              "loc": {
                "source": null,
                "start": {
                  "line": 7,
                  "column": 8
                },
                "end": {
                  "line": 9,
                  "column": 8
                }
              },
              "moduleName": "ghost/templates/modals/delete-user.hbs"
            },
            arity: 0,
            cachedFragment: null,
            hasRendered: false,
            buildFragment: function buildFragment(dom) {
              var el0 = dom.createDocumentFragment();
              var el1 = dom.createTextNode("            ");
              dom.appendChild(el0, el1);
              var el1 = dom.createElement("strong");
              var el2 = dom.createTextNode("WARNING:");
              dom.appendChild(el1, el2);
              dom.appendChild(el0, el1);
              var el1 = dom.createTextNode(" All user data will be deleted. There is no way to recover this.\n");
              dom.appendChild(el0, el1);
              return el0;
            },
            buildRenderNodes: function buildRenderNodes() { return []; },
            statements: [

            ],
            locals: [],
            templates: []
          };
        }());
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 4,
                "column": 4
              },
              "end": {
                "line": 10,
                "column": 4
              }
            },
            "moduleName": "ghost/templates/modals/delete-user.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createComment("");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
            var morphs = new Array(1);
            morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
            dom.insertBoundary(fragment, 0);
            dom.insertBoundary(fragment, null);
            return morphs;
          },
          statements: [
            ["block","if",[["get","userPostCount.count"]],[],0,1]
          ],
          locals: [],
          templates: [child0, child1]
        };
      }());
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 1,
              "column": 0
            },
            "end": {
              "line": 12,
              "column": 0
            }
          },
          "moduleName": "ghost/templates/modals/delete-user.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(1);
          morphs[0] = dom.createMorphAt(fragment,1,1,contextualElement);
          return morphs;
        },
        statements: [
          ["block","unless",[["get","userPostCount.isPending"]],[],0,null]
        ],
        locals: [],
        templates: [child0]
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 13,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/modals/delete-user.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(1);
        morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
        dom.insertBoundary(fragment, 0);
        dom.insertBoundary(fragment, null);
        return morphs;
      },
      statements: [
        ["block","gh-modal-dialog",[],["action","closeModal","showClose",true,"type","action","style","wide","title","Are you sure you want to delete this user?","confirm",["subexpr","@mut",[["get","confirm"]],[]]],0,null]
      ],
      locals: [],
      templates: [child0]
    };
  }()));

});
define('ghost/templates/modals/invite-new-user', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      var child0 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 5,
                "column": 8
              },
              "end": {
                "line": 10,
                "column": 8
              }
            },
            "moduleName": "ghost/templates/modals/invite-new-user.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createTextNode("            ");
            dom.appendChild(el0, el1);
            var el1 = dom.createElement("label");
            dom.setAttribute(el1,"for","new-user-email");
            var el2 = dom.createTextNode("Email Address");
            dom.appendChild(el1, el2);
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n            ");
            dom.appendChild(el0, el1);
            var el1 = dom.createComment("");
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n            ");
            dom.appendChild(el0, el1);
            var el1 = dom.createComment("");
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
            var morphs = new Array(2);
            morphs[0] = dom.createMorphAt(fragment,3,3,contextualElement);
            morphs[1] = dom.createMorphAt(fragment,5,5,contextualElement);
            return morphs;
          },
          statements: [
            ["inline","gh-input",[],["enter","confirmAccept","class","email","id","new-user-email","type","email","placeholder","Email Address","name","email","autofocus","autofocus","autocapitalize","off","autocorrect","off","value",["subexpr","@mut",[["get","email"]],[]],"focusOut",["subexpr","action",["validate","email"],[]]]],
            ["inline","gh-error-message",[],["errors",["subexpr","@mut",[["get","errors"]],[]],"property","email"]]
          ],
          locals: [],
          templates: []
        };
      }());
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 1,
              "column": 0
            },
            "end": {
              "line": 26,
              "column": 0
            }
          },
          "moduleName": "ghost/templates/modals/invite-new-user.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("\n    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("fieldset");
          var el2 = dom.createTextNode("\n");
          dom.appendChild(el1, el2);
          var el2 = dom.createComment("");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n        ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("div");
          dom.setAttribute(el2,"class","form-group for-select");
          var el3 = dom.createTextNode("\n            ");
          dom.appendChild(el2, el3);
          var el3 = dom.createElement("label");
          dom.setAttribute(el3,"for","new-user-role");
          var el4 = dom.createTextNode("Role");
          dom.appendChild(el3, el4);
          dom.appendChild(el2, el3);
          var el3 = dom.createTextNode("\n            ");
          dom.appendChild(el2, el3);
          var el3 = dom.createElement("span");
          dom.setAttribute(el3,"class","gh-select");
          dom.setAttribute(el3,"tabindex","0");
          var el4 = dom.createTextNode("\n                ");
          dom.appendChild(el3, el4);
          var el4 = dom.createComment("");
          dom.appendChild(el3, el4);
          var el4 = dom.createTextNode("\n            ");
          dom.appendChild(el3, el4);
          dom.appendChild(el2, el3);
          var el3 = dom.createTextNode("\n        ");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n    ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var element0 = dom.childAt(fragment, [1]);
          var morphs = new Array(2);
          morphs[0] = dom.createMorphAt(element0,1,1);
          morphs[1] = dom.createMorphAt(dom.childAt(element0, [3, 3]),1,1);
          return morphs;
        },
        statements: [
          ["block","gh-form-group",[],["errors",["subexpr","@mut",[["get","errors"]],[]],"hasValidated",["subexpr","@mut",[["get","hasValidated"]],[]],"property","email"],0,null],
          ["inline","gh-select-native",[],["id","new-user-role","content",["subexpr","@mut",[["get","roles"]],[]],"optionValuePath","id","optionLabelPath","name","selection",["subexpr","@mut",[["get","role"]],[]],"action","setRole"]]
        ],
        locals: [],
        templates: [child0]
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 27,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/modals/invite-new-user.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(1);
        morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
        dom.insertBoundary(fragment, 0);
        dom.insertBoundary(fragment, null);
        return morphs;
      },
      statements: [
        ["block","gh-modal-dialog",[],["action","closeModal","showClose",true,"type","action","title","Invite a New User","confirm",["subexpr","@mut",[["get","confirm"]],[]],"class","invite-new-user"],0,null]
      ],
      locals: [],
      templates: [child0]
    };
  }()));

});
define('ghost/templates/modals/leave-editor', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 1,
              "column": 0
            },
            "end": {
              "line": 9,
              "column": 0
            }
          },
          "moduleName": "ghost/templates/modals/leave-editor.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("\n    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("p");
          var el2 = dom.createTextNode("Hey there! It looks like you're in the middle of writing something and you haven't saved all of your\n    content.");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n\n    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("p");
          var el2 = dom.createTextNode("Save before you go!");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes() { return []; },
        statements: [

        ],
        locals: [],
        templates: []
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 10,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/modals/leave-editor.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(1);
        morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
        dom.insertBoundary(fragment, 0);
        dom.insertBoundary(fragment, null);
        return morphs;
      },
      statements: [
        ["block","gh-modal-dialog",[],["action","closeModal","showClose",true,"type","action","style","wide","title","Are you sure you want to leave this page?","confirm",["subexpr","@mut",[["get","confirm"]],[]]],0,null]
      ],
      locals: [],
      templates: [child0]
    };
  }()));

});
define('ghost/templates/modals/markdown', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 1,
              "column": 0
            },
            "end": {
              "line": 77,
              "column": 0
            }
          },
          "moduleName": "ghost/templates/modals/markdown.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("section");
          dom.setAttribute(el1,"class","markdown-help-container");
          var el2 = dom.createTextNode("\n        ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("table");
          dom.setAttribute(el2,"class","modal-markdown-help-table");
          var el3 = dom.createTextNode("\n            ");
          dom.appendChild(el2, el3);
          var el3 = dom.createElement("thead");
          var el4 = dom.createTextNode("\n            ");
          dom.appendChild(el3, el4);
          var el4 = dom.createElement("tr");
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("th");
          var el6 = dom.createTextNode("Markdown");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("th");
          var el6 = dom.createTextNode("Result");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("th");
          var el6 = dom.createTextNode("Shortcut");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n            ");
          dom.appendChild(el4, el5);
          dom.appendChild(el3, el4);
          var el4 = dom.createTextNode("\n            ");
          dom.appendChild(el3, el4);
          dom.appendChild(el2, el3);
          var el3 = dom.createTextNode("\n            ");
          dom.appendChild(el2, el3);
          var el3 = dom.createElement("tbody");
          var el4 = dom.createTextNode("\n            ");
          dom.appendChild(el3, el4);
          var el4 = dom.createElement("tr");
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("td");
          var el6 = dom.createTextNode("**text**");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("td");
          var el6 = dom.createElement("strong");
          var el7 = dom.createTextNode("Bold");
          dom.appendChild(el6, el7);
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("td");
          var el6 = dom.createTextNode("Ctrl/⌘ + B ");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n            ");
          dom.appendChild(el4, el5);
          dom.appendChild(el3, el4);
          var el4 = dom.createTextNode("\n            ");
          dom.appendChild(el3, el4);
          var el4 = dom.createElement("tr");
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("td");
          var el6 = dom.createTextNode("*text*");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("td");
          var el6 = dom.createElement("em");
          var el7 = dom.createTextNode("Emphasize");
          dom.appendChild(el6, el7);
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("td");
          var el6 = dom.createTextNode("Ctrl/⌘ + I");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n            ");
          dom.appendChild(el4, el5);
          dom.appendChild(el3, el4);
          var el4 = dom.createTextNode("\n            ");
          dom.appendChild(el3, el4);
          var el4 = dom.createElement("tr");
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("td");
          var el6 = dom.createTextNode("~~text~~");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("td");
          var el6 = dom.createElement("del");
          var el7 = dom.createTextNode("Strike-through");
          dom.appendChild(el6, el7);
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("td");
          var el6 = dom.createTextNode("Ctrl + Alt + U");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n            ");
          dom.appendChild(el4, el5);
          dom.appendChild(el3, el4);
          var el4 = dom.createTextNode("\n            ");
          dom.appendChild(el3, el4);
          var el4 = dom.createElement("tr");
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("td");
          var el6 = dom.createTextNode("[title](http://)");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("td");
          var el6 = dom.createElement("a");
          dom.setAttribute(el6,"href","#");
          var el7 = dom.createTextNode("Link");
          dom.appendChild(el6, el7);
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("td");
          var el6 = dom.createTextNode("Ctrl/⌘ + K");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n            ");
          dom.appendChild(el4, el5);
          dom.appendChild(el3, el4);
          var el4 = dom.createTextNode("\n            ");
          dom.appendChild(el3, el4);
          var el4 = dom.createElement("tr");
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("td");
          var el6 = dom.createTextNode("`code`");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("td");
          var el6 = dom.createElement("code");
          var el7 = dom.createTextNode("Inline Code");
          dom.appendChild(el6, el7);
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("td");
          var el6 = dom.createTextNode("Ctrl/⌘ + Shift + K");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n            ");
          dom.appendChild(el4, el5);
          dom.appendChild(el3, el4);
          var el4 = dom.createTextNode("\n            ");
          dom.appendChild(el3, el4);
          var el4 = dom.createElement("tr");
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("td");
          var el6 = dom.createTextNode("![alt](http://)");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("td");
          var el6 = dom.createTextNode("Image");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("td");
          var el6 = dom.createTextNode("Ctrl/⌘ + Shift + I");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n            ");
          dom.appendChild(el4, el5);
          dom.appendChild(el3, el4);
          var el4 = dom.createTextNode("\n            ");
          dom.appendChild(el3, el4);
          var el4 = dom.createElement("tr");
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("td");
          var el6 = dom.createTextNode("* item");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("td");
          var el6 = dom.createTextNode("List");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("td");
          var el6 = dom.createTextNode("Ctrl + L");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n            ");
          dom.appendChild(el4, el5);
          dom.appendChild(el3, el4);
          var el4 = dom.createTextNode("\n            ");
          dom.appendChild(el3, el4);
          var el4 = dom.createElement("tr");
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("td");
          var el6 = dom.createTextNode("> quote");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("td");
          var el6 = dom.createTextNode("Blockquote");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("td");
          var el6 = dom.createTextNode("Ctrl + Q");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n            ");
          dom.appendChild(el4, el5);
          dom.appendChild(el3, el4);
          var el4 = dom.createTextNode("\n            ");
          dom.appendChild(el3, el4);
          var el4 = dom.createElement("tr");
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("td");
          var el6 = dom.createTextNode("==Highlight==");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("td");
          var el6 = dom.createElement("mark");
          var el7 = dom.createTextNode("Highlight");
          dom.appendChild(el6, el7);
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("td");
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n            ");
          dom.appendChild(el4, el5);
          dom.appendChild(el3, el4);
          var el4 = dom.createTextNode("\n            ");
          dom.appendChild(el3, el4);
          var el4 = dom.createElement("tr");
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("td");
          var el6 = dom.createTextNode("# Heading");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("td");
          var el6 = dom.createTextNode("H1");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("td");
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n            ");
          dom.appendChild(el4, el5);
          dom.appendChild(el3, el4);
          var el4 = dom.createTextNode("\n            ");
          dom.appendChild(el3, el4);
          var el4 = dom.createElement("tr");
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("td");
          var el6 = dom.createTextNode("## Heading");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("td");
          var el6 = dom.createTextNode("H2");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("td");
          var el6 = dom.createTextNode("Ctrl/⌘ + H");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n            ");
          dom.appendChild(el4, el5);
          dom.appendChild(el3, el4);
          var el4 = dom.createTextNode("\n            ");
          dom.appendChild(el3, el4);
          var el4 = dom.createElement("tr");
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("td");
          var el6 = dom.createTextNode("### Heading");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("td");
          var el6 = dom.createTextNode("H3");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n                ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("td");
          var el6 = dom.createTextNode("Ctrl/⌘ + H (x2)");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n            ");
          dom.appendChild(el4, el5);
          dom.appendChild(el3, el4);
          var el4 = dom.createTextNode("\n            ");
          dom.appendChild(el3, el4);
          dom.appendChild(el2, el3);
          var el3 = dom.createTextNode("\n        ");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n        For further Markdown syntax reference: ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("a");
          dom.setAttribute(el2,"href","http://support.ghost.org/markdown-guide/");
          dom.setAttribute(el2,"target","_blank");
          var el3 = dom.createTextNode("Markdown Documentation");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n    ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes() { return []; },
        statements: [

        ],
        locals: [],
        templates: []
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 78,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/modals/markdown.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(1);
        morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
        dom.insertBoundary(fragment, 0);
        dom.insertBoundary(fragment, null);
        return morphs;
      },
      statements: [
        ["block","gh-modal-dialog",[],["action","closeModal","showClose",true,"style","wide","title","Markdown Help"],0,null]
      ],
      locals: [],
      templates: [child0]
    };
  }()));

});
define('ghost/templates/modals/signin', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      var child0 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 8,
                "column": 12
              },
              "end": {
                "line": 8,
                "column": 127
              }
            },
            "moduleName": "ghost/templates/modals/signin.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createTextNode("Log in");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes() { return []; },
          statements: [

          ],
          locals: [],
          templates: []
        };
      }());
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 1,
              "column": 0
            },
            "end": {
              "line": 11,
              "column": 0
            }
          },
          "moduleName": "ghost/templates/modals/signin.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("\n        ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("form");
          dom.setAttribute(el1,"id","login");
          dom.setAttribute(el1,"class","login-form");
          dom.setAttribute(el1,"method","post");
          dom.setAttribute(el1,"novalidate","novalidate");
          var el2 = dom.createTextNode("\n            ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("div");
          dom.setAttribute(el2,"class","password-wrap");
          var el3 = dom.createTextNode("\n                ");
          dom.appendChild(el2, el3);
          var el3 = dom.createComment("");
          dom.appendChild(el2, el3);
          var el3 = dom.createTextNode("\n            ");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n            ");
          dom.appendChild(el1, el2);
          var el2 = dom.createComment("");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n       ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var element0 = dom.childAt(fragment, [1]);
          var morphs = new Array(3);
          morphs[0] = dom.createElementMorph(element0);
          morphs[1] = dom.createMorphAt(dom.childAt(element0, [1]),1,1);
          morphs[2] = dom.createMorphAt(element0,3,3);
          return morphs;
        },
        statements: [
          ["element","action",["validateAndAuthenticate"],["on","submit"]],
          ["inline","input",[],["class","gh-input password","type","password","placeholder","Password","name","password","value",["subexpr","@mut",[["get","password"]],[]]]],
          ["block","gh-spin-button",[],["class","btn btn-blue","type","submit","action","validateAndAuthenticate","submitting",["subexpr","@mut",[["get","submitting"]],[]]],0,null]
        ],
        locals: [],
        templates: [child0]
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 12,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/modals/signin.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(1);
        morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
        dom.insertBoundary(fragment, 0);
        dom.insertBoundary(fragment, null);
        return morphs;
      },
      statements: [
        ["block","gh-modal-dialog",[],["action","closeModal","showClose",true,"type","action","style","wide","animation","fade","title","Please re-authenticate","confirm",["subexpr","@mut",[["get","confirm"]],[]]],0,null]
      ],
      locals: [],
      templates: [child0]
    };
  }()));

});
define('ghost/templates/modals/transfer-owner', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 1,
              "column": 0
            },
            "end": {
              "line": 6,
              "column": 0
            }
          },
          "moduleName": "ghost/templates/modals/transfer-owner.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("\n    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("p");
          var el2 = dom.createTextNode("Are you sure you want to transfer the ownership of this blog? You will not be able to undo this action.");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes() { return []; },
        statements: [

        ],
        locals: [],
        templates: []
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 7,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/modals/transfer-owner.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(1);
        morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
        dom.insertBoundary(fragment, 0);
        dom.insertBoundary(fragment, null);
        return morphs;
      },
      statements: [
        ["block","gh-modal-dialog",[],["action","closeModal","showClose",true,"type","action","style","wide","title","Transfer Ownership","confirm",["subexpr","@mut",[["get","confirm"]],[]]],0,null]
      ],
      locals: [],
      templates: [child0]
    };
  }()));

});
define('ghost/templates/modals/upload', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 1,
              "column": 0
            },
            "end": {
              "line": 7,
              "column": 0
            }
          },
          "moduleName": "ghost/templates/modals/upload.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("  ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("section");
          dom.setAttribute(el1,"class","js-drop-zone");
          var el2 = dom.createTextNode("\n      ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("img");
          dom.setAttribute(el2,"class","js-upload-target");
          dom.setAttribute(el2,"alt","logo");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n      ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("input");
          dom.setAttribute(el2,"data-url","upload");
          dom.setAttribute(el2,"class","js-fileupload main");
          dom.setAttribute(el2,"type","file");
          dom.setAttribute(el2,"name","uploadimage");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n  ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var element0 = dom.childAt(fragment, [1]);
          var element1 = dom.childAt(element0, [1]);
          var element2 = dom.childAt(element0, [3]);
          var morphs = new Array(2);
          morphs[0] = dom.createAttrMorph(element1, 'src');
          morphs[1] = dom.createAttrMorph(element2, 'accept');
          return morphs;
        },
        statements: [
          ["attribute","src",["concat",[["get","src"]]]],
          ["attribute","accept",["concat",[["get","acceptEncoding"]]]]
        ],
        locals: [],
        templates: []
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 8,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/modals/upload.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(1);
        morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
        dom.insertBoundary(fragment, 0);
        dom.insertBoundary(fragment, null);
        return morphs;
      },
      statements: [
        ["block","gh-upload-modal",[],["action","closeModal","close",true,"type","action","style","wide","model",["subexpr","@mut",[["get","model"]],[]],"imageType",["subexpr","@mut",[["get","imageType"]],[]]],0,null]
      ],
      locals: [],
      templates: [child0]
    };
  }()));

});
define('ghost/templates/post-settings-menu', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      var child0 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 13,
                "column": 16
              },
              "end": {
                "line": 17,
                "column": 16
              }
            },
            "moduleName": "ghost/templates/post-settings-menu.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createTextNode("                ");
            dom.appendChild(el0, el1);
            var el1 = dom.createElement("a");
            dom.setAttribute(el1,"class","post-view-link");
            dom.setAttribute(el1,"target","_blank");
            var el2 = dom.createTextNode("\n                    View post ");
            dom.appendChild(el1, el2);
            var el2 = dom.createElement("i");
            dom.setAttribute(el2,"class","icon-external");
            dom.appendChild(el1, el2);
            var el2 = dom.createTextNode("\n                ");
            dom.appendChild(el1, el2);
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
            var element4 = dom.childAt(fragment, [1]);
            var morphs = new Array(1);
            morphs[0] = dom.createAttrMorph(element4, 'href');
            return morphs;
          },
          statements: [
            ["attribute","href",["concat",[["get","model.absoluteUrl"]]]]
          ],
          locals: [],
          templates: []
        };
      }());
      var child1 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 17,
                "column": 16
              },
              "end": {
                "line": 21,
                "column": 16
              }
            },
            "moduleName": "ghost/templates/post-settings-menu.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createTextNode("                ");
            dom.appendChild(el0, el1);
            var el1 = dom.createElement("a");
            dom.setAttribute(el1,"class","post-view-link");
            dom.setAttribute(el1,"target","_blank");
            var el2 = dom.createTextNode("\n                    Preview ");
            dom.appendChild(el1, el2);
            var el2 = dom.createElement("i");
            dom.setAttribute(el2,"class","icon-external");
            dom.appendChild(el1, el2);
            var el2 = dom.createTextNode("\n                ");
            dom.appendChild(el1, el2);
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
            var element3 = dom.childAt(fragment, [1]);
            var morphs = new Array(1);
            morphs[0] = dom.createAttrMorph(element3, 'href');
            return morphs;
          },
          statements: [
            ["attribute","href",["concat",[["get","model.previewUrl"]]]]
          ],
          locals: [],
          templates: []
        };
      }());
      var child2 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 29,
                "column": 12
              },
              "end": {
                "line": 35,
                "column": 12
              }
            },
            "moduleName": "ghost/templates/post-settings-menu.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createTextNode("                ");
            dom.appendChild(el0, el1);
            var el1 = dom.createElement("label");
            dom.setAttribute(el1,"for","post-setting-date");
            var el2 = dom.createTextNode("Publish Date");
            dom.appendChild(el1, el2);
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n                ");
            dom.appendChild(el0, el1);
            var el1 = dom.createElement("span");
            dom.setAttribute(el1,"class","input-icon icon-calendar");
            var el2 = dom.createTextNode("\n                    ");
            dom.appendChild(el1, el2);
            var el2 = dom.createComment("");
            dom.appendChild(el1, el2);
            var el2 = dom.createTextNode("\n                ");
            dom.appendChild(el1, el2);
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n                ");
            dom.appendChild(el0, el1);
            var el1 = dom.createComment("");
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
            var morphs = new Array(2);
            morphs[0] = dom.createMorphAt(dom.childAt(fragment, [3]),1,1);
            morphs[1] = dom.createMorphAt(fragment,5,5,contextualElement);
            return morphs;
          },
          statements: [
            ["inline","gh-input",[],["class","post-setting-date","id","post-setting-date","value",["subexpr","@mut",[["get","publishedAtValue"]],[]],"name","post-setting-date","focus-out","setPublishedAt","stopEnterKeyDownPropagation","true"]],
            ["inline","gh-error-message",[],["errors",["subexpr","@mut",[["get","model.errors"]],[]],"property","post-setting-date"]]
          ],
          locals: [],
          templates: []
        };
      }());
      var child3 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 51,
                "column": 12
              },
              "end": {
                "line": 68,
                "column": 12
              }
            },
            "moduleName": "ghost/templates/post-settings-menu.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createTextNode("            ");
            dom.appendChild(el0, el1);
            var el1 = dom.createElement("div");
            dom.setAttribute(el1,"class","form-group for-select");
            var el2 = dom.createTextNode("\n                ");
            dom.appendChild(el1, el2);
            var el2 = dom.createElement("label");
            dom.setAttribute(el2,"for","author-list");
            var el3 = dom.createTextNode("Author");
            dom.appendChild(el2, el3);
            dom.appendChild(el1, el2);
            var el2 = dom.createTextNode("\n                ");
            dom.appendChild(el1, el2);
            var el2 = dom.createElement("span");
            dom.setAttribute(el2,"class","input-icon icon-user");
            var el3 = dom.createTextNode("\n                    ");
            dom.appendChild(el2, el3);
            var el3 = dom.createElement("span");
            dom.setAttribute(el3,"class","gh-select");
            dom.setAttribute(el3,"tabindex","0");
            var el4 = dom.createTextNode("\n                    ");
            dom.appendChild(el3, el4);
            var el4 = dom.createComment("");
            dom.appendChild(el3, el4);
            var el4 = dom.createTextNode("\n                    ");
            dom.appendChild(el3, el4);
            dom.appendChild(el2, el3);
            var el3 = dom.createTextNode("\n                ");
            dom.appendChild(el2, el3);
            dom.appendChild(el1, el2);
            var el2 = dom.createTextNode("\n            ");
            dom.appendChild(el1, el2);
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
            var morphs = new Array(1);
            morphs[0] = dom.createMorphAt(dom.childAt(fragment, [1, 3, 1]),1,1);
            return morphs;
          },
          statements: [
            ["inline","gh-select-native",[],["name","post-setting-author","id","author-list","content",["subexpr","@mut",[["get","authors"]],[]],"optionValuePath","id","optionLabelPath","name","selection",["subexpr","@mut",[["get","selectedAuthor"]],[]],"action","changeAuthor"]]
          ],
          locals: [],
          templates: []
        };
      }());
      var child4 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 71,
                "column": 16
              },
              "end": {
                "line": 77,
                "column": 16
              }
            },
            "moduleName": "ghost/templates/post-settings-menu.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createTextNode("                    ");
            dom.appendChild(el0, el1);
            var el1 = dom.createElement("button");
            dom.setAttribute(el1,"type","button");
            var el2 = dom.createTextNode("\n                        ");
            dom.appendChild(el1, el2);
            var el2 = dom.createElement("b");
            var el3 = dom.createTextNode("Meta Data");
            dom.appendChild(el2, el3);
            dom.appendChild(el1, el2);
            var el2 = dom.createTextNode("\n                        ");
            dom.appendChild(el1, el2);
            var el2 = dom.createElement("span");
            var el3 = dom.createTextNode("Extra content for SEO and social media.");
            dom.appendChild(el2, el3);
            dom.appendChild(el1, el2);
            var el2 = dom.createTextNode("\n                    ");
            dom.appendChild(el1, el2);
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n                    ");
            dom.appendChild(el0, el1);
            var el1 = dom.createElement("i");
            dom.setAttribute(el1,"class","icon-arrow-right");
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes() { return []; },
          statements: [

          ],
          locals: [],
          templates: []
        };
      }());
      var child5 = (function() {
        var child0 = (function() {
          var child0 = (function() {
            return {
              meta: {
                "revision": "Ember@1.13.2",
                "loc": {
                  "source": null,
                  "start": {
                    "line": 109,
                    "column": 12
                  },
                  "end": {
                    "line": 114,
                    "column": 12
                  }
                },
                "moduleName": "ghost/templates/post-settings-menu.hbs"
              },
              arity: 0,
              cachedFragment: null,
              hasRendered: false,
              buildFragment: function buildFragment(dom) {
                var el0 = dom.createDocumentFragment();
                var el1 = dom.createTextNode("                ");
                dom.appendChild(el0, el1);
                var el1 = dom.createElement("label");
                dom.setAttribute(el1,"for","meta-title");
                var el2 = dom.createTextNode("Meta Title");
                dom.appendChild(el1, el2);
                dom.appendChild(el0, el1);
                var el1 = dom.createTextNode("\n                ");
                dom.appendChild(el0, el1);
                var el1 = dom.createComment("");
                dom.appendChild(el0, el1);
                var el1 = dom.createTextNode("\n                ");
                dom.appendChild(el0, el1);
                var el1 = dom.createElement("p");
                var el2 = dom.createTextNode("Recommended: ");
                dom.appendChild(el1, el2);
                var el2 = dom.createElement("b");
                var el3 = dom.createTextNode("70");
                dom.appendChild(el2, el3);
                dom.appendChild(el1, el2);
                var el2 = dom.createTextNode(" characters. You’ve used ");
                dom.appendChild(el1, el2);
                var el2 = dom.createComment("");
                dom.appendChild(el1, el2);
                dom.appendChild(el0, el1);
                var el1 = dom.createTextNode("\n                ");
                dom.appendChild(el0, el1);
                var el1 = dom.createComment("");
                dom.appendChild(el0, el1);
                var el1 = dom.createTextNode("\n");
                dom.appendChild(el0, el1);
                return el0;
              },
              buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
                var morphs = new Array(3);
                morphs[0] = dom.createMorphAt(fragment,3,3,contextualElement);
                morphs[1] = dom.createMorphAt(dom.childAt(fragment, [5]),3,3);
                morphs[2] = dom.createMorphAt(fragment,7,7,contextualElement);
                return morphs;
              },
              statements: [
                ["inline","gh-input",[],["class","post-setting-meta-title","id","meta-title","value",["subexpr","@mut",[["get","metaTitleScratch"]],[]],"name","post-setting-meta-title","focus-out","setMetaTitle","stopEnterKeyDownPropagation","true"]],
                ["inline","gh-count-down-characters",[["get","metaTitleScratch"],70],[]],
                ["inline","gh-error-message",[],["errors",["subexpr","@mut",[["get","model.errors"]],[]],"property","meta_title"]]
              ],
              locals: [],
              templates: []
            };
          }());
          var child1 = (function() {
            return {
              meta: {
                "revision": "Ember@1.13.2",
                "loc": {
                  "source": null,
                  "start": {
                    "line": 116,
                    "column": 12
                  },
                  "end": {
                    "line": 121,
                    "column": 12
                  }
                },
                "moduleName": "ghost/templates/post-settings-menu.hbs"
              },
              arity: 0,
              cachedFragment: null,
              hasRendered: false,
              buildFragment: function buildFragment(dom) {
                var el0 = dom.createDocumentFragment();
                var el1 = dom.createTextNode("                ");
                dom.appendChild(el0, el1);
                var el1 = dom.createElement("label");
                dom.setAttribute(el1,"for","meta-description");
                var el2 = dom.createTextNode("Meta Description");
                dom.appendChild(el1, el2);
                dom.appendChild(el0, el1);
                var el1 = dom.createTextNode("\n                ");
                dom.appendChild(el0, el1);
                var el1 = dom.createComment("");
                dom.appendChild(el0, el1);
                var el1 = dom.createTextNode("\n                ");
                dom.appendChild(el0, el1);
                var el1 = dom.createElement("p");
                var el2 = dom.createTextNode("Recommended: ");
                dom.appendChild(el1, el2);
                var el2 = dom.createElement("b");
                var el3 = dom.createTextNode("156");
                dom.appendChild(el2, el3);
                dom.appendChild(el1, el2);
                var el2 = dom.createTextNode(" characters. You’ve used ");
                dom.appendChild(el1, el2);
                var el2 = dom.createComment("");
                dom.appendChild(el1, el2);
                dom.appendChild(el0, el1);
                var el1 = dom.createTextNode("\n                ");
                dom.appendChild(el0, el1);
                var el1 = dom.createComment("");
                dom.appendChild(el0, el1);
                var el1 = dom.createTextNode("\n");
                dom.appendChild(el0, el1);
                return el0;
              },
              buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
                var morphs = new Array(3);
                morphs[0] = dom.createMorphAt(fragment,3,3,contextualElement);
                morphs[1] = dom.createMorphAt(dom.childAt(fragment, [5]),3,3);
                morphs[2] = dom.createMorphAt(fragment,7,7,contextualElement);
                return morphs;
              },
              statements: [
                ["inline","gh-textarea",[],["class","gh-input post-setting-meta-description","id","meta-description","value",["subexpr","@mut",[["get","metaDescriptionScratch"]],[]],"name","post-setting-meta-description","focus-out","setMetaDescription","stopEnterKeyDownPropagation","true"]],
                ["inline","gh-count-down-characters",[["get","metaDescriptionScratch"],156],[]],
                ["inline","gh-error-message",[],["errors",["subexpr","@mut",[["get","model.errors"]],[]],"property","meta_description"]]
              ],
              locals: [],
              templates: []
            };
          }());
          return {
            meta: {
              "revision": "Ember@1.13.2",
              "loc": {
                "source": null,
                "start": {
                  "line": 100,
                  "column": 8
                },
                "end": {
                  "line": 133,
                  "column": 8
                }
              },
              "moduleName": "ghost/templates/post-settings-menu.hbs"
            },
            arity: 0,
            cachedFragment: null,
            hasRendered: false,
            buildFragment: function buildFragment(dom) {
              var el0 = dom.createDocumentFragment();
              var el1 = dom.createTextNode("        ");
              dom.appendChild(el0, el1);
              var el1 = dom.createElement("div");
              dom.setAttribute(el1,"class","settings-menu-header subview");
              var el2 = dom.createTextNode("\n            ");
              dom.appendChild(el1, el2);
              var el2 = dom.createElement("button");
              dom.setAttribute(el2,"class","back icon-arrow-left settings-menu-header-action");
              var el3 = dom.createElement("span");
              dom.setAttribute(el3,"class","hidden");
              var el4 = dom.createTextNode("Back");
              dom.appendChild(el3, el4);
              dom.appendChild(el2, el3);
              dom.appendChild(el1, el2);
              var el2 = dom.createTextNode("\n            ");
              dom.appendChild(el1, el2);
              var el2 = dom.createElement("h4");
              var el3 = dom.createTextNode("Meta Data");
              dom.appendChild(el2, el3);
              dom.appendChild(el1, el2);
              var el2 = dom.createTextNode("\n            ");
              dom.appendChild(el1, el2);
              var el2 = dom.createElement("div");
              dom.setAttribute(el2,"style","width:23px;");
              dom.appendChild(el1, el2);
              var el2 = dom.createTextNode("\n        ");
              dom.appendChild(el1, el2);
              dom.appendChild(el0, el1);
              var el1 = dom.createTextNode("\n\n        ");
              dom.appendChild(el0, el1);
              var el1 = dom.createElement("div");
              dom.setAttribute(el1,"class","settings-menu-content");
              var el2 = dom.createTextNode("\n            ");
              dom.appendChild(el1, el2);
              var el2 = dom.createElement("form");
              var el3 = dom.createTextNode("\n");
              dom.appendChild(el2, el3);
              var el3 = dom.createComment("");
              dom.appendChild(el2, el3);
              var el3 = dom.createTextNode("\n");
              dom.appendChild(el2, el3);
              var el3 = dom.createComment("");
              dom.appendChild(el2, el3);
              var el3 = dom.createTextNode("\n            ");
              dom.appendChild(el2, el3);
              var el3 = dom.createElement("div");
              dom.setAttribute(el3,"class","form-group");
              var el4 = dom.createTextNode("\n                ");
              dom.appendChild(el3, el4);
              var el4 = dom.createElement("label");
              var el5 = dom.createTextNode("Search Engine Result Preview");
              dom.appendChild(el4, el5);
              dom.appendChild(el3, el4);
              var el4 = dom.createTextNode("\n                ");
              dom.appendChild(el3, el4);
              var el4 = dom.createElement("div");
              dom.setAttribute(el4,"class","seo-preview");
              var el5 = dom.createTextNode("\n                    ");
              dom.appendChild(el4, el5);
              var el5 = dom.createElement("div");
              dom.setAttribute(el5,"class","seo-preview-title");
              var el6 = dom.createComment("");
              dom.appendChild(el5, el6);
              dom.appendChild(el4, el5);
              var el5 = dom.createTextNode("\n                    ");
              dom.appendChild(el4, el5);
              var el5 = dom.createElement("div");
              dom.setAttribute(el5,"class","seo-preview-link");
              var el6 = dom.createComment("");
              dom.appendChild(el5, el6);
              dom.appendChild(el4, el5);
              var el5 = dom.createTextNode("\n                    ");
              dom.appendChild(el4, el5);
              var el5 = dom.createElement("div");
              dom.setAttribute(el5,"class","seo-preview-description");
              var el6 = dom.createComment("");
              dom.appendChild(el5, el6);
              dom.appendChild(el4, el5);
              var el5 = dom.createTextNode("\n                ");
              dom.appendChild(el4, el5);
              dom.appendChild(el3, el4);
              var el4 = dom.createTextNode("\n            ");
              dom.appendChild(el3, el4);
              dom.appendChild(el2, el3);
              var el3 = dom.createTextNode("\n            ");
              dom.appendChild(el2, el3);
              dom.appendChild(el1, el2);
              var el2 = dom.createTextNode("\n        ");
              dom.appendChild(el1, el2);
              dom.appendChild(el0, el1);
              var el1 = dom.createTextNode("\n");
              dom.appendChild(el0, el1);
              return el0;
            },
            buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
              var element0 = dom.childAt(fragment, [1, 1]);
              var element1 = dom.childAt(fragment, [3, 1]);
              var element2 = dom.childAt(element1, [5, 3]);
              var morphs = new Array(6);
              morphs[0] = dom.createElementMorph(element0);
              morphs[1] = dom.createMorphAt(element1,1,1);
              morphs[2] = dom.createMorphAt(element1,3,3);
              morphs[3] = dom.createMorphAt(dom.childAt(element2, [1]),0,0);
              morphs[4] = dom.createMorphAt(dom.childAt(element2, [3]),0,0);
              morphs[5] = dom.createMorphAt(dom.childAt(element2, [5]),0,0);
              return morphs;
            },
            statements: [
              ["element","action",["closeSubview"],[]],
              ["block","gh-form-group",[],["errors",["subexpr","@mut",[["get","model.errors"]],[]],"property","meta_title"],0,null],
              ["block","gh-form-group",[],["errors",["subexpr","@mut",[["get","model.errors"]],[]],"property","meta_description"],1,null],
              ["content","seoTitle"],
              ["content","seoURL"],
              ["content","seoDescription"]
            ],
            locals: [],
            templates: [child0, child1]
          };
        }());
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 99,
                "column": 4
              },
              "end": {
                "line": 134,
                "column": 4
              }
            },
            "moduleName": "ghost/templates/post-settings-menu.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createComment("");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
            var morphs = new Array(1);
            morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
            dom.insertBoundary(fragment, 0);
            dom.insertBoundary(fragment, null);
            return morphs;
          },
          statements: [
            ["block","if",[["get","isViewingSubview"]],[],0,null]
          ],
          locals: [],
          templates: [child0]
        };
      }());
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 1,
              "column": 0
            },
            "end": {
              "line": 137,
              "column": 0
            }
          },
          "moduleName": "ghost/templates/post-settings-menu.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createElement("div");
          dom.setAttribute(el1,"id","entry-controls");
          var el2 = dom.createTextNode("\n    ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("div");
          var el3 = dom.createTextNode("\n        ");
          dom.appendChild(el2, el3);
          var el3 = dom.createElement("div");
          dom.setAttribute(el3,"class","settings-menu-header");
          var el4 = dom.createTextNode("\n            ");
          dom.appendChild(el3, el4);
          var el4 = dom.createElement("h4");
          var el5 = dom.createTextNode("Post Settings");
          dom.appendChild(el4, el5);
          dom.appendChild(el3, el4);
          var el4 = dom.createTextNode("\n            ");
          dom.appendChild(el3, el4);
          var el4 = dom.createElement("button");
          dom.setAttribute(el4,"class","close icon-x settings-menu-header-action");
          var el5 = dom.createElement("span");
          dom.setAttribute(el5,"class","hidden");
          var el6 = dom.createTextNode("Close");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          dom.appendChild(el3, el4);
          var el4 = dom.createTextNode("\n        ");
          dom.appendChild(el3, el4);
          dom.appendChild(el2, el3);
          var el3 = dom.createTextNode("\n        ");
          dom.appendChild(el2, el3);
          var el3 = dom.createElement("div");
          dom.setAttribute(el3,"class","settings-menu-content");
          var el4 = dom.createTextNode("\n            ");
          dom.appendChild(el3, el4);
          var el4 = dom.createComment("");
          dom.appendChild(el3, el4);
          var el4 = dom.createTextNode("\n            ");
          dom.appendChild(el3, el4);
          var el4 = dom.createElement("form");
          var el5 = dom.createTextNode("\n            ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("div");
          dom.setAttribute(el5,"class","form-group");
          var el6 = dom.createTextNode("\n                ");
          dom.appendChild(el5, el6);
          var el6 = dom.createElement("label");
          dom.setAttribute(el6,"for","url");
          var el7 = dom.createTextNode("Post URL");
          dom.appendChild(el6, el7);
          dom.appendChild(el5, el6);
          var el6 = dom.createTextNode("\n");
          dom.appendChild(el5, el6);
          var el6 = dom.createComment("");
          dom.appendChild(el5, el6);
          var el6 = dom.createTextNode("\n                ");
          dom.appendChild(el5, el6);
          var el6 = dom.createElement("span");
          dom.setAttribute(el6,"class","input-icon icon-link");
          var el7 = dom.createTextNode("\n                    ");
          dom.appendChild(el6, el7);
          var el7 = dom.createComment("");
          dom.appendChild(el6, el7);
          var el7 = dom.createTextNode("\n                ");
          dom.appendChild(el6, el7);
          dom.appendChild(el5, el6);
          var el6 = dom.createTextNode("\n                ");
          dom.appendChild(el5, el6);
          var el6 = dom.createComment("");
          dom.appendChild(el5, el6);
          var el6 = dom.createTextNode("\n            ");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n\n");
          dom.appendChild(el4, el5);
          var el5 = dom.createComment("");
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n            ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("div");
          dom.setAttribute(el5,"class","form-group");
          var el6 = dom.createTextNode("\n                ");
          dom.appendChild(el5, el6);
          var el6 = dom.createElement("label");
          dom.setAttribute(el6,"for","tag-input");
          var el7 = dom.createTextNode("Tags");
          dom.appendChild(el6, el7);
          dom.appendChild(el5, el6);
          var el6 = dom.createTextNode("\n                ");
          dom.appendChild(el5, el6);
          var el6 = dom.createComment("");
          dom.appendChild(el5, el6);
          var el6 = dom.createTextNode("\n            ");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n\n");
          dom.appendChild(el4, el5);
          var el5 = dom.createComment("");
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n            ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("ul");
          dom.setAttribute(el5,"class","nav-list nav-list-block");
          var el6 = dom.createTextNode("\n");
          dom.appendChild(el5, el6);
          var el6 = dom.createComment("");
          dom.appendChild(el5, el6);
          var el6 = dom.createTextNode("            ");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n\n            ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("div");
          dom.setAttribute(el5,"class","form-group for-checkbox");
          var el6 = dom.createTextNode("\n                ");
          dom.appendChild(el5, el6);
          var el6 = dom.createElement("label");
          dom.setAttribute(el6,"class","checkbox");
          dom.setAttribute(el6,"for","static-page");
          var el7 = dom.createTextNode("\n                    ");
          dom.appendChild(el6, el7);
          var el7 = dom.createComment("");
          dom.appendChild(el6, el7);
          var el7 = dom.createTextNode("\n                    ");
          dom.appendChild(el6, el7);
          var el7 = dom.createElement("span");
          dom.setAttribute(el7,"class","input-toggle-component");
          dom.appendChild(el6, el7);
          var el7 = dom.createTextNode("\n                    ");
          dom.appendChild(el6, el7);
          var el7 = dom.createElement("p");
          var el8 = dom.createTextNode("Turn this post into a static page");
          dom.appendChild(el7, el8);
          dom.appendChild(el6, el7);
          var el7 = dom.createTextNode("\n                ");
          dom.appendChild(el6, el7);
          dom.appendChild(el5, el6);
          var el6 = dom.createTextNode("\n\n                ");
          dom.appendChild(el5, el6);
          var el6 = dom.createElement("label");
          dom.setAttribute(el6,"class","checkbox");
          dom.setAttribute(el6,"for","featured");
          var el7 = dom.createTextNode("\n                    ");
          dom.appendChild(el6, el7);
          var el7 = dom.createComment("");
          dom.appendChild(el6, el7);
          var el7 = dom.createTextNode("\n                    ");
          dom.appendChild(el6, el7);
          var el7 = dom.createElement("span");
          dom.setAttribute(el7,"class","input-toggle-component");
          dom.appendChild(el6, el7);
          var el7 = dom.createTextNode("\n                    ");
          dom.appendChild(el6, el7);
          var el7 = dom.createElement("p");
          var el8 = dom.createTextNode("Feature this post");
          dom.appendChild(el7, el8);
          dom.appendChild(el6, el7);
          var el7 = dom.createTextNode("\n                ");
          dom.appendChild(el6, el7);
          dom.appendChild(el5, el6);
          var el6 = dom.createTextNode("\n            ");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n\n            ");
          dom.appendChild(el4, el5);
          dom.appendChild(el3, el4);
          var el4 = dom.createTextNode("\n        ");
          dom.appendChild(el3, el4);
          dom.appendChild(el2, el3);
          var el3 = dom.createTextNode("\n    ");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n\n    ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("div");
          var el3 = dom.createTextNode("\n");
          dom.appendChild(el2, el3);
          var el3 = dom.createComment("");
          dom.appendChild(el2, el3);
          var el3 = dom.createTextNode("    ");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var element5 = dom.childAt(fragment, [0]);
          var element6 = dom.childAt(element5, [1]);
          var element7 = dom.childAt(element6, [1, 3]);
          var element8 = dom.childAt(element6, [3]);
          var element9 = dom.childAt(element8, [3]);
          var element10 = dom.childAt(element9, [1]);
          var element11 = dom.childAt(element9, [11]);
          var element12 = dom.childAt(element11, [1]);
          var element13 = dom.childAt(element11, [3]);
          var element14 = dom.childAt(element5, [3]);
          var morphs = new Array(16);
          morphs[0] = dom.createAttrMorph(element6, 'class');
          morphs[1] = dom.createElementMorph(element7);
          morphs[2] = dom.createMorphAt(element8,1,1);
          morphs[3] = dom.createMorphAt(element10,3,3);
          morphs[4] = dom.createMorphAt(dom.childAt(element10, [5]),1,1);
          morphs[5] = dom.createMorphAt(element10,7,7);
          morphs[6] = dom.createMorphAt(element9,3,3);
          morphs[7] = dom.createMorphAt(dom.childAt(element9, [5]),3,3);
          morphs[8] = dom.createMorphAt(element9,7,7);
          morphs[9] = dom.createMorphAt(dom.childAt(element9, [9]),1,1);
          morphs[10] = dom.createElementMorph(element12);
          morphs[11] = dom.createMorphAt(element12,1,1);
          morphs[12] = dom.createElementMorph(element13);
          morphs[13] = dom.createMorphAt(element13,1,1);
          morphs[14] = dom.createAttrMorph(element14, 'class');
          morphs[15] = dom.createMorphAt(element14,1,1);
          return morphs;
        },
        statements: [
          ["attribute","class",["concat",[["subexpr","if",[["get","isViewingSubview"],"settings-menu-pane-out-left","settings-menu-pane-in"],[]]," settings-menu settings-menu-pane"]]],
          ["element","action",["closeMenus"],[]],
          ["inline","gh-uploader",[],["uploaded","setCoverImage","canceled","clearCoverImage","description","Add post image","image",["subexpr","@mut",[["get","model.image"]],[]],"uploaderReference",["subexpr","@mut",[["get","uploaderReference"]],[]],"tagName","section"]],
          ["block","if",[["get","model.isPublished"]],[],0,1],
          ["inline","gh-input",[],["class","post-setting-slug","id","url","value",["subexpr","@mut",[["get","slugValue"]],[]],"name","post-setting-slug","focus-out","updateSlug","selectOnClick","true","stopEnterKeyDownPropagation","true"]],
          ["inline","gh-url-preview",[],["slug",["subexpr","@mut",[["get","slugValue"]],[]],"tagName","p","classNames","description"]],
          ["block","gh-form-group",[],["errors",["subexpr","@mut",[["get","model.errors"]],[]],"property","post-setting-date"],2,null],
          ["inline","gh-selectize",[],["id","tag-input","multiple",true,"selection",["subexpr","@mut",[["get","model.tags"]],[]],"content",["subexpr","@mut",[["get","availableTags"]],[]],"optionValuePath","content.uuid","optionLabelPath","content.name","openOnFocus",false,"create-item","addTag","remove-item","removeTag"]],
          ["block","unless",[["get","session.user.isAuthor"]],[],3,null],
          ["block","gh-tab",[],["tagName","li","classNames","nav-list-item"],4,null],
          ["element","action",["togglePage"],["bubbles","false"]],
          ["inline","input",[],["type","checkbox","name","static-page","id","static-page","class","gh-input post-setting-static-page","checked",["subexpr","@mut",[["get","model.page"]],[]]]],
          ["element","action",["toggleFeatured"],["bubbles","false"]],
          ["inline","input",[],["type","checkbox","name","featured","id","featured","class","gh-input post-setting-featured","checked",["subexpr","@mut",[["get","model.featured"]],[]]]],
          ["attribute","class",["concat",[["subexpr","if",[["get","isViewingSubview"],"settings-menu-pane-in","settings-menu-pane-out-right"],[]]," settings-menu settings-menu-pane"]]],
          ["block","gh-tab-pane",[],[],5,null]
        ],
        locals: [],
        templates: [child0, child1, child2, child3, child4, child5]
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 138,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/post-settings-menu.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(1);
        morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
        dom.insertBoundary(fragment, 0);
        dom.insertBoundary(fragment, null);
        return morphs;
      },
      statements: [
        ["block","gh-tabs-manager",[],["selected","showSubview","id","entry-controls","class","settings-menu-container"],0,null]
      ],
      locals: [],
      templates: [child0]
    };
  }()));

});
define('ghost/templates/posts', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      var child0 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 3,
                "column": 4
              },
              "end": {
                "line": 3,
                "column": 74
              }
            },
            "moduleName": "ghost/templates/posts.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createElement("span");
            var el2 = dom.createTextNode("Content");
            dom.appendChild(el1, el2);
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes() { return []; },
          statements: [

          ],
          locals: [],
          templates: []
        };
      }());
      var child1 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 5,
                "column": 8
              },
              "end": {
                "line": 5,
                "column": 80
              }
            },
            "moduleName": "ghost/templates/posts.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createTextNode("New Post");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes() { return []; },
          statements: [

          ],
          locals: [],
          templates: []
        };
      }());
      var child2 = (function() {
        var child0 = (function() {
          var child0 = (function() {
            var child0 = (function() {
              var child0 = (function() {
                var child0 = (function() {
                  return {
                    meta: {
                      "revision": "Ember@1.13.2",
                      "loc": {
                        "source": null,
                        "start": {
                          "line": 24,
                          "column": 40
                        },
                        "end": {
                          "line": 26,
                          "column": 40
                        }
                      },
                      "moduleName": "ghost/templates/posts.hbs"
                    },
                    arity: 0,
                    cachedFragment: null,
                    hasRendered: false,
                    buildFragment: function buildFragment(dom) {
                      var el0 = dom.createDocumentFragment();
                      var el1 = dom.createTextNode("                                            ");
                      dom.appendChild(el0, el1);
                      var el1 = dom.createElement("span");
                      dom.setAttribute(el1,"class","page");
                      var el2 = dom.createTextNode("Page");
                      dom.appendChild(el1, el2);
                      dom.appendChild(el0, el1);
                      var el1 = dom.createTextNode("\n");
                      dom.appendChild(el0, el1);
                      return el0;
                    },
                    buildRenderNodes: function buildRenderNodes() { return []; },
                    statements: [

                    ],
                    locals: [],
                    templates: []
                  };
                }());
                var child1 = (function() {
                  return {
                    meta: {
                      "revision": "Ember@1.13.2",
                      "loc": {
                        "source": null,
                        "start": {
                          "line": 26,
                          "column": 40
                        },
                        "end": {
                          "line": 30,
                          "column": 40
                        }
                      },
                      "moduleName": "ghost/templates/posts.hbs"
                    },
                    arity: 0,
                    cachedFragment: null,
                    hasRendered: false,
                    buildFragment: function buildFragment(dom) {
                      var el0 = dom.createDocumentFragment();
                      var el1 = dom.createTextNode("                                            ");
                      dom.appendChild(el0, el1);
                      var el1 = dom.createElement("time");
                      dom.setAttribute(el1,"class","date published");
                      var el2 = dom.createTextNode("\n                                                Published ");
                      dom.appendChild(el1, el2);
                      var el2 = dom.createComment("");
                      dom.appendChild(el1, el2);
                      var el2 = dom.createTextNode("\n                                            ");
                      dom.appendChild(el1, el2);
                      dom.appendChild(el0, el1);
                      var el1 = dom.createTextNode("\n");
                      dom.appendChild(el0, el1);
                      return el0;
                    },
                    buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
                      var element0 = dom.childAt(fragment, [1]);
                      var morphs = new Array(2);
                      morphs[0] = dom.createAttrMorph(element0, 'datetime');
                      morphs[1] = dom.createMorphAt(element0,1,1);
                      return morphs;
                    },
                    statements: [
                      ["attribute","datetime",["concat",[["get","post.published_at"]]]],
                      ["inline","gh-format-timeago",[["get","post.published_at"]],[]]
                    ],
                    locals: [],
                    templates: []
                  };
                }());
                return {
                  meta: {
                    "revision": "Ember@1.13.2",
                    "loc": {
                      "source": null,
                      "start": {
                        "line": 23,
                        "column": 36
                      },
                      "end": {
                        "line": 31,
                        "column": 36
                      }
                    },
                    "moduleName": "ghost/templates/posts.hbs"
                  },
                  arity: 0,
                  cachedFragment: null,
                  hasRendered: false,
                  buildFragment: function buildFragment(dom) {
                    var el0 = dom.createDocumentFragment();
                    var el1 = dom.createComment("");
                    dom.appendChild(el0, el1);
                    return el0;
                  },
                  buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
                    var morphs = new Array(1);
                    morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
                    dom.insertBoundary(fragment, 0);
                    dom.insertBoundary(fragment, null);
                    return morphs;
                  },
                  statements: [
                    ["block","if",[["get","post.page"]],[],0,1]
                  ],
                  locals: [],
                  templates: [child0, child1]
                };
              }());
              var child1 = (function() {
                return {
                  meta: {
                    "revision": "Ember@1.13.2",
                    "loc": {
                      "source": null,
                      "start": {
                        "line": 31,
                        "column": 36
                      },
                      "end": {
                        "line": 33,
                        "column": 36
                      }
                    },
                    "moduleName": "ghost/templates/posts.hbs"
                  },
                  arity: 0,
                  cachedFragment: null,
                  hasRendered: false,
                  buildFragment: function buildFragment(dom) {
                    var el0 = dom.createDocumentFragment();
                    var el1 = dom.createTextNode("                                        ");
                    dom.appendChild(el0, el1);
                    var el1 = dom.createElement("span");
                    dom.setAttribute(el1,"class","draft");
                    var el2 = dom.createTextNode("Draft");
                    dom.appendChild(el1, el2);
                    dom.appendChild(el0, el1);
                    var el1 = dom.createTextNode("\n");
                    dom.appendChild(el0, el1);
                    return el0;
                  },
                  buildRenderNodes: function buildRenderNodes() { return []; },
                  statements: [

                  ],
                  locals: [],
                  templates: []
                };
              }());
              return {
                meta: {
                  "revision": "Ember@1.13.2",
                  "loc": {
                    "source": null,
                    "start": {
                      "line": 15,
                      "column": 24
                    },
                    "end": {
                      "line": 36,
                      "column": 24
                    }
                  },
                  "moduleName": "ghost/templates/posts.hbs"
                },
                arity: 0,
                cachedFragment: null,
                hasRendered: false,
                buildFragment: function buildFragment(dom) {
                  var el0 = dom.createDocumentFragment();
                  var el1 = dom.createTextNode("                            ");
                  dom.appendChild(el0, el1);
                  var el1 = dom.createElement("h3");
                  dom.setAttribute(el1,"class","entry-title");
                  var el2 = dom.createComment("");
                  dom.appendChild(el1, el2);
                  dom.appendChild(el0, el1);
                  var el1 = dom.createTextNode("\n                            ");
                  dom.appendChild(el0, el1);
                  var el1 = dom.createElement("section");
                  dom.setAttribute(el1,"class","entry-meta");
                  var el2 = dom.createTextNode("\n                                ");
                  dom.appendChild(el1, el2);
                  var el2 = dom.createElement("span");
                  dom.setAttribute(el2,"class","avatar");
                  var el3 = dom.createTextNode("\n                                    ");
                  dom.appendChild(el2, el3);
                  var el3 = dom.createElement("img");
                  dom.appendChild(el2, el3);
                  var el3 = dom.createTextNode("\n                                ");
                  dom.appendChild(el2, el3);
                  dom.appendChild(el1, el2);
                  var el2 = dom.createTextNode("\n                                ");
                  dom.appendChild(el1, el2);
                  var el2 = dom.createElement("span");
                  dom.setAttribute(el2,"class","author");
                  var el3 = dom.createComment("");
                  dom.appendChild(el2, el3);
                  dom.appendChild(el1, el2);
                  var el2 = dom.createTextNode("\n                                ");
                  dom.appendChild(el1, el2);
                  var el2 = dom.createElement("span");
                  dom.setAttribute(el2,"class","status");
                  var el3 = dom.createTextNode("\n");
                  dom.appendChild(el2, el3);
                  var el3 = dom.createComment("");
                  dom.appendChild(el2, el3);
                  var el3 = dom.createTextNode("                                ");
                  dom.appendChild(el2, el3);
                  dom.appendChild(el1, el2);
                  var el2 = dom.createTextNode("\n                            ");
                  dom.appendChild(el1, el2);
                  dom.appendChild(el0, el1);
                  var el1 = dom.createTextNode("\n");
                  dom.appendChild(el0, el1);
                  return el0;
                },
                buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
                  var element1 = dom.childAt(fragment, [3]);
                  var element2 = dom.childAt(element1, [1]);
                  var element3 = dom.childAt(element2, [1]);
                  var morphs = new Array(6);
                  morphs[0] = dom.createMorphAt(dom.childAt(fragment, [1]),0,0);
                  morphs[1] = dom.createAttrMorph(element2, 'style');
                  morphs[2] = dom.createAttrMorph(element3, 'src');
                  morphs[3] = dom.createAttrMorph(element3, 'title');
                  morphs[4] = dom.createMorphAt(dom.childAt(element1, [3]),0,0);
                  morphs[5] = dom.createMorphAt(dom.childAt(element1, [5]),1,1);
                  return morphs;
                },
                statements: [
                  ["content","post.title"],
                  ["attribute","style",["get","component.authorAvatarBackground"]],
                  ["attribute","src",["concat",[["get","component.authorAvatar"]]]],
                  ["attribute","title",["concat",[["get","component.authorName"]]]],
                  ["content","component.authorName"],
                  ["block","if",[["get","component.isPublished"]],[],0,1]
                ],
                locals: [],
                templates: [child0, child1]
              };
            }());
            return {
              meta: {
                "revision": "Ember@1.13.2",
                "loc": {
                  "source": null,
                  "start": {
                    "line": 14,
                    "column": 20
                  },
                  "end": {
                    "line": 37,
                    "column": 20
                  }
                },
                "moduleName": "ghost/templates/posts.hbs"
              },
              arity: 1,
              cachedFragment: null,
              hasRendered: false,
              buildFragment: function buildFragment(dom) {
                var el0 = dom.createDocumentFragment();
                var el1 = dom.createComment("");
                dom.appendChild(el0, el1);
                return el0;
              },
              buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
                var morphs = new Array(1);
                morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
                dom.insertBoundary(fragment, 0);
                dom.insertBoundary(fragment, null);
                return morphs;
              },
              statements: [
                ["block","link-to",[["get","component.viewOrEdit"],["get","post.id"]],["class","permalink","title","Edit this post"],0,null]
              ],
              locals: ["component"],
              templates: [child0]
            };
          }());
          return {
            meta: {
              "revision": "Ember@1.13.2",
              "loc": {
                "source": null,
                "start": {
                  "line": 13,
                  "column": 16
                },
                "end": {
                  "line": 38,
                  "column": 16
                }
              },
              "moduleName": "ghost/templates/posts.hbs"
            },
            arity: 1,
            cachedFragment: null,
            hasRendered: false,
            buildFragment: function buildFragment(dom) {
              var el0 = dom.createDocumentFragment();
              var el1 = dom.createComment("");
              dom.appendChild(el0, el1);
              return el0;
            },
            buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
              var morphs = new Array(1);
              morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
              dom.insertBoundary(fragment, 0);
              dom.insertBoundary(fragment, null);
              return morphs;
            },
            statements: [
              ["block","gh-posts-list-item",[],["post",["subexpr","@mut",[["get","post"]],[]],"active",["subexpr","is-equal",[["get","post"],["get","currentPost"]],[]],"onDoubleClick","openEditor","previewIsHidden",["subexpr","@mut",[["get","container.previewIsHidden"]],[]]],0,null]
            ],
            locals: ["post"],
            templates: [child0]
          };
        }());
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 11,
                "column": 8
              },
              "end": {
                "line": 40,
                "column": 8
              }
            },
            "moduleName": "ghost/templates/posts.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createTextNode("            ");
            dom.appendChild(el0, el1);
            var el1 = dom.createElement("ol");
            dom.setAttribute(el1,"class","posts-list");
            var el2 = dom.createTextNode("\n");
            dom.appendChild(el1, el2);
            var el2 = dom.createComment("");
            dom.appendChild(el1, el2);
            var el2 = dom.createTextNode("            ");
            dom.appendChild(el1, el2);
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
            var morphs = new Array(1);
            morphs[0] = dom.createMorphAt(dom.childAt(fragment, [1]),1,1);
            return morphs;
          },
          statements: [
            ["block","each",[["get","sortedPosts"]],["key","id"],0,null]
          ],
          locals: [],
          templates: [child0]
        };
      }());
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 1,
              "column": 0
            },
            "end": {
              "line": 46,
              "column": 0
            }
          },
          "moduleName": "ghost/templates/posts.hbs"
        },
        arity: 1,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createElement("header");
          dom.setAttribute(el1,"class","view-header");
          var el2 = dom.createTextNode("\n    ");
          dom.appendChild(el1, el2);
          var el2 = dom.createComment("");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n    ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("section");
          dom.setAttribute(el2,"class","view-actions");
          var el3 = dom.createTextNode("\n        ");
          dom.appendChild(el2, el3);
          var el3 = dom.createComment("");
          dom.appendChild(el2, el3);
          var el3 = dom.createTextNode("\n    ");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n\n");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("div");
          dom.setAttribute(el1,"class","view-container");
          var el2 = dom.createTextNode("\n    ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("section");
          var el3 = dom.createTextNode("\n");
          dom.appendChild(el2, el3);
          var el3 = dom.createComment("");
          dom.appendChild(el2, el3);
          var el3 = dom.createTextNode("    ");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n    ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("section");
          var el3 = dom.createTextNode("\n        ");
          dom.appendChild(el2, el3);
          var el3 = dom.createComment("");
          dom.appendChild(el2, el3);
          var el3 = dom.createTextNode("\n    ");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var element4 = dom.childAt(fragment, [0]);
          var element5 = dom.childAt(fragment, [2]);
          var element6 = dom.childAt(element5, [1]);
          var element7 = dom.childAt(element5, [3]);
          var morphs = new Array(6);
          morphs[0] = dom.createMorphAt(element4,1,1);
          morphs[1] = dom.createMorphAt(dom.childAt(element4, [3]),1,1);
          morphs[2] = dom.createAttrMorph(element6, 'class');
          morphs[3] = dom.createMorphAt(element6,1,1);
          morphs[4] = dom.createAttrMorph(element7, 'class');
          morphs[5] = dom.createMorphAt(element7,1,1);
          return morphs;
        },
        statements: [
          ["block","gh-view-title",[],["openMobileMenu","openMobileMenu"],0,null],
          ["block","link-to",["editor.new"],["class","btn btn-green","title","New Post"],1,null],
          ["attribute","class",["concat",["content-list js-content-list ",["subexpr","if",[["get","postListFocused"],"keyboard-focused"],[]]]]],
          ["block","gh-infinite-scroll-box",[],["tagName","section","classNames","content-list-content js-content-scrollbox","fetch","loadNextPage"],2,null],
          ["attribute","class",["concat",["content-preview js-content-preview ",["subexpr","if",[["get","postContentFocused"],"keyboard-focused"],[]]]]],
          ["content","outlet"]
        ],
        locals: ["container"],
        templates: [child0, child1, child2]
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 47,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/posts.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(1);
        morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
        dom.insertBoundary(fragment, 0);
        dom.insertBoundary(fragment, null);
        return morphs;
      },
      statements: [
        ["block","gh-content-view-container",[],[],0,null]
      ],
      locals: [],
      templates: [child0]
    };
  }()));

});
define('ghost/templates/posts/index', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      var child0 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 5,
                "column": 12
              },
              "end": {
                "line": 5,
                "column": 130
              }
            },
            "moduleName": "ghost/templates/posts/index.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createElement("button");
            dom.setAttribute(el1,"type","button");
            dom.setAttribute(el1,"class","btn btn-green btn-lg");
            dom.setAttribute(el1,"title","New Post");
            var el2 = dom.createTextNode("Write a new Post");
            dom.appendChild(el1, el2);
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes() { return []; },
          statements: [

          ],
          locals: [],
          templates: []
        };
      }());
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 2,
              "column": 4
            },
            "end": {
              "line": 7,
              "column": 4
            }
          },
          "moduleName": "ghost/templates/posts/index.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("        ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("div");
          dom.setAttribute(el1,"class","no-posts");
          var el2 = dom.createTextNode("\n            ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("h3");
          var el3 = dom.createTextNode("You Haven't Written Any Posts Yet!");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n            ");
          dom.appendChild(el1, el2);
          var el2 = dom.createComment("");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n        ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(1);
          morphs[0] = dom.createMorphAt(dom.childAt(fragment, [1]),3,3);
          return morphs;
        },
        statements: [
          ["block","link-to",["editor.new"],[],0,null]
        ],
        locals: [],
        templates: [child0]
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 9,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/posts/index.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createElement("div");
        dom.setAttribute(el1,"class","no-posts-box");
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        var el2 = dom.createComment("");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(1);
        morphs[0] = dom.createMorphAt(dom.childAt(fragment, [0]),1,1);
        return morphs;
      },
      statements: [
        ["block","if",[["get","noPosts"]],[],0,null]
      ],
      locals: [],
      templates: [child0]
    };
  }()));

});
define('ghost/templates/posts/post', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 2,
              "column": 4
            },
            "end": {
              "line": 2,
              "column": 96
            }
          },
          "moduleName": "ghost/templates/posts/post.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createElement("i");
          dom.setAttribute(el1,"class","icon-edit");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes() { return []; },
        statements: [

        ],
        locals: [],
        templates: []
      };
    }());
    var child1 = (function() {
      var child0 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 8,
                "column": 12
              },
              "end": {
                "line": 10,
                "column": 12
              }
            },
            "moduleName": "ghost/templates/posts/post.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createTextNode("                ");
            dom.appendChild(el0, el1);
            var el1 = dom.createComment("");
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
            var morphs = new Array(1);
            morphs[0] = dom.createMorphAt(fragment,1,1,contextualElement);
            return morphs;
          },
          statements: [
            ["content","model.title"]
          ],
          locals: [],
          templates: []
        };
      }());
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 5,
              "column": 0
            },
            "end": {
              "line": 14,
              "column": 0
            }
          },
          "moduleName": "ghost/templates/posts/post.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("div");
          dom.setAttribute(el1,"class","wrapper");
          var el2 = dom.createTextNode("\n        ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("h1");
          dom.setAttribute(el2,"class","content-preview-title");
          var el3 = dom.createTextNode("\n");
          dom.appendChild(el2, el3);
          var el3 = dom.createComment("");
          dom.appendChild(el2, el3);
          var el3 = dom.createTextNode("        ");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n        ");
          dom.appendChild(el1, el2);
          var el2 = dom.createComment("");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n    ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var element0 = dom.childAt(fragment, [1]);
          var morphs = new Array(2);
          morphs[0] = dom.createMorphAt(dom.childAt(element0, [1]),1,1);
          morphs[1] = dom.createMorphAt(element0,3,3);
          return morphs;
        },
        statements: [
          ["block","link-to",["editor.edit",["get","model.id"]],[],0,null],
          ["inline","gh-format-html",[["get","model.html"]],[]]
        ],
        locals: [],
        templates: [child0]
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 15,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/posts/post.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createElement("section");
        dom.setAttribute(el1,"class","post-controls");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createComment("");
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(2);
        morphs[0] = dom.createMorphAt(dom.childAt(fragment, [0]),1,1);
        morphs[1] = dom.createMorphAt(fragment,2,2,contextualElement);
        dom.insertBoundary(fragment, null);
        return morphs;
      },
      statements: [
        ["block","link-to",["editor.edit",["get","model.id"]],["class","btn btn-minor post-edit"],0,null],
        ["block","gh-content-preview-content",[],["tagName","section","content",["subexpr","@mut",[["get","model"]],[]]],1,null]
      ],
      locals: [],
      templates: [child0, child1]
    };
  }()));

});
define('ghost/templates/reset', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 5,
              "column": 16
            },
            "end": {
              "line": 7,
              "column": 16
            }
          },
          "moduleName": "ghost/templates/reset.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(1);
          morphs[0] = dom.createMorphAt(fragment,1,1,contextualElement);
          return morphs;
        },
        statements: [
          ["inline","gh-input",[],["type","password","name","newpassword","placeholder","Password","class","password","autocorrect","off","autofocus","autofocus","value",["subexpr","@mut",[["get","newPassword"]],[]]]]
        ],
        locals: [],
        templates: []
      };
    }());
    var child1 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 8,
              "column": 16
            },
            "end": {
              "line": 10,
              "column": 16
            }
          },
          "moduleName": "ghost/templates/reset.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(1);
          morphs[0] = dom.createMorphAt(fragment,1,1,contextualElement);
          return morphs;
        },
        statements: [
          ["inline","gh-input",[],["type","password","name","ne2password","placeholder","Confirm Password","class","password","autocorrect","off","autofocus","autofocus","value",["subexpr","@mut",[["get","ne2Password"]],[]]]]
        ],
        locals: [],
        templates: []
      };
    }());
    var child2 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 12,
              "column": 16
            },
            "end": {
              "line": 12,
              "column": 134
            }
          },
          "moduleName": "ghost/templates/reset.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("Reset Password");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes() { return []; },
        statements: [

        ],
        locals: [],
        templates: []
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 19,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/reset.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createElement("div");
        dom.setAttribute(el1,"class","gh-flow");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("div");
        dom.setAttribute(el2,"class","gh-flow-content-wrap");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("section");
        dom.setAttribute(el3,"class","gh-flow-content fade-in");
        var el4 = dom.createTextNode("\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createElement("form");
        dom.setAttribute(el4,"id","reset");
        dom.setAttribute(el4,"class","gh-signin");
        dom.setAttribute(el4,"method","post");
        dom.setAttribute(el4,"novalidate","novalidate");
        var el5 = dom.createTextNode("\n");
        dom.appendChild(el4, el5);
        var el5 = dom.createComment("");
        dom.appendChild(el4, el5);
        var el5 = dom.createComment("");
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n                ");
        dom.appendChild(el4, el5);
        var el5 = dom.createComment("");
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n            ");
        dom.appendChild(el4, el5);
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createElement("p");
        dom.setAttribute(el4,"class","main-error");
        var el5 = dom.createComment("");
        dom.appendChild(el4, el5);
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n        ");
        dom.appendChild(el3, el4);
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var element0 = dom.childAt(fragment, [0, 1, 1]);
        var element1 = dom.childAt(element0, [1]);
        var morphs = new Array(5);
        morphs[0] = dom.createElementMorph(element1);
        morphs[1] = dom.createMorphAt(element1,1,1);
        morphs[2] = dom.createMorphAt(element1,2,2);
        morphs[3] = dom.createMorphAt(element1,4,4);
        morphs[4] = dom.createUnsafeMorphAt(dom.childAt(element0, [3]),0,0);
        return morphs;
      },
      statements: [
        ["element","action",["submit"],["on","submit"]],
        ["block","gh-form-group",[],["errors",["subexpr","@mut",[["get","errors"]],[]],"hasValidated",["subexpr","@mut",[["get","hasValidated"]],[]],"property","newPassword"],0,null],
        ["block","gh-form-group",[],["errors",["subexpr","@mut",[["get","errors"]],[]],"hasValidated",["subexpr","@mut",[["get","hasValidated"]],[]],"property","ne2Password"],1,null],
        ["block","gh-spin-button",[],["class","btn btn-blue btn-block","type","submit","submitting",["subexpr","@mut",[["get","submitting"]],[]],"autoWidth","false"],2,null],
        ["content","flowErrors"]
      ],
      locals: [],
      templates: [child0, child1, child2]
    };
  }()));

});
define('ghost/templates/settings/code-injection', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 3,
              "column": 8
            },
            "end": {
              "line": 3,
              "column": 85
            }
          },
          "moduleName": "ghost/templates/settings/code-injection.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createElement("span");
          var el2 = dom.createTextNode("Code Injection");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes() { return []; },
        statements: [

        ],
        locals: [],
        templates: []
      };
    }());
    var child1 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 5,
              "column": 12
            },
            "end": {
              "line": 5,
              "column": 92
            }
          },
          "moduleName": "ghost/templates/settings/code-injection.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("Save");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes() { return []; },
        statements: [

        ],
        locals: [],
        templates: []
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 31,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/settings/code-injection.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createElement("section");
        dom.setAttribute(el1,"class","gh-view");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("header");
        dom.setAttribute(el2,"class","view-header");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createComment("");
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("section");
        dom.setAttribute(el3,"class","view-actions");
        var el4 = dom.createTextNode("\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createComment("");
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n        ");
        dom.appendChild(el3, el4);
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("section");
        dom.setAttribute(el2,"class","view-content");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("form");
        dom.setAttribute(el3,"id","settings-code");
        dom.setAttribute(el3,"novalidate","novalidate");
        var el4 = dom.createTextNode("\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createElement("fieldset");
        var el5 = dom.createTextNode("\n                ");
        dom.appendChild(el4, el5);
        var el5 = dom.createElement("p");
        var el6 = dom.createTextNode("\n                    Ghost allows you to inject code into the top and bottom of your theme files without editing them. This allows for quick modifications to insert useful things like tracking codes and meta tags.\n                ");
        dom.appendChild(el5, el6);
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n\n                ");
        dom.appendChild(el4, el5);
        var el5 = dom.createElement("div");
        dom.setAttribute(el5,"class","form-group settings-code");
        var el6 = dom.createTextNode("\n                    ");
        dom.appendChild(el5, el6);
        var el6 = dom.createElement("label");
        dom.setAttribute(el6,"for","ghost-head");
        var el7 = dom.createTextNode("Blog Header");
        dom.appendChild(el6, el7);
        dom.appendChild(el5, el6);
        var el6 = dom.createTextNode("\n                    ");
        dom.appendChild(el5, el6);
        var el6 = dom.createElement("p");
        var el7 = dom.createTextNode("Code here will be injected into the ");
        dom.appendChild(el6, el7);
        var el7 = dom.createElement("code");
        var el8 = dom.createTextNode("{{ghost_head}}");
        dom.appendChild(el7, el8);
        dom.appendChild(el6, el7);
        var el7 = dom.createTextNode(" tag on every page of your blog");
        dom.appendChild(el6, el7);
        dom.appendChild(el5, el6);
        var el6 = dom.createTextNode("\n                    ");
        dom.appendChild(el5, el6);
        var el6 = dom.createComment("");
        dom.appendChild(el5, el6);
        var el6 = dom.createTextNode("\n                ");
        dom.appendChild(el5, el6);
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n\n                ");
        dom.appendChild(el4, el5);
        var el5 = dom.createElement("div");
        dom.setAttribute(el5,"class","form-group settings-code");
        var el6 = dom.createTextNode("\n                    ");
        dom.appendChild(el5, el6);
        var el6 = dom.createElement("label");
        dom.setAttribute(el6,"for","ghost-foot");
        var el7 = dom.createTextNode("Blog Footer");
        dom.appendChild(el6, el7);
        dom.appendChild(el5, el6);
        var el6 = dom.createTextNode("\n                    ");
        dom.appendChild(el5, el6);
        var el6 = dom.createElement("p");
        var el7 = dom.createTextNode("Code here will be injected into the ");
        dom.appendChild(el6, el7);
        var el7 = dom.createElement("code");
        var el8 = dom.createTextNode("{{ghost_foot}}");
        dom.appendChild(el7, el8);
        dom.appendChild(el6, el7);
        var el7 = dom.createTextNode(" tag on every page of your blog");
        dom.appendChild(el6, el7);
        dom.appendChild(el5, el6);
        var el6 = dom.createTextNode("\n                    ");
        dom.appendChild(el5, el6);
        var el6 = dom.createComment("");
        dom.appendChild(el5, el6);
        var el6 = dom.createTextNode("\n                ");
        dom.appendChild(el5, el6);
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n            ");
        dom.appendChild(el4, el5);
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n        ");
        dom.appendChild(el3, el4);
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var element0 = dom.childAt(fragment, [0]);
        var element1 = dom.childAt(element0, [1]);
        var element2 = dom.childAt(element0, [3, 1, 1]);
        var morphs = new Array(4);
        morphs[0] = dom.createMorphAt(element1,1,1);
        morphs[1] = dom.createMorphAt(dom.childAt(element1, [3]),1,1);
        morphs[2] = dom.createMorphAt(dom.childAt(element2, [3]),5,5);
        morphs[3] = dom.createMorphAt(dom.childAt(element2, [5]),5,5);
        return morphs;
      },
      statements: [
        ["block","gh-view-title",[],["openMobileMenu","openMobileMenu"],0,null],
        ["block","gh-spin-button",[],["class","btn btn-blue","action","save","submitting",["subexpr","@mut",[["get","submitting"]],[]]],1,null],
        ["inline","gh-cm-editor",[],["id","ghost-head","class","gh-input settings-code-editor","name","codeInjection[ghost_head]","type","text","value",["subexpr","@mut",[["get","model.ghost_head"]],[]]]],
        ["inline","gh-cm-editor",[],["id","ghost-foot","class","gh-input settings-code-editor","name","codeInjection[ghost_foot]","type","text","value",["subexpr","@mut",[["get","model.ghost_foot"]],[]]]]
      ],
      locals: [],
      templates: [child0, child1]
    };
  }()));

});
define('ghost/templates/settings/general', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 3,
              "column": 8
            },
            "end": {
              "line": 3,
              "column": 78
            }
          },
          "moduleName": "ghost/templates/settings/general.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createElement("span");
          var el2 = dom.createTextNode("General");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes() { return []; },
        statements: [

        ],
        locals: [],
        templates: []
      };
    }());
    var child1 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 5,
              "column": 12
            },
            "end": {
              "line": 5,
              "column": 92
            }
          },
          "moduleName": "ghost/templates/settings/general.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("Save");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes() { return []; },
        statements: [

        ],
        locals: [],
        templates: []
      };
    }());
    var child2 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 13,
              "column": 16
            },
            "end": {
              "line": 18,
              "column": 16
            }
          },
          "moduleName": "ghost/templates/settings/general.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("label");
          dom.setAttribute(el1,"for","blog-title");
          var el2 = dom.createTextNode("Blog Title");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("p");
          var el2 = dom.createTextNode("The name of your blog");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(2);
          morphs[0] = dom.createMorphAt(fragment,3,3,contextualElement);
          morphs[1] = dom.createMorphAt(fragment,5,5,contextualElement);
          return morphs;
        },
        statements: [
          ["inline","gh-input",[],["id","blog-title","class","gh-input","name","general[title]","type","text","value",["subexpr","@mut",[["get","model.title"]],[]],"focusOut",["subexpr","action",["validate","title"],[]]]],
          ["inline","gh-error-message",[],["errors",["subexpr","@mut",[["get","model.errors"]],[]],"property","title"]]
        ],
        locals: [],
        templates: []
      };
    }());
    var child3 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 20,
              "column": 16
            },
            "end": {
              "line": 28,
              "column": 16
            }
          },
          "moduleName": "ghost/templates/settings/general.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("label");
          dom.setAttribute(el1,"for","blog-description");
          var el2 = dom.createTextNode("Blog Description");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("p");
          var el2 = dom.createTextNode("\n                        Describe what your blog is about\n                        ");
          dom.appendChild(el1, el2);
          var el2 = dom.createComment("");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n                    ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(3);
          morphs[0] = dom.createMorphAt(fragment,3,3,contextualElement);
          morphs[1] = dom.createMorphAt(fragment,5,5,contextualElement);
          morphs[2] = dom.createMorphAt(dom.childAt(fragment, [7]),1,1);
          return morphs;
        },
        statements: [
          ["inline","gh-textarea",[],["id","blog-description","class","gh-input","name","general[description]","value",["subexpr","@mut",[["get","model.description"]],[]],"focusOut",["subexpr","action",["validate","description"],[]]]],
          ["inline","gh-error-message",[],["errors",["subexpr","@mut",[["get","model.errors"]],[]],"property","description"]],
          ["inline","gh-count-characters",[["get","model.description"]],[]]
        ],
        locals: [],
        templates: []
      };
    }());
    var child4 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 33,
              "column": 16
            },
            "end": {
              "line": 35,
              "column": 16
            }
          },
          "moduleName": "ghost/templates/settings/general.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("img");
          dom.setAttribute(el1,"class","blog-logo");
          dom.setAttribute(el1,"alt","logo");
          dom.setAttribute(el1,"role","button");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var element3 = dom.childAt(fragment, [1]);
          var morphs = new Array(2);
          morphs[0] = dom.createAttrMorph(element3, 'src');
          morphs[1] = dom.createElementMorph(element3);
          return morphs;
        },
        statements: [
          ["attribute","src",["concat",[["get","model.logo"]]]],
          ["element","action",["openModal","upload",["get","this"],"logo"],[]]
        ],
        locals: [],
        templates: []
      };
    }());
    var child5 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 35,
              "column": 16
            },
            "end": {
              "line": 37,
              "column": 16
            }
          },
          "moduleName": "ghost/templates/settings/general.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("button");
          dom.setAttribute(el1,"type","button");
          dom.setAttribute(el1,"class","btn btn-green js-modal-logo");
          var el2 = dom.createTextNode("Upload Image");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var element2 = dom.childAt(fragment, [1]);
          var morphs = new Array(1);
          morphs[0] = dom.createElementMorph(element2);
          return morphs;
        },
        statements: [
          ["element","action",["openModal","upload",["get","this"],"logo"],[]]
        ],
        locals: [],
        templates: []
      };
    }());
    var child6 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 43,
              "column": 16
            },
            "end": {
              "line": 45,
              "column": 16
            }
          },
          "moduleName": "ghost/templates/settings/general.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("img");
          dom.setAttribute(el1,"class","blog-cover");
          dom.setAttribute(el1,"alt","cover photo");
          dom.setAttribute(el1,"role","button");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var element1 = dom.childAt(fragment, [1]);
          var morphs = new Array(2);
          morphs[0] = dom.createAttrMorph(element1, 'src');
          morphs[1] = dom.createElementMorph(element1);
          return morphs;
        },
        statements: [
          ["attribute","src",["concat",[["get","model.cover"]]]],
          ["element","action",["openModal","upload",["get","this"],"cover"],[]]
        ],
        locals: [],
        templates: []
      };
    }());
    var child7 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 45,
              "column": 16
            },
            "end": {
              "line": 47,
              "column": 16
            }
          },
          "moduleName": "ghost/templates/settings/general.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("button");
          dom.setAttribute(el1,"type","button");
          dom.setAttribute(el1,"class","btn btn-green js-modal-cover");
          var el2 = dom.createTextNode("Upload Image");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var element0 = dom.childAt(fragment, [1]);
          var morphs = new Array(1);
          morphs[0] = dom.createElementMorph(element0);
          return morphs;
        },
        statements: [
          ["element","action",["openModal","upload",["get","this"],"cover"],[]]
        ],
        locals: [],
        templates: []
      };
    }());
    var child8 = (function() {
      var child0 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 96,
                "column": 16
              },
              "end": {
                "line": 100,
                "column": 16
              }
            },
            "moduleName": "ghost/templates/settings/general.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createTextNode("                    ");
            dom.appendChild(el0, el1);
            var el1 = dom.createComment("");
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n                    ");
            dom.appendChild(el0, el1);
            var el1 = dom.createComment("");
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n                    ");
            dom.appendChild(el0, el1);
            var el1 = dom.createElement("p");
            var el2 = dom.createTextNode("This password will be needed to access your blog. All search engine optimization and social features are now disabled. This password is stored in plaintext.");
            dom.appendChild(el1, el2);
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
            var morphs = new Array(2);
            morphs[0] = dom.createMorphAt(fragment,1,1,contextualElement);
            morphs[1] = dom.createMorphAt(fragment,3,3,contextualElement);
            return morphs;
          },
          statements: [
            ["inline","gh-input",[],["name","general[password]","type","text","value",["subexpr","@mut",[["get","model.password"]],[]],"focusOut",["subexpr","action",["validate","password"],[]]]],
            ["inline","gh-error-message",[],["errors",["subexpr","@mut",[["get","model.errors"]],[]],"property","password"]]
          ],
          locals: [],
          templates: []
        };
      }());
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 95,
              "column": 16
            },
            "end": {
              "line": 101,
              "column": 16
            }
          },
          "moduleName": "ghost/templates/settings/general.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(1);
          morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
          dom.insertBoundary(fragment, 0);
          dom.insertBoundary(fragment, null);
          return morphs;
        },
        statements: [
          ["block","gh-form-group",[],["errors",["subexpr","@mut",[["get","model.errors"]],[]],"hasValidated",["subexpr","@mut",[["get","model.hasValidated"]],[]],"property","password"],0,null]
        ],
        locals: [],
        templates: [child0]
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 106,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/settings/general.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createElement("section");
        dom.setAttribute(el1,"class","gh-view");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("header");
        dom.setAttribute(el2,"class","view-header");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createComment("");
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("section");
        dom.setAttribute(el3,"class","view-actions");
        var el4 = dom.createTextNode("\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createComment("");
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n        ");
        dom.appendChild(el3, el4);
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("section");
        dom.setAttribute(el2,"class","view-content");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("form");
        dom.setAttribute(el3,"id","settings-general");
        dom.setAttribute(el3,"novalidate","novalidate");
        var el4 = dom.createTextNode("\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createElement("fieldset");
        var el5 = dom.createTextNode("\n\n");
        dom.appendChild(el4, el5);
        var el5 = dom.createComment("");
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n");
        dom.appendChild(el4, el5);
        var el5 = dom.createComment("");
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("            ");
        dom.appendChild(el4, el5);
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createElement("div");
        dom.setAttribute(el4,"class","form-group");
        var el5 = dom.createTextNode("\n                ");
        dom.appendChild(el4, el5);
        var el5 = dom.createElement("label");
        var el6 = dom.createTextNode("Blog Logo");
        dom.appendChild(el5, el6);
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n");
        dom.appendChild(el4, el5);
        var el5 = dom.createComment("");
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("                ");
        dom.appendChild(el4, el5);
        var el5 = dom.createElement("p");
        var el6 = dom.createTextNode("Display a sexy logo for your publication");
        dom.appendChild(el5, el6);
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n            ");
        dom.appendChild(el4, el5);
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createElement("div");
        dom.setAttribute(el4,"class","form-group");
        var el5 = dom.createTextNode("\n                ");
        dom.appendChild(el4, el5);
        var el5 = dom.createElement("label");
        var el6 = dom.createTextNode("Blog Cover");
        dom.appendChild(el5, el6);
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n");
        dom.appendChild(el4, el5);
        var el5 = dom.createComment("");
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("                ");
        dom.appendChild(el4, el5);
        var el5 = dom.createElement("p");
        var el6 = dom.createTextNode("Display a cover image on your site");
        dom.appendChild(el5, el6);
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n            ");
        dom.appendChild(el4, el5);
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createElement("fieldset");
        var el5 = dom.createTextNode("\n\n                ");
        dom.appendChild(el4, el5);
        var el5 = dom.createElement("div");
        dom.setAttribute(el5,"class","form-group");
        var el6 = dom.createTextNode("\n                    ");
        dom.appendChild(el5, el6);
        var el6 = dom.createElement("label");
        dom.setAttribute(el6,"for","postsPerPage");
        var el7 = dom.createTextNode("Posts per page");
        dom.appendChild(el6, el7);
        dom.appendChild(el5, el6);
        var el6 = dom.createTextNode("\n                    ");
        dom.appendChild(el5, el6);
        var el6 = dom.createComment("");
        dom.appendChild(el5, el6);
        var el6 = dom.createTextNode("\n                    ");
        dom.appendChild(el5, el6);
        var el6 = dom.createElement("p");
        var el7 = dom.createTextNode("How many posts should be displayed on each page");
        dom.appendChild(el6, el7);
        dom.appendChild(el5, el6);
        var el6 = dom.createTextNode("\n                ");
        dom.appendChild(el5, el6);
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n\n                ");
        dom.appendChild(el4, el5);
        var el5 = dom.createElement("div");
        dom.setAttribute(el5,"class","form-group for-checkbox");
        var el6 = dom.createTextNode("\n                    ");
        dom.appendChild(el5, el6);
        var el6 = dom.createElement("label");
        dom.setAttribute(el6,"for","permalinks");
        var el7 = dom.createTextNode("Dated Permalinks");
        dom.appendChild(el6, el7);
        dom.appendChild(el5, el6);
        var el6 = dom.createTextNode("\n                    ");
        dom.appendChild(el5, el6);
        var el6 = dom.createElement("label");
        dom.setAttribute(el6,"class","checkbox");
        dom.setAttribute(el6,"for","permalinks");
        var el7 = dom.createTextNode("\n                        ");
        dom.appendChild(el6, el7);
        var el7 = dom.createComment("");
        dom.appendChild(el6, el7);
        var el7 = dom.createTextNode("\n                        ");
        dom.appendChild(el6, el7);
        var el7 = dom.createElement("span");
        dom.setAttribute(el7,"class","input-toggle-component");
        dom.appendChild(el6, el7);
        var el7 = dom.createTextNode("\n                        ");
        dom.appendChild(el6, el7);
        var el7 = dom.createElement("p");
        var el8 = dom.createTextNode("Include the date in your post URLs");
        dom.appendChild(el7, el8);
        dom.appendChild(el6, el7);
        var el7 = dom.createTextNode("\n                    ");
        dom.appendChild(el6, el7);
        dom.appendChild(el5, el6);
        var el6 = dom.createTextNode("\n                ");
        dom.appendChild(el5, el6);
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n\n                ");
        dom.appendChild(el4, el5);
        var el5 = dom.createElement("div");
        dom.setAttribute(el5,"class","form-group for-select");
        var el6 = dom.createTextNode("\n                    ");
        dom.appendChild(el5, el6);
        var el6 = dom.createElement("label");
        dom.setAttribute(el6,"for","activeTheme");
        var el7 = dom.createTextNode("Theme");
        dom.appendChild(el6, el7);
        dom.appendChild(el5, el6);
        var el6 = dom.createTextNode("\n                    ");
        dom.appendChild(el5, el6);
        var el6 = dom.createElement("span");
        dom.setAttribute(el6,"class","gh-select");
        dom.setAttribute(el6,"tabindex","0");
        var el7 = dom.createTextNode("\n                        ");
        dom.appendChild(el6, el7);
        var el7 = dom.createComment("");
        dom.appendChild(el6, el7);
        var el7 = dom.createTextNode("\n                   ");
        dom.appendChild(el6, el7);
        dom.appendChild(el5, el6);
        var el6 = dom.createTextNode("\n                    ");
        dom.appendChild(el5, el6);
        var el6 = dom.createElement("p");
        var el7 = dom.createTextNode("Select a theme for your blog");
        dom.appendChild(el6, el7);
        dom.appendChild(el5, el6);
        var el6 = dom.createTextNode("\n                ");
        dom.appendChild(el5, el6);
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n\n                ");
        dom.appendChild(el4, el5);
        var el5 = dom.createElement("div");
        dom.setAttribute(el5,"class","form-group for-checkbox");
        var el6 = dom.createTextNode("\n                    ");
        dom.appendChild(el5, el6);
        var el6 = dom.createElement("label");
        dom.setAttribute(el6,"for","isPrivate");
        var el7 = dom.createTextNode("Make this blog private");
        dom.appendChild(el6, el7);
        dom.appendChild(el5, el6);
        var el6 = dom.createTextNode("\n                    ");
        dom.appendChild(el5, el6);
        var el6 = dom.createElement("label");
        dom.setAttribute(el6,"class","checkbox");
        dom.setAttribute(el6,"for","isPrivate");
        var el7 = dom.createTextNode("\n                        ");
        dom.appendChild(el6, el7);
        var el7 = dom.createComment("");
        dom.appendChild(el6, el7);
        var el7 = dom.createTextNode("\n                        ");
        dom.appendChild(el6, el7);
        var el7 = dom.createElement("span");
        dom.setAttribute(el7,"class","input-toggle-component");
        dom.appendChild(el6, el7);
        var el7 = dom.createTextNode("\n                        ");
        dom.appendChild(el6, el7);
        var el7 = dom.createElement("p");
        var el8 = dom.createTextNode("Enable password protection");
        dom.appendChild(el7, el8);
        dom.appendChild(el6, el7);
        var el7 = dom.createTextNode("\n                    ");
        dom.appendChild(el6, el7);
        dom.appendChild(el5, el6);
        var el6 = dom.createTextNode("\n                ");
        dom.appendChild(el5, el6);
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n\n");
        dom.appendChild(el4, el5);
        var el5 = dom.createComment("");
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("            ");
        dom.appendChild(el4, el5);
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n        ");
        dom.appendChild(el3, el4);
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var element4 = dom.childAt(fragment, [0]);
        var element5 = dom.childAt(element4, [1]);
        var element6 = dom.childAt(element4, [3, 1]);
        var element7 = dom.childAt(element6, [1]);
        var element8 = dom.childAt(element6, [7]);
        var element9 = dom.childAt(element8, [5, 3]);
        var morphs = new Array(12);
        morphs[0] = dom.createMorphAt(element5,1,1);
        morphs[1] = dom.createMorphAt(dom.childAt(element5, [3]),1,1);
        morphs[2] = dom.createMorphAt(element7,1,1);
        morphs[3] = dom.createMorphAt(element7,3,3);
        morphs[4] = dom.createMorphAt(dom.childAt(element6, [3]),3,3);
        morphs[5] = dom.createMorphAt(dom.childAt(element6, [5]),3,3);
        morphs[6] = dom.createMorphAt(dom.childAt(element8, [1]),3,3);
        morphs[7] = dom.createMorphAt(dom.childAt(element8, [3, 3]),1,1);
        morphs[8] = dom.createAttrMorph(element9, 'data-select-text');
        morphs[9] = dom.createMorphAt(element9,1,1);
        morphs[10] = dom.createMorphAt(dom.childAt(element8, [7, 3]),1,1);
        morphs[11] = dom.createMorphAt(element8,9,9);
        return morphs;
      },
      statements: [
        ["block","gh-view-title",[],["openMobileMenu","openMobileMenu"],0,null],
        ["block","gh-spin-button",[],["class","btn btn-blue","action","save","submitting",["subexpr","@mut",[["get","submitting"]],[]]],1,null],
        ["block","gh-form-group",[],["errors",["subexpr","@mut",[["get","model.errors"]],[]],"hasValidated",["subexpr","@mut",[["get","model.hasValidated"]],[]],"property","title"],2,null],
        ["block","gh-form-group",[],["errors",["subexpr","@mut",[["get","model.errors"]],[]],"hasValidated",["subexpr","@mut",[["get","model.hasValidated"]],[]],"property","description","class","description-container"],3,null],
        ["block","if",[["get","model.logo"]],[],4,5],
        ["block","if",[["get","model.cover"]],[],6,7],
        ["inline","gh-input",[],["id","postsPerPage","class","gh-input","name","general[postsPerPage]","focus-out","checkPostsPerPage","value",["subexpr","@mut",[["get","model.postsPerPage"]],[]],"min","1","max","1000","type","number","pattern","[0-9]*"]],
        ["inline","input",[],["id","permalinks","class","gh-input","name","general[permalinks]","type","checkbox","checked",["subexpr","@mut",[["get","isDatedPermalinks"]],[]]]],
        ["attribute","data-select-text",["concat",[["get","selectedTheme.label"]]]],
        ["inline","gh-select-native",[],["id","activeTheme","name","general[activeTheme]","content",["subexpr","@mut",[["get","themes"]],[]],"optionValuePath","name","optionLabelPath","label","selection",["subexpr","@mut",[["get","selectedTheme"]],[]],"action","setTheme"]],
        ["inline","input",[],["id","isPrivate","name","general[isPrivate]","type","checkbox","checked",["subexpr","@mut",[["get","model.isPrivate"]],[]]]],
        ["block","if",[["get","model.isPrivate"]],[],8,null]
      ],
      locals: [],
      templates: [child0, child1, child2, child3, child4, child5, child6, child7, child8]
    };
  }()));

});
define('ghost/templates/settings/labs', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 3,
              "column": 8
            },
            "end": {
              "line": 3,
              "column": 75
            }
          },
          "moduleName": "ghost/templates/settings/labs.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createElement("span");
          var el2 = dom.createTextNode("Labs");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes() { return []; },
        statements: [

        ],
        locals: [],
        templates: []
      };
    }());
    var child1 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 40,
              "column": 20
            },
            "end": {
              "line": 40,
              "column": 128
            }
          },
          "moduleName": "ghost/templates/settings/labs.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("Send");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes() { return []; },
        statements: [

        ],
        locals: [],
        templates: []
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 47,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/settings/labs.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createElement("section");
        dom.setAttribute(el1,"class","gh-view");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("header");
        dom.setAttribute(el2,"class","view-header");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createComment("");
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("section");
        dom.setAttribute(el2,"class","view-content settings-debug");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("p");
        var el4 = dom.createElement("strong");
        var el5 = dom.createTextNode("Important note:");
        dom.appendChild(el4, el5);
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode(" Labs is a testing ground for experimental features which aren't quite ready for primetime. They may change, break or inexplicably disappear at any time.");
        dom.appendChild(el3, el4);
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("form");
        dom.setAttribute(el3,"id","settings-export");
        var el4 = dom.createTextNode("\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createElement("fieldset");
        var el5 = dom.createTextNode("\n                ");
        dom.appendChild(el4, el5);
        var el5 = dom.createElement("div");
        dom.setAttribute(el5,"class","form-group");
        var el6 = dom.createTextNode("\n                    ");
        dom.appendChild(el5, el6);
        var el6 = dom.createElement("label");
        var el7 = dom.createTextNode("Export");
        dom.appendChild(el6, el7);
        dom.appendChild(el5, el6);
        var el6 = dom.createTextNode("\n                    ");
        dom.appendChild(el5, el6);
        var el6 = dom.createElement("button");
        dom.setAttribute(el6,"type","button");
        dom.setAttribute(el6,"class","btn btn-blue");
        var el7 = dom.createTextNode("Export");
        dom.appendChild(el6, el7);
        dom.appendChild(el5, el6);
        var el6 = dom.createTextNode("\n                    ");
        dom.appendChild(el5, el6);
        var el6 = dom.createElement("p");
        var el7 = dom.createTextNode("Export the blog settings and data.");
        dom.appendChild(el6, el7);
        dom.appendChild(el5, el6);
        var el6 = dom.createTextNode("\n                ");
        dom.appendChild(el5, el6);
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n            ");
        dom.appendChild(el4, el5);
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n        ");
        dom.appendChild(el3, el4);
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("form");
        dom.setAttribute(el3,"id","settings-import");
        dom.setAttribute(el3,"enctype","multipart/form-data");
        var el4 = dom.createTextNode("\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createElement("fieldset");
        var el5 = dom.createTextNode("\n                ");
        dom.appendChild(el4, el5);
        var el5 = dom.createElement("div");
        dom.setAttribute(el5,"class","form-group");
        var el6 = dom.createTextNode("\n                    ");
        dom.appendChild(el5, el6);
        var el6 = dom.createElement("label");
        var el7 = dom.createTextNode("Import");
        dom.appendChild(el6, el7);
        dom.appendChild(el5, el6);
        var el6 = dom.createTextNode("\n                    ");
        dom.appendChild(el5, el6);
        var el6 = dom.createComment("");
        dom.appendChild(el5, el6);
        var el6 = dom.createTextNode("\n                    ");
        dom.appendChild(el5, el6);
        var el6 = dom.createComment("");
        dom.appendChild(el5, el6);
        var el6 = dom.createTextNode("\n                    ");
        dom.appendChild(el5, el6);
        var el6 = dom.createElement("p");
        var el7 = dom.createTextNode("Import from another Ghost installation. If you import a user, this will replace the current user & log you out.");
        dom.appendChild(el6, el7);
        dom.appendChild(el5, el6);
        var el6 = dom.createTextNode("\n                ");
        dom.appendChild(el5, el6);
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n            ");
        dom.appendChild(el4, el5);
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n        ");
        dom.appendChild(el3, el4);
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("form");
        dom.setAttribute(el3,"id","settings-resetdb");
        var el4 = dom.createTextNode("\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createElement("fieldset");
        var el5 = dom.createTextNode("\n                ");
        dom.appendChild(el4, el5);
        var el5 = dom.createElement("div");
        dom.setAttribute(el5,"class","form-group");
        var el6 = dom.createTextNode("\n                    ");
        dom.appendChild(el5, el6);
        var el6 = dom.createElement("label");
        var el7 = dom.createTextNode("Delete all Content");
        dom.appendChild(el6, el7);
        dom.appendChild(el5, el6);
        var el6 = dom.createTextNode("\n                    ");
        dom.appendChild(el5, el6);
        var el6 = dom.createElement("button");
        dom.setAttribute(el6,"type","button");
        dom.setAttribute(el6,"class","btn btn-red js-delete");
        var el7 = dom.createTextNode("Delete");
        dom.appendChild(el6, el7);
        dom.appendChild(el5, el6);
        var el6 = dom.createTextNode("\n                    ");
        dom.appendChild(el5, el6);
        var el6 = dom.createElement("p");
        var el7 = dom.createTextNode("Delete all posts and tags from the database.");
        dom.appendChild(el6, el7);
        dom.appendChild(el5, el6);
        var el6 = dom.createTextNode("\n                ");
        dom.appendChild(el5, el6);
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n            ");
        dom.appendChild(el4, el5);
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n        ");
        dom.appendChild(el3, el4);
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("form");
        dom.setAttribute(el3,"id","settings-testmail");
        var el4 = dom.createTextNode("\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createElement("fieldset");
        var el5 = dom.createTextNode("\n                ");
        dom.appendChild(el4, el5);
        var el5 = dom.createElement("div");
        dom.setAttribute(el5,"class","form-group");
        var el6 = dom.createTextNode("\n                    ");
        dom.appendChild(el5, el6);
        var el6 = dom.createElement("label");
        var el7 = dom.createTextNode("Send a test email");
        dom.appendChild(el6, el7);
        dom.appendChild(el5, el6);
        var el6 = dom.createTextNode("\n                    ");
        dom.appendChild(el5, el6);
        var el6 = dom.createComment("");
        dom.appendChild(el5, el6);
        var el6 = dom.createTextNode("\n                    ");
        dom.appendChild(el5, el6);
        var el6 = dom.createElement("p");
        var el7 = dom.createTextNode("Sends a test email to your address.");
        dom.appendChild(el6, el7);
        dom.appendChild(el5, el6);
        var el6 = dom.createTextNode("\n                ");
        dom.appendChild(el5, el6);
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n            ");
        dom.appendChild(el4, el5);
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n        ");
        dom.appendChild(el3, el4);
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var element0 = dom.childAt(fragment, [0]);
        var element1 = dom.childAt(element0, [3]);
        var element2 = dom.childAt(element1, [3, 1, 1, 3]);
        var element3 = dom.childAt(element1, [5, 1, 1]);
        var element4 = dom.childAt(element1, [7, 1, 1, 3]);
        var morphs = new Array(6);
        morphs[0] = dom.createMorphAt(dom.childAt(element0, [1]),1,1);
        morphs[1] = dom.createElementMorph(element2);
        morphs[2] = dom.createMorphAt(element3,3,3);
        morphs[3] = dom.createMorphAt(element3,5,5);
        morphs[4] = dom.createElementMorph(element4);
        morphs[5] = dom.createMorphAt(dom.childAt(element1, [9, 1, 1]),3,3);
        return morphs;
      },
      statements: [
        ["block","gh-view-title",[],["openMobileMenu","openMobileMenu"],0,null],
        ["element","action",["exportData"],[]],
        ["inline","partial",["import-errors"],[]],
        ["inline","gh-file-upload",[],["id","importfile","classNames","flex","uploadButtonText",["subexpr","@mut",[["get","uploadButtonText"]],[]],"onUpload","onUpload"]],
        ["element","action",["openModal","deleteAll"],[]],
        ["block","gh-spin-button",[],["id","sendtestemail","class","btn btn-blue","action","sendTestEmail","submitting",["subexpr","@mut",[["get","submitting"]],[]]],1,null]
      ],
      locals: [],
      templates: [child0, child1]
    };
  }()));

});
define('ghost/templates/settings/navigation', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      var child0 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 3,
                "column": 8
              },
              "end": {
                "line": 3,
                "column": 81
              }
            },
            "moduleName": "ghost/templates/settings/navigation.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createElement("span");
            var el2 = dom.createTextNode("Navigation");
            dom.appendChild(el1, el2);
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes() { return []; },
          statements: [

          ],
          locals: [],
          templates: []
        };
      }());
      var child1 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 5,
                "column": 12
              },
              "end": {
                "line": 5,
                "column": 92
              }
            },
            "moduleName": "ghost/templates/settings/navigation.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createTextNode("Save");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes() { return []; },
          statements: [

          ],
          locals: [],
          templates: []
        };
      }());
      var child2 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 11,
                "column": 12
              },
              "end": {
                "line": 13,
                "column": 12
              }
            },
            "moduleName": "ghost/templates/settings/navigation.hbs"
          },
          arity: 1,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createTextNode("                ");
            dom.appendChild(el0, el1);
            var el1 = dom.createComment("");
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
            var morphs = new Array(1);
            morphs[0] = dom.createMorphAt(fragment,1,1,contextualElement);
            return morphs;
          },
          statements: [
            ["inline","gh-navitem",[],["navItem",["subexpr","@mut",[["get","navItem"]],[]],"baseUrl",["subexpr","@mut",[["get","blogUrl"]],[]],"addItem","addItem","deleteItem","deleteItem","updateUrl","updateUrl"]]
          ],
          locals: ["navItem"],
          templates: []
        };
      }());
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 1,
              "column": 0
            },
            "end": {
              "line": 16,
              "column": 0
            }
          },
          "moduleName": "ghost/templates/settings/navigation.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("header");
          dom.setAttribute(el1,"class","view-header");
          var el2 = dom.createTextNode("\n        ");
          dom.appendChild(el1, el2);
          var el2 = dom.createComment("");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n        ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("section");
          dom.setAttribute(el2,"class","view-actions");
          var el3 = dom.createTextNode("\n            ");
          dom.appendChild(el2, el3);
          var el3 = dom.createComment("");
          dom.appendChild(el2, el3);
          var el3 = dom.createTextNode("\n        ");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n    ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n\n    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("section");
          dom.setAttribute(el1,"class","view-container");
          var el2 = dom.createTextNode("\n        ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("form");
          dom.setAttribute(el2,"id","settings-navigation");
          dom.setAttribute(el2,"class","gh-blognav js-gh-blognav");
          dom.setAttribute(el2,"novalidate","novalidate");
          var el3 = dom.createTextNode("\n");
          dom.appendChild(el2, el3);
          var el3 = dom.createComment("");
          dom.appendChild(el2, el3);
          var el3 = dom.createTextNode("        ");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n    ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var element0 = dom.childAt(fragment, [1]);
          var morphs = new Array(3);
          morphs[0] = dom.createMorphAt(element0,1,1);
          morphs[1] = dom.createMorphAt(dom.childAt(element0, [3]),1,1);
          morphs[2] = dom.createMorphAt(dom.childAt(fragment, [3, 1]),1,1);
          return morphs;
        },
        statements: [
          ["block","gh-view-title",[],["openMobileMenu","openMobileMenu"],0,null],
          ["block","gh-spin-button",[],["class","btn btn-blue","action","save","submitting",["subexpr","@mut",[["get","submitting"]],[]]],1,null],
          ["block","each",[["get","navigationItems"]],[],2,null]
        ],
        locals: [],
        templates: [child0, child1, child2]
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 17,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/settings/navigation.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(1);
        morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
        dom.insertBoundary(fragment, 0);
        dom.insertBoundary(fragment, null);
        return morphs;
      },
      statements: [
        ["block","gh-navigation",[],["moveItem","moveItem"],0,null]
      ],
      locals: [],
      templates: [child0]
    };
  }()));

});
define('ghost/templates/settings/tags', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 3,
              "column": 8
            },
            "end": {
              "line": 3,
              "column": 75
            }
          },
          "moduleName": "ghost/templates/settings/tags.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createElement("span");
          var el2 = dom.createTextNode("Tags");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes() { return []; },
        statements: [

        ],
        locals: [],
        templates: []
      };
    }());
    var child1 = (function() {
      var child0 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 15,
                "column": 8
              },
              "end": {
                "line": 24,
                "column": 8
              }
            },
            "moduleName": "ghost/templates/settings/tags.hbs"
          },
          arity: 1,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createTextNode("            ");
            dom.appendChild(el0, el1);
            var el1 = dom.createElement("div");
            dom.setAttribute(el1,"class","settings-tag");
            var el2 = dom.createTextNode("\n                ");
            dom.appendChild(el1, el2);
            var el2 = dom.createElement("button");
            dom.setAttribute(el2,"class","tag-edit-button");
            var el3 = dom.createTextNode("\n                    ");
            dom.appendChild(el2, el3);
            var el3 = dom.createElement("span");
            dom.setAttribute(el3,"class","tag-title");
            var el4 = dom.createComment("");
            dom.appendChild(el3, el4);
            dom.appendChild(el2, el3);
            var el3 = dom.createTextNode("\n                    ");
            dom.appendChild(el2, el3);
            var el3 = dom.createElement("span");
            dom.setAttribute(el3,"class","label label-default");
            var el4 = dom.createTextNode("/");
            dom.appendChild(el3, el4);
            var el4 = dom.createComment("");
            dom.appendChild(el3, el4);
            dom.appendChild(el2, el3);
            var el3 = dom.createTextNode("\n                    ");
            dom.appendChild(el2, el3);
            var el3 = dom.createElement("p");
            dom.setAttribute(el3,"class","tag-description");
            var el4 = dom.createComment("");
            dom.appendChild(el3, el4);
            dom.appendChild(el2, el3);
            var el3 = dom.createTextNode("\n                    ");
            dom.appendChild(el2, el3);
            var el3 = dom.createElement("span");
            dom.setAttribute(el3,"class","tags-count");
            var el4 = dom.createComment("");
            dom.appendChild(el3, el4);
            dom.appendChild(el2, el3);
            var el3 = dom.createTextNode("\n                ");
            dom.appendChild(el2, el3);
            dom.appendChild(el1, el2);
            var el2 = dom.createTextNode("\n            ");
            dom.appendChild(el1, el2);
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
            var element0 = dom.childAt(fragment, [1, 1]);
            var morphs = new Array(5);
            morphs[0] = dom.createElementMorph(element0);
            morphs[1] = dom.createMorphAt(dom.childAt(element0, [1]),0,0);
            morphs[2] = dom.createMorphAt(dom.childAt(element0, [3]),1,1);
            morphs[3] = dom.createMorphAt(dom.childAt(element0, [5]),0,0);
            morphs[4] = dom.createMorphAt(dom.childAt(element0, [7]),0,0);
            return morphs;
          },
          statements: [
            ["element","action",["editTag",["get","tag"]],[]],
            ["content","tag.name"],
            ["content","tag.slug"],
            ["content","tag.description"],
            ["content","tag.post_count"]
          ],
          locals: ["tag"],
          templates: []
        };
      }());
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 9,
              "column": 4
            },
            "end": {
              "line": 25,
              "column": 4
            }
          },
          "moduleName": "ghost/templates/settings/tags.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(1);
          morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
          dom.insertBoundary(fragment, 0);
          dom.insertBoundary(fragment, null);
          return morphs;
        },
        statements: [
          ["block","each",[["get","tags"]],[],0,null]
        ],
        locals: [],
        templates: [child0]
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 27,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/settings/tags.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createElement("section");
        dom.setAttribute(el1,"class","gh-view");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("header");
        dom.setAttribute(el2,"class","view-header");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createComment("");
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("section");
        dom.setAttribute(el3,"class","view-actions");
        var el4 = dom.createTextNode("\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createElement("button");
        dom.setAttribute(el4,"type","button");
        dom.setAttribute(el4,"class","btn btn-green");
        var el5 = dom.createTextNode("New Tag");
        dom.appendChild(el4, el5);
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n        ");
        dom.appendChild(el3, el4);
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n\n");
        dom.appendChild(el1, el2);
        var el2 = dom.createComment("");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var element1 = dom.childAt(fragment, [0]);
        var element2 = dom.childAt(element1, [1]);
        var element3 = dom.childAt(element2, [3, 1]);
        var morphs = new Array(3);
        morphs[0] = dom.createMorphAt(element2,1,1);
        morphs[1] = dom.createElementMorph(element3);
        morphs[2] = dom.createMorphAt(element1,3,3);
        return morphs;
      },
      statements: [
        ["block","gh-view-title",[],["openMobileMenu","openMobileMenu"],0,null],
        ["element","action",["newTag"],[]],
        ["block","gh-infinite-scroll",[],["fetch","loadNextPage","isLoading",["subexpr","@mut",[["get","isLoading"]],[]],"tagName","section","classNames","view-container settings-tags"],1,null]
      ],
      locals: [],
      templates: [child0, child1]
    };
  }()));

});
define('ghost/templates/settings/tags/settings-menu', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      var child0 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 13,
                "column": 20
              },
              "end": {
                "line": 17,
                "column": 20
              }
            },
            "moduleName": "ghost/templates/settings/tags/settings-menu.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createTextNode("                        ");
            dom.appendChild(el0, el1);
            var el1 = dom.createElement("label");
            dom.setAttribute(el1,"for","tag-name");
            var el2 = dom.createTextNode("Name");
            dom.appendChild(el1, el2);
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n                        ");
            dom.appendChild(el0, el1);
            var el1 = dom.createComment("");
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n                        ");
            dom.appendChild(el0, el1);
            var el1 = dom.createComment("");
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
            var morphs = new Array(2);
            morphs[0] = dom.createMorphAt(fragment,3,3,contextualElement);
            morphs[1] = dom.createMorphAt(fragment,5,5,contextualElement);
            return morphs;
          },
          statements: [
            ["inline","gh-input",[],["id","tag-name","name","name","type","text","value",["subexpr","@mut",[["get","activeTagNameScratch"]],[]],"focus-out","saveActiveTagName"]],
            ["inline","gh-error-message",[],["errors",["subexpr","@mut",[["get","activeTag.errors"]],[]],"property","name"]]
          ],
          locals: [],
          templates: []
        };
      }());
      var child1 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 31,
                "column": 24
              },
              "end": {
                "line": 37,
                "column": 24
              }
            },
            "moduleName": "ghost/templates/settings/tags/settings-menu.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createTextNode("                            ");
            dom.appendChild(el0, el1);
            var el1 = dom.createElement("button");
            dom.setAttribute(el1,"type","button");
            dom.setAttribute(el1,"class","meta-data-button");
            var el2 = dom.createTextNode("\n                                ");
            dom.appendChild(el1, el2);
            var el2 = dom.createElement("b");
            var el3 = dom.createTextNode("Meta Data");
            dom.appendChild(el2, el3);
            dom.appendChild(el1, el2);
            var el2 = dom.createTextNode("\n                                ");
            dom.appendChild(el1, el2);
            var el2 = dom.createElement("span");
            var el3 = dom.createTextNode("Extra content for SEO and social media.");
            dom.appendChild(el2, el3);
            dom.appendChild(el1, el2);
            var el2 = dom.createTextNode("\n                            ");
            dom.appendChild(el1, el2);
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n                            ");
            dom.appendChild(el0, el1);
            var el1 = dom.createElement("i");
            dom.setAttribute(el1,"class","icon-arrow-right");
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes() { return []; },
          statements: [

          ],
          locals: [],
          templates: []
        };
      }());
      var child2 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 40,
                "column": 20
              },
              "end": {
                "line": 42,
                "column": 20
              }
            },
            "moduleName": "ghost/templates/settings/tags/settings-menu.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createTextNode("                        ");
            dom.appendChild(el0, el1);
            var el1 = dom.createElement("button");
            dom.setAttribute(el1,"type","button");
            dom.setAttribute(el1,"class","btn btn-link btn-sm tag-delete-button");
            var el2 = dom.createElement("i");
            dom.setAttribute(el2,"class","icon-trash");
            dom.appendChild(el1, el2);
            var el2 = dom.createTextNode(" Delete Tag");
            dom.appendChild(el1, el2);
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
            var element3 = dom.childAt(fragment, [1]);
            var morphs = new Array(1);
            morphs[0] = dom.createElementMorph(element3);
            return morphs;
          },
          statements: [
            ["element","action",["openModal","delete-tag",["get","activeTag"]],[]]
          ],
          locals: [],
          templates: []
        };
      }());
      var child3 = (function() {
        var child0 = (function() {
          var child0 = (function() {
            return {
              meta: {
                "revision": "Ember@1.13.2",
                "loc": {
                  "source": null,
                  "start": {
                    "line": 58,
                    "column": 20
                  },
                  "end": {
                    "line": 63,
                    "column": 20
                  }
                },
                "moduleName": "ghost/templates/settings/tags/settings-menu.hbs"
              },
              arity: 0,
              cachedFragment: null,
              hasRendered: false,
              buildFragment: function buildFragment(dom) {
                var el0 = dom.createDocumentFragment();
                var el1 = dom.createTextNode("                        ");
                dom.appendChild(el0, el1);
                var el1 = dom.createElement("label");
                dom.setAttribute(el1,"for","meta-title");
                var el2 = dom.createTextNode("Meta Title");
                dom.appendChild(el1, el2);
                dom.appendChild(el0, el1);
                var el1 = dom.createTextNode("\n                        ");
                dom.appendChild(el0, el1);
                var el1 = dom.createComment("");
                dom.appendChild(el0, el1);
                var el1 = dom.createTextNode("\n                        ");
                dom.appendChild(el0, el1);
                var el1 = dom.createComment("");
                dom.appendChild(el0, el1);
                var el1 = dom.createTextNode("\n                        ");
                dom.appendChild(el0, el1);
                var el1 = dom.createElement("p");
                var el2 = dom.createTextNode("Recommended: ");
                dom.appendChild(el1, el2);
                var el2 = dom.createElement("b");
                var el3 = dom.createTextNode("70");
                dom.appendChild(el2, el3);
                dom.appendChild(el1, el2);
                var el2 = dom.createTextNode(" characters. You’ve used ");
                dom.appendChild(el1, el2);
                var el2 = dom.createComment("");
                dom.appendChild(el1, el2);
                dom.appendChild(el0, el1);
                var el1 = dom.createTextNode("\n");
                dom.appendChild(el0, el1);
                return el0;
              },
              buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
                var morphs = new Array(3);
                morphs[0] = dom.createMorphAt(fragment,3,3,contextualElement);
                morphs[1] = dom.createMorphAt(fragment,5,5,contextualElement);
                morphs[2] = dom.createMorphAt(dom.childAt(fragment, [7]),3,3);
                return morphs;
              },
              statements: [
                ["inline","gh-input",[],["id","meta-title","name","meta_title","type","text","value",["subexpr","@mut",[["get","activeTagMetaTitleScratch"]],[]],"focus-out","saveActiveTagMetaTitle"]],
                ["inline","gh-error-message",[],["errors",["subexpr","@mut",[["get","activeTag.errors"]],[]],"property","meta_title"]],
                ["inline","gh-count-down-characters",[["get","activeTagMetaTitleScratch"],70],[]]
              ],
              locals: [],
              templates: []
            };
          }());
          var child1 = (function() {
            return {
              meta: {
                "revision": "Ember@1.13.2",
                "loc": {
                  "source": null,
                  "start": {
                    "line": 65,
                    "column": 20
                  },
                  "end": {
                    "line": 70,
                    "column": 20
                  }
                },
                "moduleName": "ghost/templates/settings/tags/settings-menu.hbs"
              },
              arity: 0,
              cachedFragment: null,
              hasRendered: false,
              buildFragment: function buildFragment(dom) {
                var el0 = dom.createDocumentFragment();
                var el1 = dom.createTextNode("                        ");
                dom.appendChild(el0, el1);
                var el1 = dom.createElement("label");
                dom.setAttribute(el1,"for","meta-description");
                var el2 = dom.createTextNode("Meta Description");
                dom.appendChild(el1, el2);
                dom.appendChild(el0, el1);
                var el1 = dom.createTextNode("\n                        ");
                dom.appendChild(el0, el1);
                var el1 = dom.createComment("");
                dom.appendChild(el0, el1);
                var el1 = dom.createTextNode("\n                        ");
                dom.appendChild(el0, el1);
                var el1 = dom.createComment("");
                dom.appendChild(el0, el1);
                var el1 = dom.createTextNode("\n                        ");
                dom.appendChild(el0, el1);
                var el1 = dom.createElement("p");
                var el2 = dom.createTextNode("Recommended: ");
                dom.appendChild(el1, el2);
                var el2 = dom.createElement("b");
                var el3 = dom.createTextNode("156");
                dom.appendChild(el2, el3);
                dom.appendChild(el1, el2);
                var el2 = dom.createTextNode(" characters. You’ve used ");
                dom.appendChild(el1, el2);
                var el2 = dom.createComment("");
                dom.appendChild(el1, el2);
                dom.appendChild(el0, el1);
                var el1 = dom.createTextNode("\n");
                dom.appendChild(el0, el1);
                return el0;
              },
              buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
                var morphs = new Array(3);
                morphs[0] = dom.createMorphAt(fragment,3,3,contextualElement);
                morphs[1] = dom.createMorphAt(fragment,5,5,contextualElement);
                morphs[2] = dom.createMorphAt(dom.childAt(fragment, [7]),3,3);
                return morphs;
              },
              statements: [
                ["inline","gh-textarea",[],["id","meta-description","name","meta_description","value",["subexpr","@mut",[["get","activeTagMetaDescriptionScratch"]],[]],"focus-out","saveActiveTagMetaDescription"]],
                ["inline","gh-error-message",[],["errors",["subexpr","@mut",[["get","activeTag.errors"]],[]],"property","meta_description"]],
                ["inline","gh-count-down-characters",[["get","activeTagMetaDescriptionScratch"],156],[]]
              ],
              locals: [],
              templates: []
            };
          }());
          return {
            meta: {
              "revision": "Ember@1.13.2",
              "loc": {
                "source": null,
                "start": {
                  "line": 49,
                  "column": 16
                },
                "end": {
                  "line": 82,
                  "column": 16
                }
              },
              "moduleName": "ghost/templates/settings/tags/settings-menu.hbs"
            },
            arity: 0,
            cachedFragment: null,
            hasRendered: false,
            buildFragment: function buildFragment(dom) {
              var el0 = dom.createDocumentFragment();
              var el1 = dom.createTextNode("                ");
              dom.appendChild(el0, el1);
              var el1 = dom.createElement("div");
              dom.setAttribute(el1,"class","settings-menu-header subview");
              var el2 = dom.createTextNode("\n                    ");
              dom.appendChild(el1, el2);
              var el2 = dom.createElement("button");
              dom.setAttribute(el2,"class","back icon-arrow-left settings-menu-header-action");
              var el3 = dom.createElement("span");
              dom.setAttribute(el3,"class","hidden");
              var el4 = dom.createTextNode("Back");
              dom.appendChild(el3, el4);
              dom.appendChild(el2, el3);
              dom.appendChild(el1, el2);
              var el2 = dom.createTextNode("\n                    ");
              dom.appendChild(el1, el2);
              var el2 = dom.createElement("h4");
              var el3 = dom.createTextNode("Meta Data");
              dom.appendChild(el2, el3);
              dom.appendChild(el1, el2);
              var el2 = dom.createTextNode("\n                    ");
              dom.appendChild(el1, el2);
              var el2 = dom.createElement("div");
              dom.setAttribute(el2,"style","width:23px;");
              dom.appendChild(el1, el2);
              var el2 = dom.createTextNode("\n                ");
              dom.appendChild(el1, el2);
              dom.appendChild(el0, el1);
              var el1 = dom.createTextNode("\n\n                ");
              dom.appendChild(el0, el1);
              var el1 = dom.createElement("div");
              dom.setAttribute(el1,"class","settings-menu-content");
              var el2 = dom.createTextNode("\n                    ");
              dom.appendChild(el1, el2);
              var el2 = dom.createElement("form");
              var el3 = dom.createTextNode("\n");
              dom.appendChild(el2, el3);
              var el3 = dom.createComment("");
              dom.appendChild(el2, el3);
              var el3 = dom.createTextNode("\n");
              dom.appendChild(el2, el3);
              var el3 = dom.createComment("");
              dom.appendChild(el2, el3);
              var el3 = dom.createTextNode("\n                    ");
              dom.appendChild(el2, el3);
              var el3 = dom.createElement("div");
              dom.setAttribute(el3,"class","form-group");
              var el4 = dom.createTextNode("\n                        ");
              dom.appendChild(el3, el4);
              var el4 = dom.createElement("label");
              var el5 = dom.createTextNode("Search Engine Result Preview");
              dom.appendChild(el4, el5);
              dom.appendChild(el3, el4);
              var el4 = dom.createTextNode("\n                        ");
              dom.appendChild(el3, el4);
              var el4 = dom.createElement("div");
              dom.setAttribute(el4,"class","seo-preview");
              var el5 = dom.createTextNode("\n                            ");
              dom.appendChild(el4, el5);
              var el5 = dom.createElement("div");
              dom.setAttribute(el5,"class","seo-preview-title");
              var el6 = dom.createComment("");
              dom.appendChild(el5, el6);
              dom.appendChild(el4, el5);
              var el5 = dom.createTextNode("\n                            ");
              dom.appendChild(el4, el5);
              var el5 = dom.createElement("div");
              dom.setAttribute(el5,"class","seo-preview-link");
              var el6 = dom.createComment("");
              dom.appendChild(el5, el6);
              dom.appendChild(el4, el5);
              var el5 = dom.createTextNode("\n                            ");
              dom.appendChild(el4, el5);
              var el5 = dom.createElement("div");
              dom.setAttribute(el5,"class","seo-preview-description");
              var el6 = dom.createComment("");
              dom.appendChild(el5, el6);
              dom.appendChild(el4, el5);
              var el5 = dom.createTextNode("\n                        ");
              dom.appendChild(el4, el5);
              dom.appendChild(el3, el4);
              var el4 = dom.createTextNode("\n                    ");
              dom.appendChild(el3, el4);
              dom.appendChild(el2, el3);
              var el3 = dom.createTextNode("\n                    ");
              dom.appendChild(el2, el3);
              dom.appendChild(el1, el2);
              var el2 = dom.createTextNode("\n                ");
              dom.appendChild(el1, el2);
              dom.appendChild(el0, el1);
              var el1 = dom.createTextNode("\n");
              dom.appendChild(el0, el1);
              return el0;
            },
            buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
              var element0 = dom.childAt(fragment, [1, 1]);
              var element1 = dom.childAt(fragment, [3, 1]);
              var element2 = dom.childAt(element1, [5, 3]);
              var morphs = new Array(6);
              morphs[0] = dom.createElementMorph(element0);
              morphs[1] = dom.createMorphAt(element1,1,1);
              morphs[2] = dom.createMorphAt(element1,3,3);
              morphs[3] = dom.createMorphAt(dom.childAt(element2, [1]),0,0);
              morphs[4] = dom.createMorphAt(dom.childAt(element2, [3]),0,0);
              morphs[5] = dom.createMorphAt(dom.childAt(element2, [5]),0,0);
              return morphs;
            },
            statements: [
              ["element","action",["closeSubview"],[]],
              ["block","gh-form-group",[],["errors",["subexpr","@mut",[["get","activeTag.errors"]],[]],"hasValidated",["subexpr","@mut",[["get","activeTag.hasValidated"]],[]],"property","meta_title"],0,null],
              ["block","gh-form-group",[],["errors",["subexpr","@mut",[["get","activeTag.errors"]],[]],"hasValidated",["subexpr","@mut",[["get","activeTag.hasValidated"]],[]],"property","meta_description"],1,null],
              ["content","seoTitle"],
              ["content","seoURL"],
              ["content","seoDescription"]
            ],
            locals: [],
            templates: [child0, child1]
          };
        }());
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 48,
                "column": 12
              },
              "end": {
                "line": 83,
                "column": 12
              }
            },
            "moduleName": "ghost/templates/settings/tags/settings-menu.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createComment("");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
            var morphs = new Array(1);
            morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
            dom.insertBoundary(fragment, 0);
            dom.insertBoundary(fragment, null);
            return morphs;
          },
          statements: [
            ["block","if",[["get","isViewingSubview"]],[],0,null]
          ],
          locals: [],
          templates: [child0]
        };
      }());
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 2,
              "column": 4
            },
            "end": {
              "line": 85,
              "column": 4
            }
          },
          "moduleName": "ghost/templates/settings/tags/settings-menu.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("        ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("div");
          var el2 = dom.createTextNode("\n            ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("div");
          dom.setAttribute(el2,"class","settings-menu-header");
          var el3 = dom.createTextNode("\n                ");
          dom.appendChild(el2, el3);
          var el3 = dom.createElement("h4");
          var el4 = dom.createTextNode("Tag Settings");
          dom.appendChild(el3, el4);
          dom.appendChild(el2, el3);
          var el3 = dom.createTextNode("\n                ");
          dom.appendChild(el2, el3);
          var el3 = dom.createElement("button");
          dom.setAttribute(el3,"class","close icon-x settings-menu-header-action");
          var el4 = dom.createTextNode("\n                    ");
          dom.appendChild(el3, el4);
          var el4 = dom.createElement("span");
          dom.setAttribute(el4,"class","hidden");
          var el5 = dom.createTextNode("Close");
          dom.appendChild(el4, el5);
          dom.appendChild(el3, el4);
          var el4 = dom.createTextNode("\n                ");
          dom.appendChild(el3, el4);
          dom.appendChild(el2, el3);
          var el3 = dom.createTextNode("\n            ");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n            ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("div");
          dom.setAttribute(el2,"class","settings-menu-content");
          var el3 = dom.createTextNode("\n                ");
          dom.appendChild(el2, el3);
          var el3 = dom.createComment("");
          dom.appendChild(el2, el3);
          var el3 = dom.createTextNode("\n                ");
          dom.appendChild(el2, el3);
          var el3 = dom.createElement("form");
          var el4 = dom.createTextNode("\n");
          dom.appendChild(el3, el4);
          var el4 = dom.createComment("");
          dom.appendChild(el3, el4);
          var el4 = dom.createTextNode("\n                    ");
          dom.appendChild(el3, el4);
          var el4 = dom.createElement("div");
          dom.setAttribute(el4,"class","form-group");
          var el5 = dom.createTextNode("\n                        ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("label");
          dom.setAttribute(el5,"for","tag-url");
          var el6 = dom.createTextNode("URL");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n                        ");
          dom.appendChild(el4, el5);
          var el5 = dom.createComment("");
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n                        ");
          dom.appendChild(el4, el5);
          var el5 = dom.createComment("");
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n                    ");
          dom.appendChild(el4, el5);
          dom.appendChild(el3, el4);
          var el4 = dom.createTextNode("\n\n                    ");
          dom.appendChild(el3, el4);
          var el4 = dom.createElement("div");
          dom.setAttribute(el4,"class","form-group");
          var el5 = dom.createTextNode("\n                        ");
          dom.appendChild(el4, el5);
          var el5 = dom.createElement("label");
          dom.setAttribute(el5,"for","tag-description");
          var el6 = dom.createTextNode("Description");
          dom.appendChild(el5, el6);
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n                        ");
          dom.appendChild(el4, el5);
          var el5 = dom.createComment("");
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("\n                    ");
          dom.appendChild(el4, el5);
          dom.appendChild(el3, el4);
          var el4 = dom.createTextNode("\n\n                    ");
          dom.appendChild(el3, el4);
          var el4 = dom.createElement("ul");
          dom.setAttribute(el4,"class","nav-list nav-list-block");
          var el5 = dom.createTextNode("\n");
          dom.appendChild(el4, el5);
          var el5 = dom.createComment("");
          dom.appendChild(el4, el5);
          var el5 = dom.createTextNode("                    ");
          dom.appendChild(el4, el5);
          dom.appendChild(el3, el4);
          var el4 = dom.createTextNode("\n\n");
          dom.appendChild(el3, el4);
          var el4 = dom.createComment("");
          dom.appendChild(el3, el4);
          var el4 = dom.createTextNode("                ");
          dom.appendChild(el3, el4);
          dom.appendChild(el2, el3);
          var el3 = dom.createTextNode("\n            ");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n        ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n\n        ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("div");
          var el2 = dom.createTextNode("\n");
          dom.appendChild(el1, el2);
          var el2 = dom.createComment("");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("        ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var element4 = dom.childAt(fragment, [1]);
          var element5 = dom.childAt(element4, [1, 3]);
          var element6 = dom.childAt(element4, [3]);
          var element7 = dom.childAt(element6, [3]);
          var element8 = dom.childAt(element7, [3]);
          var element9 = dom.childAt(fragment, [3]);
          var morphs = new Array(11);
          morphs[0] = dom.createAttrMorph(element4, 'class');
          morphs[1] = dom.createElementMorph(element5);
          morphs[2] = dom.createMorphAt(element6,1,1);
          morphs[3] = dom.createMorphAt(element7,1,1);
          morphs[4] = dom.createMorphAt(element8,3,3);
          morphs[5] = dom.createMorphAt(element8,5,5);
          morphs[6] = dom.createMorphAt(dom.childAt(element7, [5]),3,3);
          morphs[7] = dom.createMorphAt(dom.childAt(element7, [7]),1,1);
          morphs[8] = dom.createMorphAt(element7,9,9);
          morphs[9] = dom.createAttrMorph(element9, 'class');
          morphs[10] = dom.createMorphAt(element9,1,1);
          return morphs;
        },
        statements: [
          ["attribute","class",["concat",[["subexpr","if",[["get","isViewingSubview"],"settings-menu-pane-out-left","settings-menu-pane-in"],[]]," settings-menu settings-menu-pane tag-settings-pane"]]],
          ["element","action",["closeMenus"],[]],
          ["inline","gh-uploader",[],["uploaded","setCoverImage","canceled","clearCoverImage","description","Add tag image","image",["subexpr","@mut",[["get","activeTag.image"]],[]],"initUploader","setUploaderReference","tagName","section"]],
          ["block","gh-form-group",[],["errors",["subexpr","@mut",[["get","activeTag.errors"]],[]],"hasValidated",["subexpr","@mut",[["get","activeTag.hasValidated"]],[]],"property","name"],0,null],
          ["inline","gh-input",[],["id","tag-url","name","url","type","text","value",["subexpr","@mut",[["get","activeTagSlugScratch"]],[]],"focus-out","saveActiveTagSlug"]],
          ["inline","gh-url-preview",[],["prefix","tag","slug",["subexpr","@mut",[["get","activeTagSlugScratch"]],[]],"tagName","p","classNames","description"]],
          ["inline","gh-textarea",[],["id","tag-description","name","description","value",["subexpr","@mut",[["get","activeTagDescriptionScratch"]],[]],"focus-out","saveActiveTagDescription"]],
          ["block","gh-tab",[],["tagName","li","classNames","nav-list-item"],1,null],
          ["block","unless",[["get","activeTag.isNew"]],[],2,null],
          ["attribute","class",["concat",[["subexpr","if",[["get","isViewingSubview"],"settings-menu-pane-in","settings-menu-pane-out-right"],[]]," settings-menu settings-menu-pane tag-meta-settings-pane"]]],
          ["block","gh-tab-pane",[],[],3,null]
        ],
        locals: [],
        templates: [child0, child1, child2, child3]
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 87,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/settings/tags/settings-menu.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createElement("div");
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        var el2 = dom.createComment("");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(1);
        morphs[0] = dom.createMorphAt(dom.childAt(fragment, [0]),1,1);
        return morphs;
      },
      statements: [
        ["block","gh-tabs-manager",[],["selected","showSubview","class","settings-menu-container"],0,null]
      ],
      locals: [],
      templates: [child0]
    };
  }()));

});
define('ghost/templates/setup', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      var child0 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 5,
                "column": 16
              },
              "end": {
                "line": 5,
                "column": 100
              }
            },
            "moduleName": "ghost/templates/setup.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createElement("i");
            dom.setAttribute(el1,"class","icon-arrow-left");
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode(" Back");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes() { return []; },
          statements: [

          ],
          locals: [],
          templates: []
        };
      }());
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 4,
              "column": 12
            },
            "end": {
              "line": 6,
              "column": 12
            }
          },
          "moduleName": "ghost/templates/setup.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("                ");
          dom.appendChild(el0, el1);
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(1);
          morphs[0] = dom.createMorphAt(fragment,1,1,contextualElement);
          return morphs;
        },
        statements: [
          ["block","link-to",[["get","backRoute"]],["classNames","gh-flow-back"],0,null]
        ],
        locals: [],
        templates: [child0]
      };
    }());
    var child1 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 8,
              "column": 16
            },
            "end": {
              "line": 10,
              "column": 16
            }
          },
          "moduleName": "ghost/templates/setup.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("i");
          dom.setAttribute(el1,"class","icon-check");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("span");
          dom.setAttribute(el1,"class","num");
          var el2 = dom.createTextNode("1");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes() { return []; },
        statements: [

        ],
        locals: [],
        templates: []
      };
    }());
    var child2 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 12,
              "column": 16
            },
            "end": {
              "line": 14,
              "column": 16
            }
          },
          "moduleName": "ghost/templates/setup.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("i");
          dom.setAttribute(el1,"class","icon-check");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("span");
          dom.setAttribute(el1,"class","num");
          var el2 = dom.createTextNode("2");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes() { return []; },
        statements: [

        ],
        locals: [],
        templates: []
      };
    }());
    var child3 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 16,
              "column": 16
            },
            "end": {
              "line": 18,
              "column": 16
            }
          },
          "moduleName": "ghost/templates/setup.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("i");
          dom.setAttribute(el1,"class","icon-check");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("span");
          dom.setAttribute(el1,"class","num");
          var el2 = dom.createTextNode("3");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes() { return []; },
        statements: [

        ],
        locals: [],
        templates: []
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 28,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/setup.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createElement("div");
        dom.setAttribute(el1,"class","gh-flow");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("header");
        dom.setAttribute(el2,"class","gh-flow-head");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("nav");
        dom.setAttribute(el3,"class","gh-flow-nav");
        var el4 = dom.createTextNode("\n");
        dom.appendChild(el3, el4);
        var el4 = dom.createComment("");
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createElement("ol");
        var el5 = dom.createTextNode("\n");
        dom.appendChild(el4, el5);
        var el5 = dom.createComment("");
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("                ");
        dom.appendChild(el4, el5);
        var el5 = dom.createElement("li");
        dom.setAttribute(el5,"class","divider");
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n");
        dom.appendChild(el4, el5);
        var el5 = dom.createComment("");
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("                ");
        dom.appendChild(el4, el5);
        var el5 = dom.createElement("li");
        dom.setAttribute(el5,"class","divider");
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n");
        dom.appendChild(el4, el5);
        var el5 = dom.createComment("");
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("            ");
        dom.appendChild(el4, el5);
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n        ");
        dom.appendChild(el3, el4);
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("div");
        dom.setAttribute(el2,"class","gh-flow-content-wrap");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("section");
        dom.setAttribute(el3,"class","gh-flow-content");
        var el4 = dom.createTextNode("\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createComment("");
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n        ");
        dom.appendChild(el3, el4);
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var element0 = dom.childAt(fragment, [0]);
        var element1 = dom.childAt(element0, [1, 1]);
        var element2 = dom.childAt(element1, [3]);
        var morphs = new Array(5);
        morphs[0] = dom.createMorphAt(element1,1,1);
        morphs[1] = dom.createMorphAt(element2,1,1);
        morphs[2] = dom.createMorphAt(element2,5,5);
        morphs[3] = dom.createMorphAt(element2,9,9);
        morphs[4] = dom.createMorphAt(dom.childAt(element0, [3, 1]),1,1);
        return morphs;
      },
      statements: [
        ["block","if",[["get","showBackLink"]],[],0,null],
        ["block","gh-activating-list-item",[],["route","setup.one","linkClasses","step"],1,null],
        ["block","gh-activating-list-item",[],["route","setup.two","linkClasses","step"],2,null],
        ["block","gh-activating-list-item",[],["route","setup.three","linkClasses","step"],3,null],
        ["content","outlet"]
      ],
      locals: [],
      templates: [child0, child1, child2, child3]
    };
  }()));

});
define('ghost/templates/setup/one', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 10,
              "column": 0
            },
            "end": {
              "line": 12,
              "column": 0
            }
          },
          "moduleName": "ghost/templates/setup/one.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("    Create your account ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("i");
          dom.setAttribute(el1,"class","icon-chevron");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes() { return []; },
        statements: [

        ],
        locals: [],
        templates: []
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 13,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/setup/one.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createElement("header");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("h1");
        var el3 = dom.createTextNode("Welcome to ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("strong");
        var el4 = dom.createTextNode("Ghost");
        dom.appendChild(el3, el4);
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("!");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("p");
        var el3 = dom.createTextNode("All over the world, people have started ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("em");
        var el4 = dom.createComment("");
        dom.appendChild(el3, el4);
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode(" incredible blogs with Ghost. Today, we’re starting yours.");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createElement("figure");
        dom.setAttribute(el1,"class","gh-flow-screenshot");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("img");
        dom.setAttribute(el2,"alt","Ghost screenshot");
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var element0 = dom.childAt(fragment, [2, 1]);
        var morphs = new Array(3);
        morphs[0] = dom.createMorphAt(dom.childAt(fragment, [0, 3, 1]),0,0);
        morphs[1] = dom.createAttrMorph(element0, 'src');
        morphs[2] = dom.createMorphAt(fragment,4,4,contextualElement);
        dom.insertBoundary(fragment, null);
        return morphs;
      },
      statements: [
        ["content","model.count"],
        ["attribute","src",["concat",[["subexpr","gh-path",["admin","img/install-welcome.png"],[]]]]],
        ["block","link-to",["setup.two"],["classNames","btn btn-green btn-lg"],0,null]
      ],
      locals: [],
      templates: [child0]
    };
  }()));

});
define('ghost/templates/setup/three', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 9,
              "column": 4
            },
            "end": {
              "line": 12,
              "column": 4
            }
          },
          "moduleName": "ghost/templates/setup/three.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("        ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("label");
          dom.setAttribute(el1,"for","users");
          var el2 = dom.createTextNode("Enter one email address per line, we’ll handle the rest! ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("i");
          dom.setAttribute(el2,"class","icon-mail");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n        ");
          dom.appendChild(el0, el1);
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(1);
          morphs[0] = dom.createMorphAt(fragment,3,3,contextualElement);
          return morphs;
        },
        statements: [
          ["inline","gh-textarea",[],["name","users","value",["subexpr","@mut",[["get","users"]],[]],"required","required","focusOut",["subexpr","action",["validate"],[]]]]
        ],
        locals: [],
        templates: []
      };
    }());
    var child1 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 14,
              "column": 4
            },
            "end": {
              "line": 14,
              "column": 176
            }
          },
          "moduleName": "ghost/templates/setup/three.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(1);
          morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
          dom.insertBoundary(fragment, 0);
          dom.insertBoundary(fragment, null);
          return morphs;
        },
        statements: [
          ["content","buttonText"]
        ],
        locals: [],
        templates: []
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 20,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/setup/three.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createElement("header");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("h1");
        var el3 = dom.createTextNode("Invite your team");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("p");
        var el3 = dom.createTextNode("Ghost works best when shared with others. Collaborate, get feedback on your posts & work together on ideas.");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createElement("img");
        dom.setAttribute(el1,"class","gh-flow-faces");
        dom.setAttribute(el1,"alt","");
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createElement("form");
        dom.setAttribute(el1,"class","gh-flow-invite");
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        var el2 = dom.createComment("");
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createComment("");
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createElement("button");
        dom.setAttribute(el1,"class","gh-flow-skip");
        var el2 = dom.createTextNode("\n    I'll do this later, take me to my blog!\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var element0 = dom.childAt(fragment, [2]);
        var element1 = dom.childAt(fragment, [4]);
        var element2 = dom.childAt(fragment, [6]);
        var morphs = new Array(4);
        morphs[0] = dom.createAttrMorph(element0, 'src');
        morphs[1] = dom.createMorphAt(element1,1,1);
        morphs[2] = dom.createMorphAt(element1,3,3);
        morphs[3] = dom.createElementMorph(element2);
        return morphs;
      },
      statements: [
        ["attribute","src",["concat",[["subexpr","gh-path",["admin","img/users.png"],[]]]]],
        ["block","gh-form-group",[],["errors",["subexpr","@mut",[["get","errors"]],[]],"hasValidated",["subexpr","@mut",[["get","hasValidated"]],[]],"property","users"],0,null],
        ["block","gh-spin-button",[],["type","submit","action","invite","submitting",["subexpr","@mut",[["get","submitting"]],[]],"autoWidth","false","class",["subexpr","concat",["btn"," ","btn-default"," ","btn-lg"," ","btn-block"," ",["subexpr","if",[["get","buttonClass"],["subexpr","-normalize-class",["buttonClass",["get","buttonClass"]],[]]],[]]," "],[]]],1,null],
        ["element","action",["skipInvite"],[]]
      ],
      locals: [],
      templates: [child0, child1]
    };
  }()));

});
define('ghost/templates/setup/two', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 11,
              "column": 4
            },
            "end": {
              "line": 17,
              "column": 4
            }
          },
          "moduleName": "ghost/templates/setup/two.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("        ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("label");
          dom.setAttribute(el1,"for","email-address");
          var el2 = dom.createTextNode("Email address");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n        ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("span");
          dom.setAttribute(el1,"class","input-icon icon-mail");
          var el2 = dom.createTextNode("\n            ");
          dom.appendChild(el1, el2);
          var el2 = dom.createComment("");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n        ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n        ");
          dom.appendChild(el0, el1);
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(2);
          morphs[0] = dom.createMorphAt(dom.childAt(fragment, [3]),1,1);
          morphs[1] = dom.createMorphAt(fragment,5,5,contextualElement);
          return morphs;
        },
        statements: [
          ["inline","gh-trim-focus-input",[],["tabindex","1","type","email","name","email","placeholder","Eg. john@example.com","autocorrect","off","value",["subexpr","@mut",[["get","email"]],[]],"focusOut",["subexpr","action",["preValidate","email"],[]]]],
          ["inline","gh-error-message",[],["errors",["subexpr","@mut",[["get","errors"]],[]],"property","email"]]
        ],
        locals: [],
        templates: []
      };
    }());
    var child1 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 18,
              "column": 4
            },
            "end": {
              "line": 24,
              "column": 4
            }
          },
          "moduleName": "ghost/templates/setup/two.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("        ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("label");
          dom.setAttribute(el1,"for","full-name");
          var el2 = dom.createTextNode("Full name");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n        ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("span");
          dom.setAttribute(el1,"class","input-icon icon-user");
          var el2 = dom.createTextNode("\n            ");
          dom.appendChild(el1, el2);
          var el2 = dom.createComment("");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n        ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n        ");
          dom.appendChild(el0, el1);
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(2);
          morphs[0] = dom.createMorphAt(dom.childAt(fragment, [3]),1,1);
          morphs[1] = dom.createMorphAt(fragment,5,5,contextualElement);
          return morphs;
        },
        statements: [
          ["inline","gh-input",[],["tabindex","2","type","text","name","name","placeholder","Eg. John H. Watson","autocorrect","off","value",["subexpr","@mut",[["get","name"]],[]],"focusOut",["subexpr","action",["preValidate","name"],[]]]],
          ["inline","gh-error-message",[],["errors",["subexpr","@mut",[["get","errors"]],[]],"property","name"]]
        ],
        locals: [],
        templates: []
      };
    }());
    var child2 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 25,
              "column": 4
            },
            "end": {
              "line": 31,
              "column": 4
            }
          },
          "moduleName": "ghost/templates/setup/two.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("        ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("label");
          dom.setAttribute(el1,"for","password");
          var el2 = dom.createTextNode("Password");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n        ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("span");
          dom.setAttribute(el1,"class","input-icon icon-lock");
          var el2 = dom.createTextNode("\n            ");
          dom.appendChild(el1, el2);
          var el2 = dom.createComment("");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n        ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n        ");
          dom.appendChild(el0, el1);
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(2);
          morphs[0] = dom.createMorphAt(dom.childAt(fragment, [3]),1,1);
          morphs[1] = dom.createMorphAt(fragment,5,5,contextualElement);
          return morphs;
        },
        statements: [
          ["inline","gh-input",[],["tabindex","3","type","password","name","password","placeholder","At least 8 characters","autocorrect","off","value",["subexpr","@mut",[["get","password"]],[]],"focusOut",["subexpr","action",["preValidate","password"],[]]]],
          ["inline","gh-error-message",[],["errors",["subexpr","@mut",[["get","errors"]],[]],"property","password"]]
        ],
        locals: [],
        templates: []
      };
    }());
    var child3 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 32,
              "column": 4
            },
            "end": {
              "line": 38,
              "column": 4
            }
          },
          "moduleName": "ghost/templates/setup/two.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("        ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("label");
          dom.setAttribute(el1,"for","blog-title");
          var el2 = dom.createTextNode("Blog title");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n        ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("span");
          dom.setAttribute(el1,"class","input-icon icon-content");
          var el2 = dom.createTextNode("\n            ");
          dom.appendChild(el1, el2);
          var el2 = dom.createComment("");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n        ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n        ");
          dom.appendChild(el0, el1);
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(2);
          morphs[0] = dom.createMorphAt(dom.childAt(fragment, [3]),1,1);
          morphs[1] = dom.createMorphAt(fragment,5,5,contextualElement);
          return morphs;
        },
        statements: [
          ["inline","gh-input",[],["tabindex","4","type","text","name","blog-title","placeholder","Eg. The Daily Awesome","autocorrect","off","value",["subexpr","@mut",[["get","blogTitle"]],[]],"focusOut",["subexpr","action",["preValidate","blogTitle"],[]]]],
          ["inline","gh-error-message",[],["errors",["subexpr","@mut",[["get","errors"]],[]],"property","blogTitle"]]
        ],
        locals: [],
        templates: []
      };
    }());
    var child4 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 39,
              "column": 4
            },
            "end": {
              "line": 41,
              "column": 4
            }
          },
          "moduleName": "ghost/templates/setup/two.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("        Last step: Invite your team ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("i");
          dom.setAttribute(el1,"class","icon-chevron");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes() { return []; },
        statements: [

        ],
        locals: [],
        templates: []
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 45,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/setup/two.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createElement("header");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("h1");
        var el3 = dom.createTextNode("Create your account");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createElement("form");
        dom.setAttribute(el1,"id","setup");
        dom.setAttribute(el1,"class","gh-flow-create");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("input");
        dom.setAttribute(el2,"style","display:none;");
        dom.setAttribute(el2,"type","text");
        dom.setAttribute(el2,"name","fakeusernameremembered");
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("input");
        dom.setAttribute(el2,"style","display:none;");
        dom.setAttribute(el2,"type","password");
        dom.setAttribute(el2,"name","fakepasswordremembered");
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createComment("");
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        var el2 = dom.createComment("");
        dom.appendChild(el1, el2);
        var el2 = dom.createComment("");
        dom.appendChild(el1, el2);
        var el2 = dom.createComment("");
        dom.appendChild(el1, el2);
        var el2 = dom.createComment("");
        dom.appendChild(el1, el2);
        var el2 = dom.createComment("");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createElement("p");
        dom.setAttribute(el1,"class","main-error");
        var el2 = dom.createComment("");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var element0 = dom.childAt(fragment, [2]);
        var morphs = new Array(7);
        morphs[0] = dom.createMorphAt(element0,5,5);
        morphs[1] = dom.createMorphAt(element0,7,7);
        morphs[2] = dom.createMorphAt(element0,8,8);
        morphs[3] = dom.createMorphAt(element0,9,9);
        morphs[4] = dom.createMorphAt(element0,10,10);
        morphs[5] = dom.createMorphAt(element0,11,11);
        morphs[6] = dom.createUnsafeMorphAt(dom.childAt(fragment, [4]),0,0);
        return morphs;
      },
      statements: [
        ["inline","gh-profile-image",[],["fileStorage",["subexpr","@mut",[["get","config.fileStorage"]],[]],"email",["subexpr","@mut",[["get","validEmail"]],[]],"setImage","setImage"]],
        ["block","gh-form-group",[],["errors",["subexpr","@mut",[["get","errors"]],[]],"hasValidated",["subexpr","@mut",[["get","hasValidated"]],[]],"property","email"],0,null],
        ["block","gh-form-group",[],["errors",["subexpr","@mut",[["get","errors"]],[]],"hasValidated",["subexpr","@mut",[["get","hasValidated"]],[]],"property","name"],1,null],
        ["block","gh-form-group",[],["errors",["subexpr","@mut",[["get","errors"]],[]],"hasValidated",["subexpr","@mut",[["get","hasValidated"]],[]],"property","password"],2,null],
        ["block","gh-form-group",[],["errors",["subexpr","@mut",[["get","errors"]],[]],"hasValidated",["subexpr","@mut",[["get","hasValidated"]],[]],"property","blogTitle"],3,null],
        ["block","gh-spin-button",[],["type","submit","tabindex","5","class","btn btn-green btn-lg btn-block","action","setup","submitting",["subexpr","@mut",[["get","submitting"]],[]],"autoWidth","false"],4,null],
        ["content","flowErrors"]
      ],
      locals: [],
      templates: [child0, child1, child2, child3, child4]
    };
  }()));

});
define('ghost/templates/signin', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 5,
              "column": 16
            },
            "end": {
              "line": 9,
              "column": 16
            }
          },
          "moduleName": "ghost/templates/signin.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("span");
          dom.setAttribute(el1,"class","input-icon icon-mail");
          var el2 = dom.createTextNode("\n                        ");
          dom.appendChild(el1, el2);
          var el2 = dom.createComment("");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n                    ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(1);
          morphs[0] = dom.createMorphAt(dom.childAt(fragment, [1]),1,1);
          return morphs;
        },
        statements: [
          ["inline","gh-trim-focus-input",[],["class","gh-input email","type","email","placeholder","Email Address","name","identification","autocapitalize","off","autocorrect","off","tabindex","1","focusOut",["subexpr","action",["validate","identification"],[]],"value",["subexpr","@mut",[["get","model.identification"]],[]]]]
        ],
        locals: [],
        templates: []
      };
    }());
    var child1 = (function() {
      var child0 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 13,
                "column": 24
              },
              "end": {
                "line": 13,
                "column": 171
              }
            },
            "moduleName": "ghost/templates/signin.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createTextNode("Forgot?");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes() { return []; },
          statements: [

          ],
          locals: [],
          templates: []
        };
      }());
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 10,
              "column": 16
            },
            "end": {
              "line": 15,
              "column": 16
            }
          },
          "moduleName": "ghost/templates/signin.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("span");
          dom.setAttribute(el1,"class","input-icon icon-lock forgotten-wrap");
          var el2 = dom.createTextNode("\n                        ");
          dom.appendChild(el1, el2);
          var el2 = dom.createComment("");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n                        ");
          dom.appendChild(el1, el2);
          var el2 = dom.createComment("");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n                    ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var element0 = dom.childAt(fragment, [1]);
          var morphs = new Array(2);
          morphs[0] = dom.createMorphAt(element0,1,1);
          morphs[1] = dom.createMorphAt(element0,3,3);
          return morphs;
        },
        statements: [
          ["inline","gh-input",[],["class","password","type","password","placeholder","Password","name","password","tabindex","2","value",["subexpr","@mut",[["get","model.password"]],[]],"autocorrect","off"]],
          ["block","gh-spin-button",[],["class","forgotten-link btn btn-link","type","button","action","forgotten","tabindex","4","submitting",["subexpr","@mut",[["get","submitting"]],[]],"autoWidth","true"],0,null]
        ],
        locals: [],
        templates: [child0]
      };
    }());
    var child2 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 16,
              "column": 16
            },
            "end": {
              "line": 16,
              "column": 178
            }
          },
          "moduleName": "ghost/templates/signin.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("Sign in");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes() { return []; },
        statements: [

        ],
        locals: [],
        templates: []
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 23,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/signin.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createElement("div");
        dom.setAttribute(el1,"class","gh-flow");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("div");
        dom.setAttribute(el2,"class","gh-flow-content-wrap");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("section");
        dom.setAttribute(el3,"class","gh-flow-content");
        var el4 = dom.createTextNode("\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createElement("form");
        dom.setAttribute(el4,"id","login");
        dom.setAttribute(el4,"class","gh-signin");
        dom.setAttribute(el4,"method","post");
        dom.setAttribute(el4,"novalidate","novalidate");
        var el5 = dom.createTextNode("\n");
        dom.appendChild(el4, el5);
        var el5 = dom.createComment("");
        dom.appendChild(el4, el5);
        var el5 = dom.createComment("");
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("                ");
        dom.appendChild(el4, el5);
        var el5 = dom.createComment("");
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n            ");
        dom.appendChild(el4, el5);
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createElement("p");
        dom.setAttribute(el4,"class","main-error");
        var el5 = dom.createComment("");
        dom.appendChild(el4, el5);
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n        ");
        dom.appendChild(el3, el4);
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var element1 = dom.childAt(fragment, [0, 1, 1]);
        var element2 = dom.childAt(element1, [1]);
        var morphs = new Array(4);
        morphs[0] = dom.createMorphAt(element2,1,1);
        morphs[1] = dom.createMorphAt(element2,2,2);
        morphs[2] = dom.createMorphAt(element2,4,4);
        morphs[3] = dom.createUnsafeMorphAt(dom.childAt(element1, [3]),0,0);
        return morphs;
      },
      statements: [
        ["block","gh-form-group",[],["errors",["subexpr","@mut",[["get","model.errors"]],[]],"hasValidated",["subexpr","@mut",[["get","hasValidated"]],[]],"property","identification"],0,null],
        ["block","gh-form-group",[],["errors",["subexpr","@mut",[["get","model.errors"]],[]],"hasValidated",["subexpr","@mut",[["get","hasValidated"]],[]],"property","password"],1,null],
        ["block","gh-spin-button",[],["class","login btn btn-blue btn-block","type","submit","action","validateAndAuthenticate","tabindex","3","submitting",["subexpr","@mut",[["get","loggingIn"]],[]],"autoWidth","false"],2,null],
        ["content","flowErrors"]
      ],
      locals: [],
      templates: [child0, child1, child2]
    };
  }()));

});
define('ghost/templates/signup', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 15,
              "column": 16
            },
            "end": {
              "line": 21,
              "column": 16
            }
          },
          "moduleName": "ghost/templates/signup.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("label");
          dom.setAttribute(el1,"for","email-address");
          var el2 = dom.createTextNode("Email address");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("span");
          dom.setAttribute(el1,"class","input-icon icon-mail");
          var el2 = dom.createTextNode("\n                        ");
          dom.appendChild(el1, el2);
          var el2 = dom.createComment("");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n                    ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(2);
          morphs[0] = dom.createMorphAt(dom.childAt(fragment, [3]),1,1);
          morphs[1] = dom.createMorphAt(fragment,5,5,contextualElement);
          return morphs;
        },
        statements: [
          ["inline","gh-input",[],["type","email","name","email","placeholder","Eg. john@example.com","enter",["subexpr","action",["signup"],[]],"disabled","disabled","autocorrect","off","value",["subexpr","@mut",[["get","model.email"]],[]],"focusOut",["subexpr","action",["handleEmail"],[]]]],
          ["inline","gh-error-message",[],["errors",["subexpr","@mut",[["get","model.errors"]],[]],"property","email"]]
        ],
        locals: [],
        templates: []
      };
    }());
    var child1 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 22,
              "column": 16
            },
            "end": {
              "line": 28,
              "column": 16
            }
          },
          "moduleName": "ghost/templates/signup.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("label");
          dom.setAttribute(el1,"for","full-name");
          var el2 = dom.createTextNode("Full name");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("span");
          dom.setAttribute(el1,"class","input-icon icon-user");
          var el2 = dom.createTextNode("\n                        ");
          dom.appendChild(el1, el2);
          var el2 = dom.createComment("");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n                    ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(2);
          morphs[0] = dom.createMorphAt(dom.childAt(fragment, [3]),1,1);
          morphs[1] = dom.createMorphAt(fragment,5,5,contextualElement);
          return morphs;
        },
        statements: [
          ["inline","gh-trim-focus-input",[],["tabindex","1","type","text","name","name","placeholder","Eg. John H. Watson","enter",["subexpr","action",["signup"],[]],"autocorrect","off","value",["subexpr","@mut",[["get","model.name"]],[]],"focusOut",["subexpr","action",["validate","name"],[]]]],
          ["inline","gh-error-message",[],["errors",["subexpr","@mut",[["get","model.errors"]],[]],"property","name"]]
        ],
        locals: [],
        templates: []
      };
    }());
    var child2 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 29,
              "column": 16
            },
            "end": {
              "line": 35,
              "column": 16
            }
          },
          "moduleName": "ghost/templates/signup.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("label");
          dom.setAttribute(el1,"for","password");
          var el2 = dom.createTextNode("Password");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("span");
          dom.setAttribute(el1,"class","input-icon icon-lock");
          var el2 = dom.createTextNode("\n                        ");
          dom.appendChild(el1, el2);
          var el2 = dom.createComment("");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n                    ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(2);
          morphs[0] = dom.createMorphAt(dom.childAt(fragment, [3]),1,1);
          morphs[1] = dom.createMorphAt(fragment,5,5,contextualElement);
          return morphs;
        },
        statements: [
          ["inline","gh-input",[],["tabindex","2","type","password","name","password","enter",["subexpr","action",["signup"],[]],"autocorrect","off","value",["subexpr","@mut",[["get","model.password"]],[]],"focusOut",["subexpr","action",["validate","password"],[]]]],
          ["inline","gh-error-message",[],["errors",["subexpr","@mut",[["get","model.errors"]],[]],"property","password"]]
        ],
        locals: [],
        templates: []
      };
    }());
    var child3 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 38,
              "column": 12
            },
            "end": {
              "line": 38,
              "column": 167
            }
          },
          "moduleName": "ghost/templates/signup.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("Create Account");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes() { return []; },
        statements: [

        ],
        locals: [],
        templates: []
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 44,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/signup.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createElement("div");
        dom.setAttribute(el1,"class","gh-flow");
        var el2 = dom.createTextNode("\n\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("div");
        dom.setAttribute(el2,"class","gh-flow-content-wrap");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("section");
        dom.setAttribute(el3,"class","gh-flow-content");
        var el4 = dom.createTextNode("\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createElement("header");
        var el5 = dom.createTextNode("\n                ");
        dom.appendChild(el4, el5);
        var el5 = dom.createElement("h1");
        var el6 = dom.createTextNode("Create your account");
        dom.appendChild(el5, el6);
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n            ");
        dom.appendChild(el4, el5);
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createElement("form");
        dom.setAttribute(el4,"id","signup");
        dom.setAttribute(el4,"class","gh-flow-create");
        dom.setAttribute(el4,"method","post");
        dom.setAttribute(el4,"novalidate","novalidate");
        var el5 = dom.createTextNode("\n                ");
        dom.appendChild(el4, el5);
        var el5 = dom.createElement("input");
        dom.setAttribute(el5,"style","display:none;");
        dom.setAttribute(el5,"type","text");
        dom.setAttribute(el5,"name","fakeusernameremembered");
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n                ");
        dom.appendChild(el4, el5);
        var el5 = dom.createElement("input");
        dom.setAttribute(el5,"style","display:none;");
        dom.setAttribute(el5,"type","password");
        dom.setAttribute(el5,"name","fakepasswordremembered");
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n\n                ");
        dom.appendChild(el4, el5);
        var el5 = dom.createComment("");
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n");
        dom.appendChild(el4, el5);
        var el5 = dom.createComment("");
        dom.appendChild(el4, el5);
        var el5 = dom.createComment("");
        dom.appendChild(el4, el5);
        var el5 = dom.createComment("");
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("            ");
        dom.appendChild(el4, el5);
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createComment("");
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createElement("p");
        dom.setAttribute(el4,"class","main-error");
        var el5 = dom.createComment("");
        dom.appendChild(el4, el5);
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n        ");
        dom.appendChild(el3, el4);
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var element0 = dom.childAt(fragment, [0, 1, 1]);
        var element1 = dom.childAt(element0, [3]);
        var morphs = new Array(6);
        morphs[0] = dom.createMorphAt(element1,5,5);
        morphs[1] = dom.createMorphAt(element1,7,7);
        morphs[2] = dom.createMorphAt(element1,8,8);
        morphs[3] = dom.createMorphAt(element1,9,9);
        morphs[4] = dom.createMorphAt(element0,5,5);
        morphs[5] = dom.createUnsafeMorphAt(dom.childAt(element0, [7]),0,0);
        return morphs;
      },
      statements: [
        ["inline","gh-profile-image",[],["fileStorage",["subexpr","@mut",[["get","config.fileStorage"]],[]],"email",["subexpr","@mut",[["get","validEmail"]],[]],"setImage","setImage"]],
        ["block","gh-form-group",[],["errors",["subexpr","@mut",[["get","model.errors"]],[]],"hasValidated",["subexpr","@mut",[["get","hasValidated"]],[]],"property","email"],0,null],
        ["block","gh-form-group",[],["errors",["subexpr","@mut",[["get","model.errors"]],[]],"hasValidated",["subexpr","@mut",[["get","hasValidated"]],[]],"property","name"],1,null],
        ["block","gh-form-group",[],["errors",["subexpr","@mut",[["get","model.errors"]],[]],"hasValidated",["subexpr","@mut",[["get","hasValidated"]],[]],"property","password"],2,null],
        ["block","gh-spin-button",[],["tabindex","3","type","submit","class","btn btn-green btn-lg btn-block","action","signup","submitting",["subexpr","@mut",[["get","submitting"]],[]],"autoWidth","false"],3,null],
        ["content","flowErrors"]
      ],
      locals: [],
      templates: [child0, child1, child2, child3]
    };
  }()));

});
define('ghost/templates/team/index', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 3,
              "column": 8
            },
            "end": {
              "line": 3,
              "column": 75
            }
          },
          "moduleName": "ghost/templates/team/index.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createElement("span");
          var el2 = dom.createTextNode("Team");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes() { return []; },
        statements: [

        ],
        locals: [],
        templates: []
      };
    }());
    var child1 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 5,
              "column": 8
            },
            "end": {
              "line": 9,
              "column": 8
            }
          },
          "moduleName": "ghost/templates/team/index.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("            ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("section");
          dom.setAttribute(el1,"class","view-actions");
          var el2 = dom.createTextNode("\n                ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("button");
          dom.setAttribute(el2,"class","btn btn-green");
          var el3 = dom.createTextNode("Invite People");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n            ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var element4 = dom.childAt(fragment, [1, 1]);
          var morphs = new Array(1);
          morphs[0] = dom.createElementMorph(element4);
          return morphs;
        },
        statements: [
          ["element","action",["openModal","invite-new-user"],[]]
        ],
        locals: [],
        templates: []
      };
    }());
    var child2 = (function() {
      var child0 = (function() {
        var child0 = (function() {
          var child0 = (function() {
            var child0 = (function() {
              var child0 = (function() {
                return {
                  meta: {
                    "revision": "Ember@1.13.2",
                    "loc": {
                      "source": null,
                      "start": {
                        "line": 29,
                        "column": 40
                      },
                      "end": {
                        "line": 33,
                        "column": 40
                      }
                    },
                    "moduleName": "ghost/templates/team/index.hbs"
                  },
                  arity: 0,
                  cachedFragment: null,
                  hasRendered: false,
                  buildFragment: function buildFragment(dom) {
                    var el0 = dom.createDocumentFragment();
                    var el1 = dom.createTextNode("                                            ");
                    dom.appendChild(el0, el1);
                    var el1 = dom.createElement("span");
                    dom.setAttribute(el1,"class","description-error");
                    var el2 = dom.createTextNode("\n                                                Invitation not sent - please try again\n                                            ");
                    dom.appendChild(el1, el2);
                    dom.appendChild(el0, el1);
                    var el1 = dom.createTextNode("\n");
                    dom.appendChild(el0, el1);
                    return el0;
                  },
                  buildRenderNodes: function buildRenderNodes() { return []; },
                  statements: [

                  ],
                  locals: [],
                  templates: []
                };
              }());
              var child1 = (function() {
                return {
                  meta: {
                    "revision": "Ember@1.13.2",
                    "loc": {
                      "source": null,
                      "start": {
                        "line": 33,
                        "column": 40
                      },
                      "end": {
                        "line": 37,
                        "column": 40
                      }
                    },
                    "moduleName": "ghost/templates/team/index.hbs"
                  },
                  arity: 0,
                  cachedFragment: null,
                  hasRendered: false,
                  buildFragment: function buildFragment(dom) {
                    var el0 = dom.createDocumentFragment();
                    var el1 = dom.createTextNode("                                            ");
                    dom.appendChild(el0, el1);
                    var el1 = dom.createElement("span");
                    dom.setAttribute(el1,"class","description");
                    var el2 = dom.createTextNode("\n                                                Invitation sent: ");
                    dom.appendChild(el1, el2);
                    var el2 = dom.createComment("");
                    dom.appendChild(el1, el2);
                    var el2 = dom.createTextNode("\n                                            ");
                    dom.appendChild(el1, el2);
                    dom.appendChild(el0, el1);
                    var el1 = dom.createTextNode("\n");
                    dom.appendChild(el0, el1);
                    return el0;
                  },
                  buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
                    var morphs = new Array(1);
                    morphs[0] = dom.createMorphAt(dom.childAt(fragment, [1]),1,1);
                    return morphs;
                  },
                  statements: [
                    ["content","component.createdAt"]
                  ],
                  locals: [],
                  templates: []
                };
              }());
              var child2 = (function() {
                return {
                  meta: {
                    "revision": "Ember@1.13.2",
                    "loc": {
                      "source": null,
                      "start": {
                        "line": 40,
                        "column": 36
                      },
                      "end": {
                        "line": 42,
                        "column": 36
                      }
                    },
                    "moduleName": "ghost/templates/team/index.hbs"
                  },
                  arity: 0,
                  cachedFragment: null,
                  hasRendered: false,
                  buildFragment: function buildFragment(dom) {
                    var el0 = dom.createDocumentFragment();
                    var el1 = dom.createTextNode("                                        ");
                    dom.appendChild(el0, el1);
                    var el1 = dom.createElement("span");
                    var el2 = dom.createTextNode("Sending Invite...");
                    dom.appendChild(el1, el2);
                    dom.appendChild(el0, el1);
                    var el1 = dom.createTextNode("\n");
                    dom.appendChild(el0, el1);
                    return el0;
                  },
                  buildRenderNodes: function buildRenderNodes() { return []; },
                  statements: [

                  ],
                  locals: [],
                  templates: []
                };
              }());
              var child3 = (function() {
                return {
                  meta: {
                    "revision": "Ember@1.13.2",
                    "loc": {
                      "source": null,
                      "start": {
                        "line": 42,
                        "column": 36
                      },
                      "end": {
                        "line": 49,
                        "column": 36
                      }
                    },
                    "moduleName": "ghost/templates/team/index.hbs"
                  },
                  arity: 0,
                  cachedFragment: null,
                  hasRendered: false,
                  buildFragment: function buildFragment(dom) {
                    var el0 = dom.createDocumentFragment();
                    var el1 = dom.createTextNode("                                        ");
                    dom.appendChild(el0, el1);
                    var el1 = dom.createElement("a");
                    dom.setAttribute(el1,"class","user-list-action");
                    dom.setAttribute(el1,"href","#");
                    var el2 = dom.createTextNode("\n                                            Revoke\n                                        ");
                    dom.appendChild(el1, el2);
                    dom.appendChild(el0, el1);
                    var el1 = dom.createTextNode("\n                                        ");
                    dom.appendChild(el0, el1);
                    var el1 = dom.createElement("a");
                    dom.setAttribute(el1,"class","user-list-action");
                    dom.setAttribute(el1,"href","#");
                    var el2 = dom.createTextNode("\n                                            Resend\n                                        ");
                    dom.appendChild(el1, el2);
                    dom.appendChild(el0, el1);
                    var el1 = dom.createTextNode("\n");
                    dom.appendChild(el0, el1);
                    return el0;
                  },
                  buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
                    var element0 = dom.childAt(fragment, [1]);
                    var element1 = dom.childAt(fragment, [3]);
                    var morphs = new Array(2);
                    morphs[0] = dom.createElementMorph(element0);
                    morphs[1] = dom.createElementMorph(element1);
                    return morphs;
                  },
                  statements: [
                    ["element","action",["revoke"],["target",["get","component"]]],
                    ["element","action",["resend"],["target",["get","component"]]]
                  ],
                  locals: [],
                  templates: []
                };
              }());
              return {
                meta: {
                  "revision": "Ember@1.13.2",
                  "loc": {
                    "source": null,
                    "start": {
                      "line": 24,
                      "column": 24
                    },
                    "end": {
                      "line": 52,
                      "column": 24
                    }
                  },
                  "moduleName": "ghost/templates/team/index.hbs"
                },
                arity: 1,
                cachedFragment: null,
                hasRendered: false,
                buildFragment: function buildFragment(dom) {
                  var el0 = dom.createDocumentFragment();
                  var el1 = dom.createTextNode("                            ");
                  dom.appendChild(el0, el1);
                  var el1 = dom.createElement("div");
                  dom.setAttribute(el1,"class","user-list-item");
                  var el2 = dom.createTextNode("\n                                ");
                  dom.appendChild(el1, el2);
                  var el2 = dom.createElement("span");
                  dom.setAttribute(el2,"class","user-list-item-icon icon-mail");
                  var el3 = dom.createTextNode("ic");
                  dom.appendChild(el2, el3);
                  dom.appendChild(el1, el2);
                  var el2 = dom.createTextNode("\n                                ");
                  dom.appendChild(el1, el2);
                  var el2 = dom.createElement("div");
                  dom.setAttribute(el2,"class","user-list-item-body");
                  var el3 = dom.createTextNode("\n                                    ");
                  dom.appendChild(el2, el3);
                  var el3 = dom.createElement("span");
                  dom.setAttribute(el3,"class","name");
                  var el4 = dom.createComment("");
                  dom.appendChild(el3, el4);
                  dom.appendChild(el2, el3);
                  var el3 = dom.createElement("br");
                  dom.appendChild(el2, el3);
                  var el3 = dom.createTextNode("\n");
                  dom.appendChild(el2, el3);
                  var el3 = dom.createComment("");
                  dom.appendChild(el2, el3);
                  var el3 = dom.createTextNode("                                ");
                  dom.appendChild(el2, el3);
                  dom.appendChild(el1, el2);
                  var el2 = dom.createTextNode("\n                                ");
                  dom.appendChild(el1, el2);
                  var el2 = dom.createElement("aside");
                  dom.setAttribute(el2,"class","user-list-item-aside");
                  var el3 = dom.createTextNode("\n");
                  dom.appendChild(el2, el3);
                  var el3 = dom.createComment("");
                  dom.appendChild(el2, el3);
                  var el3 = dom.createTextNode("                                ");
                  dom.appendChild(el2, el3);
                  dom.appendChild(el1, el2);
                  var el2 = dom.createTextNode("\n                            ");
                  dom.appendChild(el1, el2);
                  dom.appendChild(el0, el1);
                  var el1 = dom.createTextNode("\n");
                  dom.appendChild(el0, el1);
                  return el0;
                },
                buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
                  var element2 = dom.childAt(fragment, [1]);
                  var element3 = dom.childAt(element2, [3]);
                  var morphs = new Array(3);
                  morphs[0] = dom.createMorphAt(dom.childAt(element3, [1]),0,0);
                  morphs[1] = dom.createMorphAt(element3,4,4);
                  morphs[2] = dom.createMorphAt(dom.childAt(element2, [5]),1,1);
                  return morphs;
                },
                statements: [
                  ["content","user.email"],
                  ["block","if",[["get","user.pending"]],[],0,1],
                  ["block","if",[["get","component.isSending"]],[],2,3]
                ],
                locals: ["component"],
                templates: [child0, child1, child2, child3]
              };
            }());
            return {
              meta: {
                "revision": "Ember@1.13.2",
                "loc": {
                  "source": null,
                  "start": {
                    "line": 23,
                    "column": 20
                  },
                  "end": {
                    "line": 53,
                    "column": 20
                  }
                },
                "moduleName": "ghost/templates/team/index.hbs"
              },
              arity: 1,
              cachedFragment: null,
              hasRendered: false,
              buildFragment: function buildFragment(dom) {
                var el0 = dom.createDocumentFragment();
                var el1 = dom.createComment("");
                dom.appendChild(el0, el1);
                return el0;
              },
              buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
                var morphs = new Array(1);
                morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
                dom.insertBoundary(fragment, 0);
                dom.insertBoundary(fragment, null);
                return morphs;
              },
              statements: [
                ["block","gh-user-invited",[],["user",["subexpr","@mut",[["get","user"]],[]],"reload","reload"],0,null]
              ],
              locals: ["user"],
              templates: [child0]
            };
          }());
          return {
            meta: {
              "revision": "Ember@1.13.2",
              "loc": {
                "source": null,
                "start": {
                  "line": 20,
                  "column": 12
                },
                "end": {
                  "line": 55,
                  "column": 12
                }
              },
              "moduleName": "ghost/templates/team/index.hbs"
            },
            arity: 0,
            cachedFragment: null,
            hasRendered: false,
            buildFragment: function buildFragment(dom) {
              var el0 = dom.createDocumentFragment();
              var el1 = dom.createTextNode("                ");
              dom.appendChild(el0, el1);
              var el1 = dom.createElement("section");
              dom.setAttribute(el1,"class","user-list invited-users");
              var el2 = dom.createTextNode("\n                    ");
              dom.appendChild(el1, el2);
              var el2 = dom.createElement("h4");
              dom.setAttribute(el2,"class","user-list-title");
              var el3 = dom.createTextNode("Invited users");
              dom.appendChild(el2, el3);
              dom.appendChild(el1, el2);
              var el2 = dom.createTextNode("\n");
              dom.appendChild(el1, el2);
              var el2 = dom.createComment("");
              dom.appendChild(el1, el2);
              var el2 = dom.createTextNode("                ");
              dom.appendChild(el1, el2);
              dom.appendChild(el0, el1);
              var el1 = dom.createTextNode("\n");
              dom.appendChild(el0, el1);
              return el0;
            },
            buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
              var morphs = new Array(1);
              morphs[0] = dom.createMorphAt(dom.childAt(fragment, [1]),3,3);
              return morphs;
            },
            statements: [
              ["block","each",[["get","invitedUsers"]],[],0,null]
            ],
            locals: [],
            templates: [child0]
          };
        }());
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 19,
                "column": 8
              },
              "end": {
                "line": 56,
                "column": 8
              }
            },
            "moduleName": "ghost/templates/team/index.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createComment("");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
            var morphs = new Array(1);
            morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
            dom.insertBoundary(fragment, 0);
            dom.insertBoundary(fragment, null);
            return morphs;
          },
          statements: [
            ["block","if",[["get","invitedUsers"]],[],0,null]
          ],
          locals: [],
          templates: [child0]
        };
      }());
      var child1 = (function() {
        var child0 = (function() {
          var child0 = (function() {
            var child0 = (function() {
              return {
                meta: {
                  "revision": "Ember@1.13.2",
                  "loc": {
                    "source": null,
                    "start": {
                      "line": 64,
                      "column": 24
                    },
                    "end": {
                      "line": 66,
                      "column": 24
                    }
                  },
                  "moduleName": "ghost/templates/team/index.hbs"
                },
                arity: 0,
                cachedFragment: null,
                hasRendered: false,
                buildFragment: function buildFragment(dom) {
                  var el0 = dom.createDocumentFragment();
                  var el1 = dom.createTextNode("                            ");
                  dom.appendChild(el0, el1);
                  var el1 = dom.createComment("");
                  dom.appendChild(el0, el1);
                  var el1 = dom.createTextNode("\n");
                  dom.appendChild(el0, el1);
                  return el0;
                },
                buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
                  var morphs = new Array(1);
                  morphs[0] = dom.createMorphAt(fragment,1,1,contextualElement);
                  return morphs;
                },
                statements: [
                  ["inline","partial",["user-list-item"],[]]
                ],
                locals: [],
                templates: []
              };
            }());
            return {
              meta: {
                "revision": "Ember@1.13.2",
                "loc": {
                  "source": null,
                  "start": {
                    "line": 63,
                    "column": 20
                  },
                  "end": {
                    "line": 67,
                    "column": 20
                  }
                },
                "moduleName": "ghost/templates/team/index.hbs"
              },
              arity: 1,
              cachedFragment: null,
              hasRendered: false,
              buildFragment: function buildFragment(dom) {
                var el0 = dom.createDocumentFragment();
                var el1 = dom.createComment("");
                dom.appendChild(el0, el1);
                return el0;
              },
              buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
                var morphs = new Array(1);
                morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
                dom.insertBoundary(fragment, 0);
                dom.insertBoundary(fragment, null);
                return morphs;
              },
              statements: [
                ["block","link-to",["team.user",["get","user"]],["class","user-list-item"],0,null]
              ],
              locals: ["component"],
              templates: [child0]
            };
          }());
          return {
            meta: {
              "revision": "Ember@1.13.2",
              "loc": {
                "source": null,
                "start": {
                  "line": 62,
                  "column": 16
                },
                "end": {
                  "line": 68,
                  "column": 16
                }
              },
              "moduleName": "ghost/templates/team/index.hbs"
            },
            arity: 0,
            cachedFragment: null,
            hasRendered: false,
            buildFragment: function buildFragment(dom) {
              var el0 = dom.createDocumentFragment();
              var el1 = dom.createComment("");
              dom.appendChild(el0, el1);
              return el0;
            },
            buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
              var morphs = new Array(1);
              morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
              dom.insertBoundary(fragment, 0);
              dom.insertBoundary(fragment, null);
              return morphs;
            },
            statements: [
              ["block","gh-user-active",[],["user",["subexpr","@mut",[["get","user"]],[]]],0,null]
            ],
            locals: [],
            templates: [child0]
          };
        }());
        var child1 = (function() {
          var child0 = (function() {
            return {
              meta: {
                "revision": "Ember@1.13.2",
                "loc": {
                  "source": null,
                  "start": {
                    "line": 69,
                    "column": 20
                  },
                  "end": {
                    "line": 71,
                    "column": 20
                  }
                },
                "moduleName": "ghost/templates/team/index.hbs"
              },
              arity: 1,
              cachedFragment: null,
              hasRendered: false,
              buildFragment: function buildFragment(dom) {
                var el0 = dom.createDocumentFragment();
                var el1 = dom.createTextNode("                        ");
                dom.appendChild(el0, el1);
                var el1 = dom.createElement("li");
                dom.setAttribute(el1,"class","ember-view active user-list-item");
                var el2 = dom.createComment("");
                dom.appendChild(el1, el2);
                dom.appendChild(el0, el1);
                var el1 = dom.createTextNode("\n");
                dom.appendChild(el0, el1);
                return el0;
              },
              buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
                var morphs = new Array(1);
                morphs[0] = dom.createMorphAt(dom.childAt(fragment, [1]),0,0);
                return morphs;
              },
              statements: [
                ["inline","partial",["user-list-item"],[]]
              ],
              locals: ["component"],
              templates: []
            };
          }());
          return {
            meta: {
              "revision": "Ember@1.13.2",
              "loc": {
                "source": null,
                "start": {
                  "line": 68,
                  "column": 16
                },
                "end": {
                  "line": 72,
                  "column": 16
                }
              },
              "moduleName": "ghost/templates/team/index.hbs"
            },
            arity: 0,
            cachedFragment: null,
            hasRendered: false,
            buildFragment: function buildFragment(dom) {
              var el0 = dom.createDocumentFragment();
              var el1 = dom.createComment("");
              dom.appendChild(el0, el1);
              return el0;
            },
            buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
              var morphs = new Array(1);
              morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
              dom.insertBoundary(fragment, 0);
              dom.insertBoundary(fragment, null);
              return morphs;
            },
            statements: [
              ["block","gh-user-active",[],["user",["subexpr","@mut",[["get","user"]],[]]],0,null]
            ],
            locals: [],
            templates: [child0]
          };
        }());
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 60,
                "column": 12
              },
              "end": {
                "line": 73,
                "column": 12
              }
            },
            "moduleName": "ghost/templates/team/index.hbs"
          },
          arity: 1,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createComment("");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
            var morphs = new Array(1);
            morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
            dom.insertBoundary(fragment, 0);
            dom.insertBoundary(fragment, null);
            return morphs;
          },
          statements: [
            ["block","unless",[["get","session.user.isAuthor"]],[],0,1]
          ],
          locals: ["user"],
          templates: [child0, child1]
        };
      }());
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 12,
              "column": 4
            },
            "end": {
              "line": 75,
              "column": 4
            }
          },
          "moduleName": "ghost/templates/team/index.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n        ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("section");
          dom.setAttribute(el1,"class","user-list active-users");
          var el2 = dom.createTextNode("\n            ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("h4");
          dom.setAttribute(el2,"class","user-list-title");
          var el3 = dom.createTextNode("Active users");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n");
          dom.appendChild(el1, el2);
          var el2 = dom.createComment("");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("        ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(2);
          morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
          morphs[1] = dom.createMorphAt(dom.childAt(fragment, [2]),3,3);
          dom.insertBoundary(fragment, 0);
          return morphs;
        },
        statements: [
          ["block","unless",[["get","session.user.isAuthor"]],[],0,null],
          ["block","each",[["get","activeUsers"]],["key","id"],1,null]
        ],
        locals: [],
        templates: [child0, child1]
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 77,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/team/index.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createElement("section");
        dom.setAttribute(el1,"class","gh-view");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("header");
        dom.setAttribute(el2,"class","view-header");
        var el3 = dom.createTextNode("\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createComment("");
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n");
        dom.appendChild(el2, el3);
        var el3 = dom.createComment("");
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n\n");
        dom.appendChild(el1, el2);
        var el2 = dom.createComment("");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var element5 = dom.childAt(fragment, [0]);
        var element6 = dom.childAt(element5, [1]);
        var morphs = new Array(3);
        morphs[0] = dom.createMorphAt(element6,1,1);
        morphs[1] = dom.createMorphAt(element6,3,3);
        morphs[2] = dom.createMorphAt(element5,3,3);
        return morphs;
      },
      statements: [
        ["block","gh-view-title",[],["openMobileMenu","openMobileMenu"],0,null],
        ["block","unless",[["get","session.user.isAuthor"]],[],1,null],
        ["block","gh-infinite-scroll",[],["fetch","loadNextPage","isLoading",["subexpr","@mut",[["get","isLoading"]],[]],"tagName","section","classNames","view-content team"],2,null]
      ],
      locals: [],
      templates: [child0, child1, child2]
    };
  }()));

});
define('ghost/templates/team/user', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    var child0 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 3,
              "column": 8
            },
            "end": {
              "line": 6,
              "column": 8
            }
          },
          "moduleName": "ghost/templates/team/user.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("            ");
          dom.appendChild(el0, el1);
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n            ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("i");
          dom.setAttribute(el1,"class","icon-arrow-right");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode(" ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("span");
          var el2 = dom.createComment("");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(2);
          morphs[0] = dom.createMorphAt(fragment,1,1,contextualElement);
          morphs[1] = dom.createMorphAt(dom.childAt(fragment, [5]),0,0);
          return morphs;
        },
        statements: [
          ["inline","link-to",["Team","team"],[]],
          ["content","user.name"]
        ],
        locals: [],
        templates: []
      };
    }());
    var child1 = (function() {
      var child0 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 10,
                "column": 20
              },
              "end": {
                "line": 13,
                "column": 20
              }
            },
            "moduleName": "ghost/templates/team/user.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createTextNode("                        ");
            dom.appendChild(el0, el1);
            var el1 = dom.createElement("i");
            dom.setAttribute(el1,"class","icon-settings");
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n                        ");
            dom.appendChild(el0, el1);
            var el1 = dom.createElement("span");
            dom.setAttribute(el1,"class","hidden");
            var el2 = dom.createTextNode("User Settings");
            dom.appendChild(el1, el2);
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes() { return []; },
          statements: [

          ],
          locals: [],
          templates: []
        };
      }());
      var child1 = (function() {
        var child0 = (function() {
          return {
            meta: {
              "revision": "Ember@1.13.2",
              "loc": {
                "source": null,
                "start": {
                  "line": 15,
                  "column": 24
                },
                "end": {
                  "line": 21,
                  "column": 24
                }
              },
              "moduleName": "ghost/templates/team/user.hbs"
            },
            arity: 0,
            cachedFragment: null,
            hasRendered: false,
            buildFragment: function buildFragment(dom) {
              var el0 = dom.createDocumentFragment();
              var el1 = dom.createTextNode("                            ");
              dom.appendChild(el0, el1);
              var el1 = dom.createElement("li");
              var el2 = dom.createTextNode("\n                                ");
              dom.appendChild(el1, el2);
              var el2 = dom.createElement("button");
              var el3 = dom.createTextNode("\n                                    Make Owner\n                                ");
              dom.appendChild(el2, el3);
              dom.appendChild(el1, el2);
              var el2 = dom.createTextNode("\n                            ");
              dom.appendChild(el1, el2);
              dom.appendChild(el0, el1);
              var el1 = dom.createTextNode("\n");
              dom.appendChild(el0, el1);
              return el0;
            },
            buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
              var element4 = dom.childAt(fragment, [1, 1]);
              var morphs = new Array(1);
              morphs[0] = dom.createElementMorph(element4);
              return morphs;
            },
            statements: [
              ["element","action",["openModal","transfer-owner",["get","this"]],[]]
            ],
            locals: [],
            templates: []
          };
        }());
        var child1 = (function() {
          return {
            meta: {
              "revision": "Ember@1.13.2",
              "loc": {
                "source": null,
                "start": {
                  "line": 22,
                  "column": 24
                },
                "end": {
                  "line": 28,
                  "column": 24
                }
              },
              "moduleName": "ghost/templates/team/user.hbs"
            },
            arity: 0,
            cachedFragment: null,
            hasRendered: false,
            buildFragment: function buildFragment(dom) {
              var el0 = dom.createDocumentFragment();
              var el1 = dom.createTextNode("                            ");
              dom.appendChild(el0, el1);
              var el1 = dom.createElement("li");
              var el2 = dom.createTextNode("\n                                ");
              dom.appendChild(el1, el2);
              var el2 = dom.createElement("button");
              dom.setAttribute(el2,"class","delete");
              var el3 = dom.createTextNode("\n                                    Delete User\n                                ");
              dom.appendChild(el2, el3);
              dom.appendChild(el1, el2);
              var el2 = dom.createTextNode("\n                            ");
              dom.appendChild(el1, el2);
              dom.appendChild(el0, el1);
              var el1 = dom.createTextNode("\n");
              dom.appendChild(el0, el1);
              return el0;
            },
            buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
              var element3 = dom.childAt(fragment, [1, 1]);
              var morphs = new Array(1);
              morphs[0] = dom.createElementMorph(element3);
              return morphs;
            },
            statements: [
              ["element","action",["openModal","delete-user",["get","this"]],[]]
            ],
            locals: [],
            templates: []
          };
        }());
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 14,
                "column": 20
              },
              "end": {
                "line": 29,
                "column": 20
              }
            },
            "moduleName": "ghost/templates/team/user.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createComment("");
            dom.appendChild(el0, el1);
            var el1 = dom.createComment("");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
            var morphs = new Array(2);
            morphs[0] = dom.createMorphAt(fragment,0,0,contextualElement);
            morphs[1] = dom.createMorphAt(fragment,1,1,contextualElement);
            dom.insertBoundary(fragment, 0);
            dom.insertBoundary(fragment, null);
            return morphs;
          },
          statements: [
            ["block","if",[["get","canMakeOwner"]],[],0,null],
            ["block","if",[["get","deleteUserActionIsVisible"]],[],1,null]
          ],
          locals: [],
          templates: [child0, child1]
        };
      }());
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 8,
              "column": 12
            },
            "end": {
              "line": 31,
              "column": 12
            }
          },
          "moduleName": "ghost/templates/team/user.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("                ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("span");
          dom.setAttribute(el1,"class","dropdown");
          var el2 = dom.createTextNode("\n");
          dom.appendChild(el1, el2);
          var el2 = dom.createComment("");
          dom.appendChild(el1, el2);
          var el2 = dom.createComment("");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("                ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var element5 = dom.childAt(fragment, [1]);
          var morphs = new Array(2);
          morphs[0] = dom.createMorphAt(element5,1,1);
          morphs[1] = dom.createMorphAt(element5,2,2);
          return morphs;
        },
        statements: [
          ["block","gh-dropdown-button",[],["dropdownName","user-actions-menu","classNames","btn btn-default only-has-icon user-actions-cog","title","User Actions"],0,null],
          ["block","gh-dropdown",[],["name","user-actions-menu","tagName","ul","classNames","user-actions-menu dropdown-menu dropdown-triangle-top-right"],1,null]
        ],
        locals: [],
        templates: [child0, child1]
      };
    }());
    var child2 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 33,
              "column": 12
            },
            "end": {
              "line": 33,
              "column": 92
            }
          },
          "moduleName": "ghost/templates/team/user.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("Save");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes() { return []; },
        statements: [

        ],
        locals: [],
        templates: []
      };
    }());
    var child3 = (function() {
      var child0 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 59,
                "column": 20
              },
              "end": {
                "line": 61,
                "column": 20
              }
            },
            "moduleName": "ghost/templates/team/user.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createTextNode("                        ");
            dom.appendChild(el0, el1);
            var el1 = dom.createComment("");
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
            var morphs = new Array(1);
            morphs[0] = dom.createMorphAt(fragment,1,1,contextualElement);
            return morphs;
          },
          statements: [
            ["inline","gh-error-message",[],["errors",["subexpr","@mut",[["get","user.errors"]],[]],"property","name"]]
          ],
          locals: [],
          templates: []
        };
      }());
      var child1 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 61,
                "column": 20
              },
              "end": {
                "line": 63,
                "column": 20
              }
            },
            "moduleName": "ghost/templates/team/user.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createTextNode("                        ");
            dom.appendChild(el0, el1);
            var el1 = dom.createElement("p");
            var el2 = dom.createTextNode("Use your real name so people can recognise you");
            dom.appendChild(el1, el2);
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes() { return []; },
          statements: [

          ],
          locals: [],
          templates: []
        };
      }());
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 56,
              "column": 16
            },
            "end": {
              "line": 64,
              "column": 16
            }
          },
          "moduleName": "ghost/templates/team/user.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("label");
          dom.setAttribute(el1,"for","user-name");
          var el2 = dom.createTextNode("Full Name");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(2);
          morphs[0] = dom.createMorphAt(fragment,3,3,contextualElement);
          morphs[1] = dom.createMorphAt(fragment,5,5,contextualElement);
          dom.insertBoundary(fragment, null);
          return morphs;
        },
        statements: [
          ["inline","input",[],["value",["subexpr","@mut",[["get","user.name"]],[]],"id","user-name","class","gh-input user-name","placeholder","Full Name","autocorrect","off","focusOut",["subexpr","action",["validate","name"],[]]]],
          ["block","if",[["get","user.errors.name"]],[],0,1]
        ],
        locals: [],
        templates: [child0, child1]
      };
    }());
    var child4 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 70,
              "column": 16
            },
            "end": {
              "line": 75,
              "column": 16
            }
          },
          "moduleName": "ghost/templates/team/user.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("label");
          dom.setAttribute(el1,"for","user-slug");
          var el2 = dom.createTextNode("Slug");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("p");
          var el2 = dom.createComment("");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("/author/");
          dom.appendChild(el1, el2);
          var el2 = dom.createComment("");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var element2 = dom.childAt(fragment, [5]);
          var morphs = new Array(4);
          morphs[0] = dom.createMorphAt(fragment,3,3,contextualElement);
          morphs[1] = dom.createMorphAt(element2,0,0);
          morphs[2] = dom.createMorphAt(element2,2,2);
          morphs[3] = dom.createMorphAt(fragment,7,7,contextualElement);
          return morphs;
        },
        statements: [
          ["inline","gh-input",[],["class","gh-input user-name","id","user-slug","value",["subexpr","@mut",[["get","slugValue"]],[]],"name","user","focus-out","updateSlug","placeholder","Slug","selectOnClick","true","autocorrect","off"]],
          ["content","gh-blog-url"],
          ["content","slugValue"],
          ["inline","gh-error-message",[],["errors",["subexpr","@mut",[["get","user.errors"]],[]],"property","slug"]]
        ],
        locals: [],
        templates: []
      };
    }());
    var child5 = (function() {
      var child0 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 80,
                "column": 20
              },
              "end": {
                "line": 83,
                "column": 20
              }
            },
            "moduleName": "ghost/templates/team/user.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createTextNode("                        ");
            dom.appendChild(el0, el1);
            var el1 = dom.createComment("");
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n                        ");
            dom.appendChild(el0, el1);
            var el1 = dom.createComment("");
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
            var morphs = new Array(2);
            morphs[0] = dom.createMorphAt(fragment,1,1,contextualElement);
            morphs[1] = dom.createMorphAt(fragment,3,3,contextualElement);
            return morphs;
          },
          statements: [
            ["inline","input",[],["type","email","value",["subexpr","@mut",[["get","user.email"]],[]],"id","user-email","name","email","class","gh-input","placeholder","Email Address","autocapitalize","off","autocorrect","off","autocomplete","off","focusOut",["subexpr","action",["validate","email"],[]]]],
            ["inline","gh-error-message",[],["errors",["subexpr","@mut",[["get","user.errors"]],[]],"property","email"]]
          ],
          locals: [],
          templates: []
        };
      }());
      var child1 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 83,
                "column": 20
              },
              "end": {
                "line": 85,
                "column": 20
              }
            },
            "moduleName": "ghost/templates/team/user.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createTextNode("                        ");
            dom.appendChild(el0, el1);
            var el1 = dom.createElement("span");
            var el2 = dom.createComment("");
            dom.appendChild(el1, el2);
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
            var morphs = new Array(1);
            morphs[0] = dom.createMorphAt(dom.childAt(fragment, [1]),0,0);
            return morphs;
          },
          statements: [
            ["content","user.email"]
          ],
          locals: [],
          templates: []
        };
      }());
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 77,
              "column": 16
            },
            "end": {
              "line": 87,
              "column": 16
            }
          },
          "moduleName": "ghost/templates/team/user.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("label");
          dom.setAttribute(el1,"for","user-email");
          var el2 = dom.createTextNode("Email");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("p");
          var el2 = dom.createTextNode("Used for notifications");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(1);
          morphs[0] = dom.createMorphAt(fragment,3,3,contextualElement);
          return morphs;
        },
        statements: [
          ["block","unless",[["get","isAdminUserOnOwnerProfile"]],[],0,1]
        ],
        locals: [],
        templates: [child0, child1]
      };
    }());
    var child6 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 89,
              "column": 16
            },
            "end": {
              "line": 103,
              "column": 16
            }
          },
          "moduleName": "ghost/templates/team/user.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("div");
          dom.setAttribute(el1,"class","form-group");
          var el2 = dom.createTextNode("\n                        ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("label");
          dom.setAttribute(el2,"for","user-role");
          var el3 = dom.createTextNode("Role");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n                        ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("span");
          dom.setAttribute(el2,"class","gh-select");
          dom.setAttribute(el2,"tabindex","0");
          var el3 = dom.createTextNode("\n                            ");
          dom.appendChild(el2, el3);
          var el3 = dom.createComment("");
          dom.appendChild(el2, el3);
          var el3 = dom.createTextNode("\n                        ");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n                        ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("p");
          var el3 = dom.createTextNode("What permissions should this user have?");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n                    ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(1);
          morphs[0] = dom.createMorphAt(dom.childAt(fragment, [1, 3]),1,1);
          return morphs;
        },
        statements: [
          ["inline","gh-select-native",[],["id","new-user-role","content",["subexpr","@mut",[["get","roles"]],[]],"optionValuePath","id","optionLabelPath","name","selection",["subexpr","@mut",[["get","model.role"]],[]],"action","changeRole"]]
        ],
        locals: [],
        templates: []
      };
    }());
    var child7 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 105,
              "column": 16
            },
            "end": {
              "line": 110,
              "column": 16
            }
          },
          "moduleName": "ghost/templates/team/user.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("label");
          dom.setAttribute(el1,"for","user-location");
          var el2 = dom.createTextNode("Location");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("p");
          var el2 = dom.createTextNode("Where in the world do you live?");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(2);
          morphs[0] = dom.createMorphAt(fragment,3,3,contextualElement);
          morphs[1] = dom.createMorphAt(fragment,5,5,contextualElement);
          return morphs;
        },
        statements: [
          ["inline","input",[],["type","text","value",["subexpr","@mut",[["get","user.location"]],[]],"id","user-location","class","gh-input","focusOut",["subexpr","action",["validate","location"],[]]]],
          ["inline","gh-error-message",[],["errors",["subexpr","@mut",[["get","user.errors"]],[]],"property","location"]]
        ],
        locals: [],
        templates: []
      };
    }());
    var child8 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 112,
              "column": 16
            },
            "end": {
              "line": 117,
              "column": 16
            }
          },
          "moduleName": "ghost/templates/team/user.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("label");
          dom.setAttribute(el1,"for","user-website");
          var el2 = dom.createTextNode("Website");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("p");
          var el2 = dom.createTextNode("Have a website or blog other than this one? Link it!");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(2);
          morphs[0] = dom.createMorphAt(fragment,3,3,contextualElement);
          morphs[1] = dom.createMorphAt(fragment,5,5,contextualElement);
          return morphs;
        },
        statements: [
          ["inline","input",[],["type","url","value",["subexpr","@mut",[["get","user.website"]],[]],"id","user-website","class","gh-input","autocapitalize","off","autocorrect","off","autocomplete","off","focusOut",["subexpr","action",["validate","website"],[]]]],
          ["inline","gh-error-message",[],["errors",["subexpr","@mut",[["get","user.errors"]],[]],"property","website"]]
        ],
        locals: [],
        templates: []
      };
    }());
    var child9 = (function() {
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 119,
              "column": 16
            },
            "end": {
              "line": 127,
              "column": 16
            }
          },
          "moduleName": "ghost/templates/team/user.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("label");
          dom.setAttribute(el1,"for","user-bio");
          var el2 = dom.createTextNode("Bio");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createComment("");
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n                    ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("p");
          var el2 = dom.createTextNode("\n                        Write about you, in 200 characters or less.\n                        ");
          dom.appendChild(el1, el2);
          var el2 = dom.createComment("");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n                    ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var morphs = new Array(3);
          morphs[0] = dom.createMorphAt(fragment,3,3,contextualElement);
          morphs[1] = dom.createMorphAt(fragment,5,5,contextualElement);
          morphs[2] = dom.createMorphAt(dom.childAt(fragment, [7]),1,1);
          return morphs;
        },
        statements: [
          ["inline","textarea",[],["id","user-bio","class","gh-input","value",["subexpr","@mut",[["get","user.bio"]],[]],"focusOut",["subexpr","action",["validate","bio"],[]]]],
          ["inline","gh-error-message",[],["errors",["subexpr","@mut",[["get","user.errors"]],[]],"property","bio"]],
          ["inline","gh-count-characters",[["get","user.bio"]],[]]
        ],
        locals: [],
        templates: []
      };
    }());
    var child10 = (function() {
      var child0 = (function() {
        return {
          meta: {
            "revision": "Ember@1.13.2",
            "loc": {
              "source": null,
              "start": {
                "line": 135,
                "column": 20
              },
              "end": {
                "line": 140,
                "column": 20
              }
            },
            "moduleName": "ghost/templates/team/user.hbs"
          },
          arity: 0,
          cachedFragment: null,
          hasRendered: false,
          buildFragment: function buildFragment(dom) {
            var el0 = dom.createDocumentFragment();
            var el1 = dom.createTextNode("                    ");
            dom.appendChild(el0, el1);
            var el1 = dom.createElement("div");
            dom.setAttribute(el1,"class","form-group");
            var el2 = dom.createTextNode("\n                        ");
            dom.appendChild(el1, el2);
            var el2 = dom.createElement("label");
            dom.setAttribute(el2,"for","user-password-old");
            var el3 = dom.createTextNode("Old Password");
            dom.appendChild(el2, el3);
            dom.appendChild(el1, el2);
            var el2 = dom.createTextNode("\n                        ");
            dom.appendChild(el1, el2);
            var el2 = dom.createComment("");
            dom.appendChild(el1, el2);
            var el2 = dom.createTextNode("\n                    ");
            dom.appendChild(el1, el2);
            dom.appendChild(el0, el1);
            var el1 = dom.createTextNode("\n");
            dom.appendChild(el0, el1);
            return el0;
          },
          buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
            var morphs = new Array(1);
            morphs[0] = dom.createMorphAt(dom.childAt(fragment, [1]),3,3);
            return morphs;
          },
          statements: [
            ["inline","input",[],["value",["subexpr","@mut",[["get","user.password"]],[]],"type","password","id","user-password-old","class","gh-input"]]
          ],
          locals: [],
          templates: []
        };
      }());
      return {
        meta: {
          "revision": "Ember@1.13.2",
          "loc": {
            "source": null,
            "start": {
              "line": 133,
              "column": 12
            },
            "end": {
              "line": 156,
              "column": 12
            }
          },
          "moduleName": "ghost/templates/team/user.hbs"
        },
        arity: 0,
        cachedFragment: null,
        hasRendered: false,
        buildFragment: function buildFragment(dom) {
          var el0 = dom.createDocumentFragment();
          var el1 = dom.createTextNode("                ");
          dom.appendChild(el0, el1);
          var el1 = dom.createElement("fieldset");
          var el2 = dom.createTextNode("\n");
          dom.appendChild(el1, el2);
          var el2 = dom.createComment("");
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n                    ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("div");
          dom.setAttribute(el2,"class","form-group");
          var el3 = dom.createTextNode("\n                        ");
          dom.appendChild(el2, el3);
          var el3 = dom.createElement("label");
          dom.setAttribute(el3,"for","user-password-new");
          var el4 = dom.createTextNode("New Password");
          dom.appendChild(el3, el4);
          dom.appendChild(el2, el3);
          var el3 = dom.createTextNode("\n                        ");
          dom.appendChild(el2, el3);
          var el3 = dom.createComment("");
          dom.appendChild(el2, el3);
          var el3 = dom.createTextNode("\n                    ");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n\n                    ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("div");
          dom.setAttribute(el2,"class","form-group");
          var el3 = dom.createTextNode("\n                        ");
          dom.appendChild(el2, el3);
          var el3 = dom.createElement("label");
          dom.setAttribute(el3,"for","user-new-password-verification");
          var el4 = dom.createTextNode("Verify Password");
          dom.appendChild(el3, el4);
          dom.appendChild(el2, el3);
          var el3 = dom.createTextNode("\n                        ");
          dom.appendChild(el2, el3);
          var el3 = dom.createComment("");
          dom.appendChild(el2, el3);
          var el3 = dom.createTextNode("\n                    ");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n                    ");
          dom.appendChild(el1, el2);
          var el2 = dom.createElement("div");
          dom.setAttribute(el2,"class","form-group");
          var el3 = dom.createTextNode("\n                        ");
          dom.appendChild(el2, el3);
          var el3 = dom.createElement("button");
          dom.setAttribute(el3,"type","button");
          dom.setAttribute(el3,"class","btn btn-red button-change-password");
          var el4 = dom.createTextNode("Change Password");
          dom.appendChild(el3, el4);
          dom.appendChild(el2, el3);
          var el3 = dom.createTextNode("\n                    ");
          dom.appendChild(el2, el3);
          dom.appendChild(el1, el2);
          var el2 = dom.createTextNode("\n\n                ");
          dom.appendChild(el1, el2);
          dom.appendChild(el0, el1);
          var el1 = dom.createTextNode("\n");
          dom.appendChild(el0, el1);
          return el0;
        },
        buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
          var element0 = dom.childAt(fragment, [1]);
          var element1 = dom.childAt(element0, [7, 1]);
          var morphs = new Array(4);
          morphs[0] = dom.createMorphAt(element0,1,1);
          morphs[1] = dom.createMorphAt(dom.childAt(element0, [3]),3,3);
          morphs[2] = dom.createMorphAt(dom.childAt(element0, [5]),3,3);
          morphs[3] = dom.createElementMorph(element1);
          return morphs;
        },
        statements: [
          ["block","unless",[["get","isNotOwnProfile"]],[],0,null],
          ["inline","input",[],["value",["subexpr","@mut",[["get","user.newPassword"]],[]],"type","password","id","user-password-new","class","gh-input"]],
          ["inline","input",[],["value",["subexpr","@mut",[["get","user.ne2Password"]],[]],"type","password","id","user-new-password-verification","class","gh-input"]],
          ["element","action",["password"],[]]
        ],
        locals: [],
        templates: [child0]
      };
    }());
    return {
      meta: {
        "revision": "Ember@1.13.2",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 160,
            "column": 0
          }
        },
        "moduleName": "ghost/templates/team/user.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createElement("section");
        dom.setAttribute(el1,"class","gh-view");
        var el2 = dom.createTextNode("\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("header");
        dom.setAttribute(el2,"class","view-header");
        var el3 = dom.createTextNode("\n");
        dom.appendChild(el2, el3);
        var el3 = dom.createComment("");
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("section");
        dom.setAttribute(el3,"class","view-actions");
        var el4 = dom.createTextNode("\n");
        dom.appendChild(el3, el4);
        var el4 = dom.createComment("");
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createComment("");
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n        ");
        dom.appendChild(el3, el4);
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n\n    ");
        dom.appendChild(el1, el2);
        var el2 = dom.createElement("div");
        dom.setAttribute(el2,"class","view-container settings-user");
        var el3 = dom.createTextNode("\n\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("figure");
        dom.setAttribute(el3,"class","user-cover");
        var el4 = dom.createTextNode("\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createElement("button");
        dom.setAttribute(el4,"class","btn btn-default user-cover-edit js-modal-cover");
        var el5 = dom.createTextNode("Change Cover");
        dom.appendChild(el4, el5);
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n        ");
        dom.appendChild(el3, el4);
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n\n        ");
        dom.appendChild(el2, el3);
        var el3 = dom.createElement("form");
        dom.setAttribute(el3,"class","user-profile");
        dom.setAttribute(el3,"novalidate","novalidate");
        dom.setAttribute(el3,"autocomplete","off");
        var el4 = dom.createTextNode("\n\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createElement("input");
        dom.setAttribute(el4,"style","display:none;");
        dom.setAttribute(el4,"type","text");
        dom.setAttribute(el4,"name","fakeusernameremembered");
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createElement("input");
        dom.setAttribute(el4,"style","display:none;");
        dom.setAttribute(el4,"type","password");
        dom.setAttribute(el4,"name","fakepasswordremembered");
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createElement("fieldset");
        dom.setAttribute(el4,"class","user-details-top");
        var el5 = dom.createTextNode("\n\n                ");
        dom.appendChild(el4, el5);
        var el5 = dom.createElement("figure");
        dom.setAttribute(el5,"class","user-image");
        var el6 = dom.createTextNode("\n                    ");
        dom.appendChild(el5, el6);
        var el6 = dom.createElement("div");
        dom.setAttribute(el6,"id","user-image");
        dom.setAttribute(el6,"class","img");
        var el7 = dom.createElement("span");
        dom.setAttribute(el7,"class","hidden");
        var el8 = dom.createComment("");
        dom.appendChild(el7, el8);
        var el8 = dom.createTextNode("\"s Picture");
        dom.appendChild(el7, el8);
        dom.appendChild(el6, el7);
        dom.appendChild(el5, el6);
        var el6 = dom.createTextNode("\n                    ");
        dom.appendChild(el5, el6);
        var el6 = dom.createElement("button");
        dom.setAttribute(el6,"type","button");
        dom.setAttribute(el6,"class","edit-user-image js-modal-image");
        var el7 = dom.createTextNode("Edit Picture");
        dom.appendChild(el6, el7);
        dom.appendChild(el5, el6);
        var el6 = dom.createTextNode("\n                ");
        dom.appendChild(el5, el6);
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n\n");
        dom.appendChild(el4, el5);
        var el5 = dom.createComment("");
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n            ");
        dom.appendChild(el4, el5);
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n\n            ");
        dom.appendChild(el3, el4);
        var el4 = dom.createElement("fieldset");
        dom.setAttribute(el4,"class","user-details-bottom");
        var el5 = dom.createTextNode("\n\n");
        dom.appendChild(el4, el5);
        var el5 = dom.createComment("");
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n");
        dom.appendChild(el4, el5);
        var el5 = dom.createComment("");
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n");
        dom.appendChild(el4, el5);
        var el5 = dom.createComment("");
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n");
        dom.appendChild(el4, el5);
        var el5 = dom.createComment("");
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n");
        dom.appendChild(el4, el5);
        var el5 = dom.createComment("");
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n");
        dom.appendChild(el4, el5);
        var el5 = dom.createComment("");
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n                ");
        dom.appendChild(el4, el5);
        var el5 = dom.createElement("hr");
        dom.appendChild(el4, el5);
        var el5 = dom.createTextNode("\n\n            ");
        dom.appendChild(el4, el5);
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("\n");
        dom.appendChild(el3, el4);
        var el4 = dom.createComment("");
        dom.appendChild(el3, el4);
        var el4 = dom.createTextNode("        ");
        dom.appendChild(el3, el4);
        dom.appendChild(el2, el3);
        var el3 = dom.createTextNode("\n    ");
        dom.appendChild(el2, el3);
        dom.appendChild(el1, el2);
        var el2 = dom.createTextNode("\n");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var element6 = dom.childAt(fragment, [0]);
        var element7 = dom.childAt(element6, [1]);
        var element8 = dom.childAt(element7, [3]);
        var element9 = dom.childAt(element6, [3]);
        var element10 = dom.childAt(element9, [1]);
        var element11 = dom.childAt(element10, [1]);
        var element12 = dom.childAt(element9, [3]);
        var element13 = dom.childAt(element12, [5]);
        var element14 = dom.childAt(element13, [1]);
        var element15 = dom.childAt(element14, [1]);
        var element16 = dom.childAt(element14, [3]);
        var element17 = dom.childAt(element12, [7]);
        var morphs = new Array(16);
        morphs[0] = dom.createMorphAt(element7,1,1);
        morphs[1] = dom.createMorphAt(element8,1,1);
        morphs[2] = dom.createMorphAt(element8,3,3);
        morphs[3] = dom.createAttrMorph(element10, 'style');
        morphs[4] = dom.createElementMorph(element11);
        morphs[5] = dom.createAttrMorph(element15, 'style');
        morphs[6] = dom.createMorphAt(dom.childAt(element15, [0]),0,0);
        morphs[7] = dom.createElementMorph(element16);
        morphs[8] = dom.createMorphAt(element13,3,3);
        morphs[9] = dom.createMorphAt(element17,1,1);
        morphs[10] = dom.createMorphAt(element17,3,3);
        morphs[11] = dom.createMorphAt(element17,5,5);
        morphs[12] = dom.createMorphAt(element17,7,7);
        morphs[13] = dom.createMorphAt(element17,9,9);
        morphs[14] = dom.createMorphAt(element17,11,11);
        morphs[15] = dom.createMorphAt(element12,9,9);
        return morphs;
      },
      statements: [
        ["block","gh-view-title",[],["openMobileMenu","openMobileMenu"],0,null],
        ["block","if",[["get","userActionsAreVisible"]],[],1,null],
        ["block","gh-spin-button",[],["class","btn btn-blue","action","save","submitting",["subexpr","@mut",[["get","submitting"]],[]]],2,null],
        ["attribute","style",["concat",[["get","coverImageBackground"]]]],
        ["element","action",["openModal","upload",["get","user"],"cover"],[]],
        ["attribute","style",["concat",[["get","userImageBackground"]]]],
        ["content","user.name"],
        ["element","action",["openModal","upload",["get","user"],"image"],[]],
        ["block","gh-form-group",[],["errors",["subexpr","@mut",[["get","user.errors"]],[]],"hasValidated",["subexpr","@mut",[["get","user.hasValidated"]],[]],"property","name","class","first-form-group"],3,null],
        ["block","gh-form-group",[],["errors",["subexpr","@mut",[["get","user.errors"]],[]],"hasValidated",["subexpr","@mut",[["get","user.hasValidated"]],[]],"property","slug"],4,null],
        ["block","gh-form-group",[],["errors",["subexpr","@mut",[["get","user.errors"]],[]],"hasValidated",["subexpr","@mut",[["get","user.hasValidated"]],[]],"property","email"],5,null],
        ["block","if",[["get","rolesDropdownIsVisible"]],[],6,null],
        ["block","gh-form-group",[],["errors",["subexpr","@mut",[["get","user.errors"]],[]],"hasValidated",["subexpr","@mut",[["get","user.hasValidated"]],[]],"property","location"],7,null],
        ["block","gh-form-group",[],["errors",["subexpr","@mut",[["get","user.errors"]],[]],"hasValidated",["subexpr","@mut",[["get","user.hasValidated"]],[]],"property","website"],8,null],
        ["block","gh-form-group",[],["errors",["subexpr","@mut",[["get","user.errors"]],[]],"hasValidated",["subexpr","@mut",[["get","user.hasValidated"]],[]],"property","bio","class","bio-container"],9,null],
        ["block","unless",[["get","isAdminUserOnOwnerProfile"]],[],10,null]
      ],
      locals: [],
      templates: [child0, child1, child2, child3, child4, child5, child6, child7, child8, child9, child10]
    };
  }()));

});
define('ghost/tests/helpers/resolver', ['exports', 'ember/resolver', 'ghost/config/environment'], function (exports, Resolver, config) {

    'use strict';

    var resolver = Resolver['default'].create();

    resolver.namespace = {
        modulePrefix: config['default'].modulePrefix,
        podModulePrefix: config['default'].podModulePrefix
    };

    exports['default'] = resolver;

});
define('ghost/tests/helpers/start-app', ['exports', 'ember', 'ghost/app', 'ghost/router', 'ghost/config/environment'], function (exports, Ember, Application, Router, config) {

    'use strict';

    function startApp(attrs) {
        var application,
            attributes = Ember['default'].merge({}, config['default'].APP);

        attributes = Ember['default'].merge(attributes, attrs); // use defaults, but you can override;

        Ember['default'].run(function () {
            application = Application['default'].create(attributes);
            application.setupForTesting();
            application.injectTestHelpers();
        });

        return application;
    }

    exports['default'] = startApp;

});
define('ghost/tests/test-helper', ['ghost/tests/helpers/resolver', 'ember-mocha'], function (resolver, ember_mocha) {

	'use strict';

	ember_mocha.setResolver(resolver['default']);

});
define('ghost/tests/unit/components/gh-alert-test', ['chai', 'ember-mocha', 'sinon'], function (chai, ember_mocha, sinon) {

    'use strict';

    /* jshint expr:true */
    ember_mocha.describeComponent('gh-alert', 'GhAlertComponent', {
        // specify the other units that are required for this test
        // needs: ['component:foo', 'helper:bar']
    }, function () {
        ember_mocha.it('renders', function () {
            // creates the component instance
            var component = this.subject();
            chai.expect(component._state).to.equal('preRender');

            component.set('message', { message: 'Test message', type: 'success' });

            // renders the component on the page
            this.render();
            chai.expect(component._state).to.equal('inDOM');

            chai.expect(this.$().prop('tagName')).to.equal('ARTICLE');
            chai.expect(this.$().hasClass('gh-alert')).to.be['true'];
            chai.expect(this.$().text()).to.match(/Test message/);
        });

        ember_mocha.it('maps success alert type to correct class', function () {
            var component = this.subject();
            component.set('message', { message: 'Test message', type: 'success' });
            chai.expect(this.$().hasClass('gh-alert-green')).to.be['true'];
        });

        ember_mocha.it('maps error alert type to correct class', function () {
            var component = this.subject();
            component.set('message', { message: 'Test message', type: 'error' });
            chai.expect(this.$().hasClass('gh-alert-red')).to.be['true'];
        });

        ember_mocha.it('maps warn alert type to correct class', function () {
            var component = this.subject();
            component.set('message', { message: 'Test message', type: 'warn' });
            chai.expect(this.$().hasClass('gh-alert-yellow')).to.be['true'];
        });

        ember_mocha.it('maps info alert type to correct class', function () {
            var component = this.subject();
            component.set('message', { message: 'Test message', type: 'info' });
            chai.expect(this.$().hasClass('gh-alert-blue')).to.be['true'];
        });

        ember_mocha.it('closes notification through notifications service', function () {
            var component = this.subject(),
                notifications = {},
                notification = { message: 'Test close', type: 'success' };

            notifications.closeNotification = sinon['default'].spy();
            component.set('notifications', notifications);
            component.set('message', notification);

            this.$().find('button').click();

            chai.expect(notifications.closeNotification.calledWith(notification)).to.be['true'];
        });
    });

});
define('ghost/tests/unit/components/gh-alerts-test', ['ember', 'chai', 'ember-mocha', 'sinon'], function (Ember, chai, ember_mocha, sinon) {

    'use strict';

    /* jshint expr:true */
    ember_mocha.describeComponent('gh-alerts', 'GhAlertsComponent', {
        // specify the other units that are required for this test
        needs: ['component:gh-alert']
    }, function () {
        beforeEach(function () {
            // Stub the notifications service
            var notifications = Ember['default'].Object.create();
            notifications.alerts = Ember['default'].A();
            notifications.alerts.pushObject({ message: 'First', type: 'error' });
            notifications.alerts.pushObject({ message: 'Second', type: 'warn' });

            this.subject().set('notifications', notifications);
        });

        ember_mocha.it('renders', function () {
            // creates the component instance
            var component = this.subject();
            chai.expect(component._state).to.equal('preRender');

            // renders the component on the page
            this.render();
            chai.expect(component._state).to.equal('inDOM');

            chai.expect(this.$().prop('tagName')).to.equal('ASIDE');
            chai.expect(this.$().hasClass('gh-alerts')).to.be['true'];
            chai.expect(this.$().children().length).to.equal(2);

            Ember['default'].run(function () {
                component.set('notifications.alerts', Ember['default'].A());
            });

            chai.expect(this.$().children().length).to.equal(0);
        });

        ember_mocha.it('triggers "notify" action when message count changes', function () {
            var component = this.subject();

            component.sendAction = sinon['default'].spy();

            component.get('notifications.alerts').pushObject({ message: 'New alert', type: 'info' });

            chai.expect(component.sendAction.calledWith('notify', 3)).to.be['true'];

            component.set('notifications.alerts', Ember['default'].A());

            chai.expect(component.sendAction.calledWith('notify', 0)).to.be['true'];
        });
    });

});
define('ghost/tests/unit/components/gh-app-test', ['chai', 'ember-mocha'], function (chai, ember_mocha) {

    'use strict';

    /* jshint expr:true */
    ember_mocha.describeComponent('gh-app', 'GhAppComponent', {
        // specify the other units that are required for this test
        // needs: ['component:foo', 'helper:bar']
    }, function () {
        ember_mocha.it('renders', function () {
            // creates the component instance
            var component = this.subject();

            chai.expect(component._state).to.equal('preRender');

            // renders the component on the page
            this.render();
            chai.expect(component._state).to.equal('inDOM');
        });
    });

});
define('ghost/tests/unit/components/gh-content-preview-content-test', ['chai', 'ember-mocha'], function (chai, ember_mocha) {

    'use strict';

    /* jshint expr:true */
    ember_mocha.describeComponent('gh-content-preview-content', 'GhContentPreviewContentComponent', {
        // specify the other units that are required for this test
        // needs: ['component:foo', 'helper:bar']
    }, function () {
        ember_mocha.it('renders', function () {
            // creates the component instance
            var component = this.subject();

            chai.expect(component._state).to.equal('preRender');

            // renders the component on the page
            this.render();
            chai.expect(component._state).to.equal('inDOM');
        });
    });

});
define('ghost/tests/unit/components/gh-editor-save-button-test', ['chai', 'ember-mocha'], function (chai, ember_mocha) {

    'use strict';

    /* jshint expr:true */
    ember_mocha.describeComponent('gh-editor-save-button', 'GhEditorSaveButtonComponent', {
        needs: ['component:gh-dropdown-button', 'component:gh-dropdown', 'component:gh-spin-button', 'service:dropdown']
    }, function () {
        ember_mocha.it('renders', function () {
            // creates the component instance
            var component = this.subject();

            chai.expect(component._state).to.equal('preRender');

            // renders the component on the page
            this.render();
            chai.expect(component._state).to.equal('inDOM');
        });
    });

});
define('ghost/tests/unit/components/gh-editor-test', ['chai', 'ember-mocha'], function (chai, ember_mocha) {

    'use strict';

    /* jshint expr:true */
    ember_mocha.describeComponent('gh-editor', 'GhEditorComponent', {
        // specify the other units that are required for this test
        // needs: ['component:foo', 'helper:bar']
    }, function () {
        ember_mocha.it('renders', function () {
            // creates the component instance
            var component = this.subject();

            chai.expect(component._state).to.equal('preRender');

            // renders the component on the page
            this.render();
            chai.expect(component._state).to.equal('inDOM');
        });
    });

});
define('ghost/tests/unit/components/gh-infinite-scroll-box-test', ['chai', 'ember-mocha'], function (chai, ember_mocha) {

    'use strict';

    /* jshint expr:true */
    ember_mocha.describeComponent('gh-infinite-scroll-box', 'GhInfiniteScrollBoxComponent', {
        // specify the other units that are required for this test
        // needs: ['component:foo', 'helper:bar']
    }, function () {
        ember_mocha.it('renders', function () {
            // creates the component instance
            var component = this.subject();

            chai.expect(component._state).to.equal('preRender');

            // renders the component on the page
            this.render();
            chai.expect(component._state).to.equal('inDOM');
        });
    });

});
define('ghost/tests/unit/components/gh-infinite-scroll-test', ['chai', 'ember-mocha'], function (chai, ember_mocha) {

    'use strict';

    /* jshint expr:true */
    ember_mocha.describeComponent('gh-infinite-scroll', 'GhInfiniteScrollComponent', {
        // specify the other units that are required for this test
        // needs: ['component:foo', 'helper:bar']
    }, function () {
        ember_mocha.it('renders', function () {
            // creates the component instance
            var component = this.subject();

            chai.expect(component._state).to.equal('preRender');

            // renders the component on the page
            this.render();
            chai.expect(component._state).to.equal('inDOM');
        });
    });

});
define('ghost/tests/unit/components/gh-navigation-test', ['chai', 'ember-mocha'], function (chai, ember_mocha) {

    'use strict';

    /* jshint expr:true */
    ember_mocha.describeComponent('gh-navigation', 'GhNavigationComponent', {
        // specify the other units that are required for this test
        // needs: ['component:foo', 'helper:bar']
    }, function () {
        ember_mocha.it('renders', function () {
            // creates the component instance
            var component = this.subject();

            chai.expect(component._state).to.equal('preRender');

            // renders the component on the page
            this.render();
            chai.expect(component._state).to.equal('inDOM');
        });
    });

});
define('ghost/tests/unit/components/gh-navitem-url-input-test', ['ember', 'chai', 'ember-mocha'], function (Ember, chai, ember_mocha) {

    'use strict';

    /* jshint expr:true */
    ember_mocha.describeComponent('gh-navitem-url-input', 'GhNavitemUrlInputComponent', {}, function () {
        ember_mocha.it('renders', function () {
            var component = this.subject();

            chai.expect(component._state).to.equal('preRender');

            this.render();

            chai.expect(component._state).to.equal('inDOM');
        });

        ember_mocha.it('renders correctly with a URL that matches the base URL', function () {
            var component = this.subject({
                baseUrl: 'http://example.com/'
            });

            Ember['default'].run(function () {
                component.set('value', 'http://example.com/');
            });

            this.render();

            chai.expect(this.$().val()).to.equal('http://example.com/');
        });

        ember_mocha.it('renders correctly with a relative URL', function () {
            var component = this.subject({
                baseUrl: 'http://example.com/'
            });

            Ember['default'].run(function () {
                component.set('value', '/go/docs');
            });

            this.render();

            chai.expect(this.$().val()).to.equal('/go/docs');
        });

        ember_mocha.it('renders correctly with a mailto URL', function () {
            var component = this.subject({
                baseUrl: 'http://example.com/'
            });

            Ember['default'].run(function () {
                component.set('value', 'mailto:someone@example.com');
            });

            this.render();

            chai.expect(this.$().val()).to.equal('mailto:someone@example.com');
        });

        ember_mocha.it('identifies a URL as relative', function () {
            var component = this.subject({
                baseUrl: 'http://example.com/',
                url: '/go/docs'
            });

            this.render();

            chai.expect(component.get('isRelative')).to.be.ok;

            Ember['default'].run(function () {
                component.set('value', 'http://example.com/go/docs');
            });

            chai.expect(component.get('isRelative')).to.not.be.ok;
        });

        ember_mocha.it('identifies a URL as the base URL', function () {
            var component = this.subject({
                baseUrl: 'http://example.com/'
            });

            this.render();

            Ember['default'].run(function () {
                component.set('value', 'http://example.com/');
            });

            chai.expect(component.get('isBaseUrl')).to.be.ok;

            Ember['default'].run(function () {
                component.set('value', 'http://example.com/go/');
            });

            chai.expect(component.get('isBaseUrl')).to.not.be.ok;
        });
    });

});
define('ghost/tests/unit/components/gh-notification-test', ['chai', 'ember-mocha', 'sinon'], function (chai, ember_mocha, sinon) {

    'use strict';

    /* jshint expr:true */
    ember_mocha.describeComponent('gh-notification', 'GhNotificationComponent', {
        // specify the other units that are required for this test
        // needs: ['component:foo', 'helper:bar']
    }, function () {
        ember_mocha.it('renders', function () {
            // creates the component instance
            var component = this.subject();
            chai.expect(component._state).to.equal('preRender');

            component.set('message', { message: 'Test message', type: 'success' });

            // renders the component on the page
            this.render();
            chai.expect(component._state).to.equal('inDOM');

            chai.expect(this.$().prop('tagName')).to.equal('ARTICLE');
            chai.expect(this.$().is('.gh-notification, .gh-notification-passive')).to.be['true'];
            chai.expect(this.$().text()).to.match(/Test message/);
        });

        ember_mocha.it('maps success alert type to correct class', function () {
            var component = this.subject();
            component.set('message', { message: 'Test message', type: 'success' });
            chai.expect(this.$().hasClass('gh-notification-green')).to.be['true'];
        });

        ember_mocha.it('maps error alert type to correct class', function () {
            var component = this.subject();
            component.set('message', { message: 'Test message', type: 'error' });
            chai.expect(this.$().hasClass('gh-notification-red')).to.be['true'];
        });

        ember_mocha.it('maps warn alert type to correct class', function () {
            var component = this.subject();
            component.set('message', { message: 'Test message', type: 'warn' });
            chai.expect(this.$().hasClass('gh-notification-yellow')).to.be['true'];
        });

        ember_mocha.it('closes notification through notifications service', function () {
            var component = this.subject(),
                notifications = {},
                notification = { message: 'Test close', type: 'success' };

            notifications.closeNotification = sinon['default'].spy();
            component.set('notifications', notifications);
            component.set('message', notification);

            this.$().find('button').click();

            chai.expect(notifications.closeNotification.calledWith(notification)).to.be['true'];
        });

        ember_mocha.it('closes notification when animationend event is triggered', function (done) {
            var component = this.subject(),
                notifications = {},
                notification = { message: 'Test close', type: 'success' };

            notifications.closeNotification = sinon['default'].spy();
            component.set('notifications', notifications);
            component.set('message', notification);

            // shorten the animation delay to speed up test
            this.$().css('animation-delay', '0.1s');
            setTimeout(function () {
                chai.expect(notifications.closeNotification.calledWith(notification)).to.be['true'];
                done();
            }, 150);
        });
    });

});
define('ghost/tests/unit/components/gh-notifications-test', ['ember', 'chai', 'ember-mocha'], function (Ember, chai, ember_mocha) {

    'use strict';

    /* jshint expr:true */
    ember_mocha.describeComponent('gh-notifications', 'GhNotificationsComponent', {
        // specify the other units that are required for this test
        needs: ['component:gh-notification']
    }, function () {
        beforeEach(function () {
            // Stub the notifications service
            var notifications = Ember['default'].Object.create();
            notifications.notifications = Ember['default'].A();
            notifications.notifications.pushObject({ message: 'First', type: 'error' });
            notifications.notifications.pushObject({ message: 'Second', type: 'warn' });

            this.subject().set('notifications', notifications);
        });

        ember_mocha.it('renders', function () {
            // creates the component instance
            var component = this.subject();
            chai.expect(component._state).to.equal('preRender');

            // renders the component on the page
            this.render();
            chai.expect(component._state).to.equal('inDOM');

            chai.expect(this.$().prop('tagName')).to.equal('ASIDE');
            chai.expect(this.$().hasClass('gh-notifications')).to.be['true'];
            chai.expect(this.$().children().length).to.equal(2);

            Ember['default'].run(function () {
                component.set('notifications.notifications', Ember['default'].A());
            });

            chai.expect(this.$().children().length).to.equal(0);
        });
    });

});
define('ghost/tests/unit/components/gh-posts-list-item-test', ['chai', 'ember-mocha'], function (chai, ember_mocha) {

    'use strict';

    /* jshint expr:true */
    ember_mocha.describeComponent('gh-posts-list-item', 'GhPostsListItemComponent', {
        // specify the other units that are required for this test
        // needs: ['component:foo', 'helper:bar']
    }, function () {
        ember_mocha.it('renders', function () {
            // creates the component instance
            var component = this.subject();

            chai.expect(component._state).to.equal('preRender');

            // renders the component on the page
            this.render();
            chai.expect(component._state).to.equal('inDOM');
        });
    });

});
define('ghost/tests/unit/components/gh-profile-image-test', ['chai', 'ember-mocha'], function (chai, ember_mocha) {

    'use strict';

    /* jshint expr:true */
    /* global md5 */
    ember_mocha.describeComponent('gh-profile-image', 'GhProfileImageComponent', {
        needs: ['service:ghost-paths']
    }, function () {
        ember_mocha.it('renders', function () {
            // creates the component instance
            var component = this.subject();
            chai.expect(component._state).to.equal('preRender');

            // renders the component on the page
            this.render();
            chai.expect(component._state).to.equal('inDOM');
        });
        ember_mocha.it('renders the gravatar image background if email is supplied', function () {
            var component = this.subject(),
                testEmail = 'test@example.com',
                style,
                size;

            component.set('email', testEmail);
            this.render();

            size = component.get('size');

            style = 'url(http://www.gravatar.com/avatar/' + md5(testEmail) + '?s=' + size + '&d=blank)';

            chai.expect(component.$('#account-image').css('background-image')).to.equal(style);
        });
        ember_mocha.it('doesn\'t render the gravatar image background if email isn\'t supplied', function () {
            var component = this.subject();

            this.render();

            chai.expect(component.$('#account-image').length).to.equal(0);
        });
    });

});
define('ghost/tests/unit/components/gh-search-input-test', ['chai', 'ember-mocha'], function (chai, ember_mocha) {

    'use strict';

    /* jshint expr:true */
    ember_mocha.describeComponent('gh-search-input', 'GhSearchInputComponent', {
        needs: ['component:gh-selectize']
    }, function () {
        ember_mocha.it('renders', function () {
            // creates the component instance
            var component = this.subject();
            chai.expect(component._state).to.equal('preRender');

            // renders the component on the page
            this.render();
            chai.expect(component._state).to.equal('inDOM');
        });
    });

});
define('ghost/tests/unit/components/gh-select-native-test', ['chai', 'ember-mocha'], function (chai, ember_mocha) {

    'use strict';

    /* jshint expr:true */
    ember_mocha.describeComponent('gh-select-native', 'GhSelectNativeComponent', {
        // specify the other units that are required for this test
        // needs: ['component:foo', 'helper:bar']
    }, function () {
        ember_mocha.it('renders', function () {
            // creates the component instance
            var component = this.subject();

            chai.expect(component._state).to.equal('preRender');

            // renders the component on the page
            this.render();
            chai.expect(component._state).to.equal('inDOM');
        });
    });

});
define('ghost/tests/unit/components/gh-spin-button-test', ['chai', 'ember-mocha'], function (chai, ember_mocha) {

    'use strict';

    /* jshint expr:true */
    ember_mocha.describeComponent('gh-spin-button', 'GhSpinButtonComponent', {
        // specify the other units that are required for this test
        // needs: ['component:foo', 'helper:bar']
    }, function () {
        ember_mocha.it('renders', function () {
            // creates the component instance
            var component = this.subject();

            chai.expect(component._state).to.equal('preRender');

            // renders the component on the page
            this.render();
            chai.expect(component._state).to.equal('inDOM');
        });
    });

});
define('ghost/tests/unit/components/gh-trim-focus-input_test', ['ember', 'ember-mocha'], function (Ember, ember_mocha) {

    'use strict';

    ember_mocha.describeComponent('gh-trim-focus-input', function () {
        ember_mocha.it('trims value on focusOut', function () {
            var component = this.subject({
                value: 'some random stuff   '
            });

            this.render();

            component.$().focusout();
            expect(component.$().val()).to.equal('some random stuff');
        });

        ember_mocha.it('does not have the autofocus attribute if not set to focus', function () {
            var component = this.subject({
                value: 'some text',
                focus: false
            });

            this.render();

            expect(component.$().attr('autofocus')).to.not.be.ok;
        });

        ember_mocha.it('has the autofocus attribute if set to focus', function () {
            var component = this.subject({
                value: 'some text',
                focus: true
            });

            this.render();

            expect(component.$().attr('autofocus')).to.be.ok;
        });
    });

});
define('ghost/tests/unit/components/gh-url-preview_test', ['ember-mocha'], function (ember_mocha) {

    'use strict';

    ember_mocha.describeComponent('gh-url-preview', function () {
        ember_mocha.it('generates the correct preview URL with a prefix', function () {
            var component = this.subject({
                prefix: 'tag',
                slug: 'test-slug',
                tagName: 'p',
                classNames: 'test-class',

                config: { blogUrl: 'http://my-ghost-blog.com' }
            });

            this.render();

            expect(component.get('url')).to.equal('my-ghost-blog.com/tag/test-slug/');
        });

        ember_mocha.it('generates the correct preview URL without a prefix', function () {
            var component = this.subject({
                slug: 'test-slug',
                tagName: 'p',
                classNames: 'test-class',

                config: { blogUrl: 'http://my-ghost-blog.com' }
            });

            this.render();

            expect(component.get('url')).to.equal('my-ghost-blog.com/test-slug/');
        });
    });

});
define('ghost/tests/unit/components/gh-user-active-test', ['chai', 'ember-mocha'], function (chai, ember_mocha) {

    'use strict';

    /* jshint expr:true */
    ember_mocha.describeComponent('gh-user-active', 'GhUserActiveComponent', {
        // specify the other units that are required for this test
        // needs: ['component:foo', 'helper:bar']
    }, function () {
        ember_mocha.it('renders', function () {
            // creates the component instance
            var component = this.subject();

            chai.expect(component._state).to.equal('preRender');

            // renders the component on the page
            this.render();
            chai.expect(component._state).to.equal('inDOM');
        });
    });

});
define('ghost/tests/unit/components/gh-user-invited-test', ['chai', 'ember-mocha'], function (chai, ember_mocha) {

    'use strict';

    /* jshint expr:true */
    ember_mocha.describeComponent('gh-user-invited', 'GhUserInvitedComponent', {
        // specify the other units that are required for this test
        // needs: ['component:foo', 'helper:bar']
    }, function () {
        ember_mocha.it('renders', function () {
            // creates the component instance
            var component = this.subject();

            chai.expect(component._state).to.equal('preRender');

            // renders the component on the page
            this.render();
            chai.expect(component._state).to.equal('inDOM');
        });
    });

});
define('ghost/tests/unit/controllers/post-settings-menu_test', ['ember', 'ember-mocha'], function (Ember, ember_mocha) {

    'use strict';

    ember_mocha.describeModule('controller:post-settings-menu', {
        needs: ['controller:application']
    }, function () {
        ember_mocha.it('slugValue is one-way bound to model.slug', function () {
            var controller = this.subject({
                model: Ember['default'].Object.create({
                    slug: 'a-slug'
                })
            });

            expect(controller.get('model.slug')).to.equal('a-slug');
            expect(controller.get('slugValue')).to.equal('a-slug');

            Ember['default'].run(function () {
                controller.set('model.slug', 'changed-slug');

                expect(controller.get('slugValue')).to.equal('changed-slug');
            });

            Ember['default'].run(function () {
                controller.set('slugValue', 'changed-directly');

                expect(controller.get('model.slug')).to.equal('changed-slug');
                expect(controller.get('slugValue')).to.equal('changed-directly');
            });

            Ember['default'].run(function () {
                // test that the one-way binding is still in place
                controller.set('model.slug', 'should-update');

                expect(controller.get('slugValue')).to.equal('should-update');
            });
        });

        ember_mocha.it('metaTitleScratch is one-way bound to model.meta_title', function () {
            var controller = this.subject({
                model: Ember['default'].Object.create({
                    meta_title: 'a title'
                })
            });

            expect(controller.get('model.meta_title')).to.equal('a title');
            expect(controller.get('metaTitleScratch')).to.equal('a title');

            Ember['default'].run(function () {
                controller.set('model.meta_title', 'a different title');

                expect(controller.get('metaTitleScratch')).to.equal('a different title');
            });

            Ember['default'].run(function () {
                controller.set('metaTitleScratch', 'changed directly');

                expect(controller.get('model.meta_title')).to.equal('a different title');
                expect(controller.get('metaTitleScratch')).to.equal('changed directly');
            });

            Ember['default'].run(function () {
                // test that the one-way binding is still in place
                controller.set('model.meta_title', 'should update');

                expect(controller.get('metaTitleScratch')).to.equal('should update');
            });
        });

        ember_mocha.it('metaDescriptionScratch is one-way bound to model.meta_description', function () {
            var controller = this.subject({
                model: Ember['default'].Object.create({
                    meta_description: 'a description'
                })
            });

            expect(controller.get('model.meta_description')).to.equal('a description');
            expect(controller.get('metaDescriptionScratch')).to.equal('a description');

            Ember['default'].run(function () {
                controller.set('model.meta_description', 'a different description');

                expect(controller.get('metaDescriptionScratch')).to.equal('a different description');
            });

            Ember['default'].run(function () {
                controller.set('metaDescriptionScratch', 'changed directly');

                expect(controller.get('model.meta_description')).to.equal('a different description');
                expect(controller.get('metaDescriptionScratch')).to.equal('changed directly');
            });

            Ember['default'].run(function () {
                // test that the one-way binding is still in place
                controller.set('model.meta_description', 'should update');

                expect(controller.get('metaDescriptionScratch')).to.equal('should update');
            });
        });

        describe('seoTitle', function () {
            ember_mocha.it('should be the meta_title if one exists', function () {
                var controller = this.subject({
                    model: Ember['default'].Object.create({
                        meta_title: 'a meta-title',
                        titleScratch: 'should not be used'
                    })
                });

                expect(controller.get('seoTitle')).to.equal('a meta-title');
            });

            ember_mocha.it('should default to the title if an explicit meta-title does not exist', function () {
                var controller = this.subject({
                    model: Ember['default'].Object.create({
                        titleScratch: 'should be the meta-title'
                    })
                });

                expect(controller.get('seoTitle')).to.equal('should be the meta-title');
            });

            ember_mocha.it('should be the meta_title if both title and meta_title exist', function () {
                var controller = this.subject({
                    model: Ember['default'].Object.create({
                        meta_title: 'a meta-title',
                        titleScratch: 'a title'
                    })
                });

                expect(controller.get('seoTitle')).to.equal('a meta-title');
            });

            ember_mocha.it('should revert to the title if explicit meta_title is removed', function () {
                var controller = this.subject({
                    model: Ember['default'].Object.create({
                        meta_title: 'a meta-title',
                        titleScratch: 'a title'
                    })
                });

                expect(controller.get('seoTitle')).to.equal('a meta-title');

                Ember['default'].run(function () {
                    controller.set('model.meta_title', '');

                    expect(controller.get('seoTitle')).to.equal('a title');
                });
            });

            ember_mocha.it('should truncate to 70 characters with an appended ellipsis', function () {
                var longTitle, controller;

                longTitle = new Array(100).join('a');
                expect(longTitle.length).to.equal(99);

                controller = this.subject({
                    model: Ember['default'].Object.create()
                });

                Ember['default'].run(function () {
                    var expected = longTitle.substr(0, 70) + '&hellip;';

                    controller.set('metaTitleScratch', longTitle);

                    expect(controller.get('seoTitle').toString().length).to.equal(78);
                    expect(controller.get('seoTitle').toString()).to.equal(expected);
                });
            });
        });

        describe('seoDescription', function () {
            ember_mocha.it('should be the meta_description if one exists', function () {
                var controller = this.subject({
                    model: Ember['default'].Object.create({
                        meta_description: 'a description'
                    })
                });

                expect(controller.get('seoDescription')).to.equal('a description');
            });

            ember_mocha.it.skip('should be generated from the rendered markdown if not explicitly set', function () {
                // can't test right now because the rendered markdown is being pulled
                // from the DOM via jquery
            });

            ember_mocha.it('should truncate to 156 characters with an appended ellipsis', function () {
                var longDescription, controller;

                longDescription = new Array(200).join('a');
                expect(longDescription.length).to.equal(199);

                controller = this.subject({
                    model: Ember['default'].Object.create()
                });

                Ember['default'].run(function () {
                    var expected = longDescription.substr(0, 156) + '&hellip;';

                    controller.set('metaDescriptionScratch', longDescription);

                    expect(controller.get('seoDescription').toString().length).to.equal(164);
                    expect(controller.get('seoDescription').toString()).to.equal(expected);
                });
            });
        });

        describe('seoURL', function () {
            ember_mocha.it('should be the URL of the blog if no post slug exists', function () {
                var controller = this.subject({
                    config: Ember['default'].Object.create({ blogUrl: 'http://my-ghost-blog.com' }),
                    model: Ember['default'].Object.create()
                });

                expect(controller.get('seoURL')).to.equal('http://my-ghost-blog.com/');
            });

            ember_mocha.it('should be the URL of the blog plus the post slug', function () {
                var controller = this.subject({
                    config: Ember['default'].Object.create({ blogUrl: 'http://my-ghost-blog.com' }),
                    model: Ember['default'].Object.create({ slug: 'post-slug' })
                });

                expect(controller.get('seoURL')).to.equal('http://my-ghost-blog.com/post-slug/');
            });

            ember_mocha.it('should update when the post slug changes', function () {
                var controller = this.subject({
                    config: Ember['default'].Object.create({ blogUrl: 'http://my-ghost-blog.com' }),
                    model: Ember['default'].Object.create({ slug: 'post-slug' })
                });

                expect(controller.get('seoURL')).to.equal('http://my-ghost-blog.com/post-slug/');

                Ember['default'].run(function () {
                    controller.set('model.slug', 'changed-slug');

                    expect(controller.get('seoURL')).to.equal('http://my-ghost-blog.com/changed-slug/');
                });
            });

            ember_mocha.it('should truncate a long URL to 70 characters with an appended ellipsis', function () {
                var longSlug,
                    blogURL = 'http://my-ghost-blog.com',
                    expected,
                    controller;

                longSlug = new Array(75).join('a');
                expect(longSlug.length).to.equal(74);

                controller = this.subject({
                    config: Ember['default'].Object.create({ blogUrl: blogURL }),
                    model: Ember['default'].Object.create({ slug: longSlug })
                });

                expected = blogURL + '/' + longSlug + '/';
                expected = expected.substr(0, 70) + '&hellip;';

                expect(controller.get('seoURL').toString().length).to.equal(78);
                expect(controller.get('seoURL').toString()).to.equal(expected);
            });
        });

        describe('togglePage', function () {
            ember_mocha.it('should toggle the page property', function () {
                var controller = this.subject({
                    model: Ember['default'].Object.create({
                        page: false,
                        isNew: true
                    })
                });

                expect(controller.get('model.page')).to.not.be.ok;

                Ember['default'].run(function () {
                    controller.send('togglePage');

                    expect(controller.get('model.page')).to.be.ok;
                });
            });

            ember_mocha.it('should not save the post if it is still new', function () {
                var controller = this.subject({
                    model: Ember['default'].Object.create({
                        page: false,
                        isNew: true,
                        save: function save() {
                            this.incrementProperty('saved');
                            return Ember['default'].RSVP.resolve();
                        }
                    })
                });

                Ember['default'].run(function () {
                    controller.send('togglePage');

                    expect(controller.get('model.page')).to.be.ok;
                    expect(controller.get('model.saved')).to.not.be.ok;
                });
            });

            ember_mocha.it('should save the post if it is not new', function () {
                var controller = this.subject({
                    model: Ember['default'].Object.create({
                        page: false,
                        isNew: false,
                        save: function save() {
                            this.incrementProperty('saved');
                            return Ember['default'].RSVP.resolve();
                        }
                    })
                });

                Ember['default'].run(function () {
                    controller.send('togglePage');

                    expect(controller.get('model.page')).to.be.ok;
                    expect(controller.get('model.saved')).to.equal(1);
                });
            });
        });

        describe('toggleFeatured', function () {
            ember_mocha.it('should toggle the featured property', function () {
                var controller = this.subject({
                    model: Ember['default'].Object.create({
                        featured: false,
                        isNew: true
                    })
                });

                Ember['default'].run(function () {
                    controller.send('toggleFeatured');

                    expect(controller.get('model.featured')).to.be.ok;
                });
            });

            ember_mocha.it('should not save the post if it is still new', function () {
                var controller = this.subject({
                    model: Ember['default'].Object.create({
                        featured: false,
                        isNew: true,
                        save: function save() {
                            this.incrementProperty('saved');
                            return Ember['default'].RSVP.resolve();
                        }
                    })
                });

                Ember['default'].run(function () {
                    controller.send('toggleFeatured');

                    expect(controller.get('model.featured')).to.be.ok;
                    expect(controller.get('model.saved')).to.not.be.ok;
                });
            });

            ember_mocha.it('should save the post if it is not new', function () {
                var controller = this.subject({
                    model: Ember['default'].Object.create({
                        featured: false,
                        isNew: false,
                        save: function save() {
                            this.incrementProperty('saved');
                            return Ember['default'].RSVP.resolve();
                        }
                    })
                });

                Ember['default'].run(function () {
                    controller.send('toggleFeatured');

                    expect(controller.get('model.featured')).to.be.ok;
                    expect(controller.get('model.saved')).to.equal(1);
                });
            });
        });

        describe('generateAndSetSlug', function () {
            ember_mocha.it('should generate a slug and set it on the destination', function (done) {
                var controller = this.subject({
                    slugGenerator: Ember['default'].Object.create({
                        generateSlug: function generateSlug(str) {
                            return Ember['default'].RSVP.resolve(str + '-slug');
                        }
                    }),
                    model: Ember['default'].Object.create({ slug: '' })
                });

                Ember['default'].run(function () {
                    controller.set('model.titleScratch', 'title');
                    controller.generateAndSetSlug('model.slug');

                    expect(controller.get('model.slug')).to.equal('');

                    Ember['default'].RSVP.resolve(controller.get('lastPromise')).then(function () {
                        expect(controller.get('model.slug')).to.equal('title-slug');

                        done();
                    })['catch'](done);
                });
            });

            ember_mocha.it('should not set the destination if the title is "(Untitled)" and the post already has a slug', function (done) {
                var controller = this.subject({
                    slugGenerator: Ember['default'].Object.create({
                        generateSlug: function generateSlug(str) {
                            return Ember['default'].RSVP.resolve(str + '-slug');
                        }
                    }),
                    model: Ember['default'].Object.create({
                        slug: 'whatever'
                    })
                });

                expect(controller.get('model.slug')).to.equal('whatever');

                Ember['default'].run(function () {
                    controller.set('model.titleScratch', 'title');

                    Ember['default'].RSVP.resolve(controller.get('lastPromise')).then(function () {
                        expect(controller.get('model.slug')).to.equal('whatever');

                        done();
                    })['catch'](done);
                });
            });
        });

        describe('titleObserver', function () {
            ember_mocha.it('should invoke generateAndSetSlug if the post is new and a title has not been set', function (done) {
                var controller = this.subject({
                    model: Ember['default'].Object.create({ isNew: true }),
                    invoked: 0,
                    generateAndSetSlug: function generateAndSetSlug() {
                        this.incrementProperty('invoked');
                    }
                });

                expect(controller.get('invoked')).to.equal(0);
                expect(controller.get('model.title')).to.not.be.ok;

                Ember['default'].run(function () {
                    controller.set('model.titleScratch', 'test');

                    controller.titleObserver();

                    // since titleObserver invokes generateAndSetSlug with a delay of 700ms
                    // we need to make sure this assertion runs after that.
                    // probably a better way to handle this?
                    Ember['default'].run.later(function () {
                        expect(controller.get('invoked')).to.equal(1);

                        done();
                    }, 800);
                });
            });

            ember_mocha.it('should invoke generateAndSetSlug if the post title is "(Untitled)"', function (done) {
                var controller = this.subject({
                    model: Ember['default'].Object.create({
                        isNew: false,
                        title: '(Untitled)'
                    }),
                    invoked: 0,
                    generateAndSetSlug: function generateAndSetSlug() {
                        this.incrementProperty('invoked');
                    }
                });

                expect(controller.get('invoked')).to.equal(0);
                expect(controller.get('model.title')).to.equal('(Untitled)');

                Ember['default'].run(function () {
                    controller.set('model.titleScratch', 'test');

                    controller.titleObserver();

                    // since titleObserver invokes generateAndSetSlug with a delay of 700ms
                    // we need to make sure this assertion runs after that.
                    // probably a better way to handle this?
                    Ember['default'].run.later(function () {
                        expect(controller.get('invoked')).to.equal(1);

                        done();
                    }, 800);
                });
            });

            ember_mocha.it('should not invoke generateAndSetSlug if the post is new but has a title', function (done) {
                var controller = this.subject({
                    model: Ember['default'].Object.create({
                        isNew: true,
                        title: 'a title'
                    }),
                    invoked: 0,
                    generateAndSetSlug: function generateAndSetSlug() {
                        this.incrementProperty('invoked');
                    }
                });

                expect(controller.get('invoked')).to.equal(0);
                expect(controller.get('model.title')).to.equal('a title');

                Ember['default'].run(function () {
                    controller.set('model.titleScratch', 'test');

                    controller.titleObserver();

                    // since titleObserver invokes generateAndSetSlug with a delay of 700ms
                    // we need to make sure this assertion runs after that.
                    // probably a better way to handle this?
                    Ember['default'].run.later(function () {
                        expect(controller.get('invoked')).to.equal(0);

                        done();
                    }, 800);
                });
            });
        });

        describe('updateSlug', function () {
            ember_mocha.it('should reset slugValue to the previous slug when the new slug is blank or unchanged', function () {
                var controller = this.subject({
                    model: Ember['default'].Object.create({
                        slug: 'slug'
                    })
                });

                Ember['default'].run(function () {
                    // unchanged
                    controller.set('slugValue', 'slug');
                    controller.send('updateSlug', controller.get('slugValue'));

                    expect(controller.get('model.slug')).to.equal('slug');
                    expect(controller.get('slugValue')).to.equal('slug');
                });

                Ember['default'].run(function () {
                    // unchanged after trim
                    controller.set('slugValue', 'slug  ');
                    controller.send('updateSlug', controller.get('slugValue'));

                    expect(controller.get('model.slug')).to.equal('slug');
                    expect(controller.get('slugValue')).to.equal('slug');
                });

                Ember['default'].run(function () {
                    // blank
                    controller.set('slugValue', '');
                    controller.send('updateSlug', controller.get('slugValue'));

                    expect(controller.get('model.slug')).to.equal('slug');
                    expect(controller.get('slugValue')).to.equal('slug');
                });
            });

            ember_mocha.it('should not set a new slug if the server-generated slug matches existing slug', function (done) {
                var controller = this.subject({
                    slugGenerator: Ember['default'].Object.create({
                        generateSlug: function generateSlug(str) {
                            var promise;
                            promise = Ember['default'].RSVP.resolve(str.split('#')[0]);
                            this.set('lastPromise', promise);
                            return promise;
                        }
                    }),
                    model: Ember['default'].Object.create({
                        slug: 'whatever'
                    })
                });

                Ember['default'].run(function () {
                    controller.set('slugValue', 'whatever#slug');
                    controller.send('updateSlug', controller.get('slugValue'));

                    Ember['default'].RSVP.resolve(controller.get('lastPromise')).then(function () {
                        expect(controller.get('model.slug')).to.equal('whatever');

                        done();
                    })['catch'](done);
                });
            });

            ember_mocha.it('should not set a new slug if the only change is to the appended increment value', function (done) {
                var controller = this.subject({
                    slugGenerator: Ember['default'].Object.create({
                        generateSlug: function generateSlug(str) {
                            var promise;
                            promise = Ember['default'].RSVP.resolve(str.replace(/[^a-zA-Z]/g, '') + '-2');
                            this.set('lastPromise', promise);
                            return promise;
                        }
                    }),
                    model: Ember['default'].Object.create({
                        slug: 'whatever'
                    })
                });

                Ember['default'].run(function () {
                    controller.set('slugValue', 'whatever!');
                    controller.send('updateSlug', controller.get('slugValue'));

                    Ember['default'].RSVP.resolve(controller.get('lastPromise')).then(function () {
                        expect(controller.get('model.slug')).to.equal('whatever');

                        done();
                    })['catch'](done);
                });
            });

            ember_mocha.it('should set the slug if the new slug is different', function (done) {
                var controller = this.subject({
                    slugGenerator: Ember['default'].Object.create({
                        generateSlug: function generateSlug(str) {
                            var promise;
                            promise = Ember['default'].RSVP.resolve(str);
                            this.set('lastPromise', promise);
                            return promise;
                        }
                    }),
                    model: Ember['default'].Object.create({
                        slug: 'whatever',
                        save: Ember['default'].K
                    })
                });

                Ember['default'].run(function () {
                    controller.set('slugValue', 'changed');
                    controller.send('updateSlug', controller.get('slugValue'));

                    Ember['default'].RSVP.resolve(controller.get('lastPromise')).then(function () {
                        expect(controller.get('model.slug')).to.equal('changed');

                        done();
                    })['catch'](done);
                });
            });

            ember_mocha.it('should save the post when the slug changes and the post is not new', function (done) {
                var controller = this.subject({
                    slugGenerator: Ember['default'].Object.create({
                        generateSlug: function generateSlug(str) {
                            var promise;
                            promise = Ember['default'].RSVP.resolve(str);
                            this.set('lastPromise', promise);
                            return promise;
                        }
                    }),
                    model: Ember['default'].Object.create({
                        slug: 'whatever',
                        saved: 0,
                        isNew: false,
                        save: function save() {
                            this.incrementProperty('saved');
                        }
                    })
                });

                Ember['default'].run(function () {
                    controller.set('slugValue', 'changed');
                    controller.send('updateSlug', controller.get('slugValue'));

                    Ember['default'].RSVP.resolve(controller.get('lastPromise')).then(function () {
                        expect(controller.get('model.slug')).to.equal('changed');
                        expect(controller.get('model.saved')).to.equal(1);

                        done();
                    })['catch'](done);
                });
            });

            ember_mocha.it('should not save the post when the slug changes and the post is new', function (done) {
                var controller = this.subject({
                    slugGenerator: Ember['default'].Object.create({
                        generateSlug: function generateSlug(str) {
                            var promise;
                            promise = Ember['default'].RSVP.resolve(str);
                            this.set('lastPromise', promise);
                            return promise;
                        }
                    }),
                    model: Ember['default'].Object.create({
                        slug: 'whatever',
                        saved: 0,
                        isNew: true,
                        save: function save() {
                            this.incrementProperty('saved');
                        }
                    })
                });

                Ember['default'].run(function () {
                    controller.set('slugValue', 'changed');
                    controller.send('updateSlug', controller.get('slugValue'));

                    Ember['default'].RSVP.resolve(controller.get('lastPromise')).then(function () {
                        expect(controller.get('model.slug')).to.equal('changed');
                        expect(controller.get('model.saved')).to.equal(0);

                        done();
                    })['catch'](done);
                });
            });
        });
    });

});
define('ghost/tests/unit/controllers/settings-general_test', ['ember', 'ember-mocha'], function (Ember, ember_mocha) {

    'use strict';

    ember_mocha.describeModule('controller:settings/general', function () {
        ember_mocha.it('isDatedPermalinks should be correct', function () {
            var controller = this.subject({
                model: Ember['default'].Object.create({
                    permalinks: '/:year/:month/:day/:slug/'
                })
            });

            expect(controller.get('isDatedPermalinks')).to.be.ok;

            Ember['default'].run(function () {
                controller.set('model.permalinks', '/:slug/');

                expect(controller.get('isDatedPermalinks')).to.not.be.ok;
            });
        });

        ember_mocha.it('setting isDatedPermalinks should switch between dated and slug', function () {
            var controller = this.subject({
                model: Ember['default'].Object.create({
                    permalinks: '/:year/:month/:day/:slug/'
                })
            });

            Ember['default'].run(function () {
                controller.set('isDatedPermalinks', false);

                expect(controller.get('isDatedPermalinks')).to.not.be.ok;
                expect(controller.get('model.permalinks')).to.equal('/:slug/');
            });

            Ember['default'].run(function () {
                controller.set('isDatedPermalinks', true);

                expect(controller.get('isDatedPermalinks')).to.be.ok;
                expect(controller.get('model.permalinks')).to.equal('/:year/:month/:day/:slug/');
            });
        });

        ember_mocha.it('themes should be correct', function () {
            var controller,
                themes = [];

            themes.push({
                name: 'casper',
                active: true,
                'package': {
                    name: 'Casper',
                    version: '1.1.5'
                }
            });

            themes.push({
                name: 'rasper',
                'package': {
                    name: 'Rasper',
                    version: '1.0.0'
                }
            });

            controller = this.subject({
                model: Ember['default'].Object.create({
                    availableThemes: themes
                })
            });

            themes = controller.get('themes');
            expect(themes).to.be.an.Array;
            expect(themes.length).to.equal(2);
            expect(themes.objectAt(0).name).to.equal('casper');
            expect(themes.objectAt(0).active).to.be.ok;
            expect(themes.objectAt(0).label).to.equal('Casper - 1.1.5');
            expect(themes.objectAt(1).name).to.equal('rasper');
            expect(themes.objectAt(1).active).to.not.be.ok;
            expect(themes.objectAt(1).label).to.equal('Rasper - 1.0.0');
        });
    });

});
define('ghost/tests/unit/helpers/gh-user-can-admin-test', ['ember-mocha', 'ghost/helpers/gh-user-can-admin'], function (ember_mocha, gh_user_can_admin) {

    'use strict';

    describe('GhUserCanAdminHelper', function () {
        // Mock up roles and test for truthy
        describe('Owner role', function () {
            var user = { get: function get(role) {
                    if (role === 'isOwner') {
                        return true;
                    } else if (role === 'isAdmin') {
                        return false;
                    }
                }
            };
            ember_mocha.it(' - can be Admin', function () {
                var result = gh_user_can_admin.ghUserCanAdmin([user]);
                expect(result).to.equal(true);
            });
        });

        describe('Administrator role', function () {
            var user = {
                get: function get(role) {
                    if (role === 'isOwner') {
                        return false;
                    } else if (role === 'isAdmin') {
                        return true;
                    }
                }
            };
            ember_mocha.it(' - can be Admin', function () {
                var result = gh_user_can_admin.ghUserCanAdmin([user]);
                expect(result).to.equal(true);
            });
        });

        describe('Editor and Author roles', function () {
            var user = {
                get: function get(role) {
                    if (role === 'isOwner') {
                        return false;
                    } else if (role === 'isAdmin') {
                        return false;
                    }
                }
            };
            ember_mocha.it(' - cannot be Admin', function () {
                var result = gh_user_can_admin.ghUserCanAdmin([user]);
                expect(result).to.equal(false);
            });
        });
    });

});
define('ghost/tests/unit/helpers/is-equal-test', ['chai', 'mocha', 'ghost/helpers/is-equal'], function (chai, mocha, is_equal) {

    'use strict';

    /* jshint expr:true */
    mocha.describe('IsEqualHelper', function () {
        // Replace this with your real tests.
        mocha.it('works', function () {
            var result = is_equal.isEqual([42, 42]);

            chai.expect(result).to.be.ok;
        });
    });

});
define('ghost/tests/unit/helpers/is-not-test', ['chai', 'mocha', 'ghost/helpers/is-not'], function (chai, mocha, is_not) {

    'use strict';

    /* jshint expr:true */
    mocha.describe('IsNotHelper', function () {
        // Replace this with your real tests.
        mocha.it('works', function () {
            var result = is_not.isNot(false);

            chai.expect(result).to.be.ok;
        });
    });

});
define('ghost/tests/unit/helpers/read-path-test', ['chai', 'mocha', 'ghost/helpers/read-path', 'ember'], function (chai, mocha, read_path, Ember) {

    'use strict';

    /* jshint expr:true */
    mocha.describe('ReadPathHelper', function () {
        // Replace this with your real tests.
        mocha.it('works', function () {
            var result = read_path.readPath([Ember['default'].Object.create({ hi: 'there' }), 'hi']);

            chai.expect(result).to.equal('there');
        });
    });

});
define('ghost/tests/unit/mixins/infinite-scroll-test', ['chai', 'mocha', 'ember', 'ghost/mixins/infinite-scroll'], function (chai, mocha, Ember, InfiniteScrollMixin) {

    'use strict';

    /* jshint expr:true */
    mocha.describe('InfiniteScrollMixin', function () {
        // Replace this with your real tests.
        mocha.it('works', function () {
            var InfiniteScrollObject = Ember['default'].Object.extend(InfiniteScrollMixin['default']),
                subject = InfiniteScrollObject.create();

            chai.expect(subject).to.be.ok;
        });
    });

});
define('ghost/tests/unit/models/post_test', ['ember', 'ember-mocha'], function (Ember, ember_mocha) {

    'use strict';

    ember_mocha.describeModel('post', {
        needs: ['model:user', 'model:tag', 'model:role']
    }, function () {
        ember_mocha.it('has a validation type of "post"', function () {
            var model = this.subject();

            expect(model.validationType).to.equal('post');
        });

        ember_mocha.it('isPublished and isDraft are correct', function () {
            var model = this.subject({
                status: 'published'
            });

            expect(model.get('isPublished')).to.be.ok;
            expect(model.get('isDraft')).to.not.be.ok;

            Ember['default'].run(function () {
                model.set('status', 'draft');

                expect(model.get('isPublished')).to.not.be.ok;
                expect(model.get('isDraft')).to.be.ok;
            });
        });

        ember_mocha.it('isAuthoredByUser is correct', function () {
            var model = this.subject({
                author_id: 15
            }),
                user = Ember['default'].Object.create({ id: '15' });

            expect(model.isAuthoredByUser(user)).to.be.ok;

            Ember['default'].run(function () {
                model.set('author_id', 1);

                expect(model.isAuthoredByUser(user)).to.not.be.ok;
            });
        });

        ember_mocha.it('updateTags removes and deletes old tags', function () {
            var model = this.subject();

            Ember['default'].run(this, function () {
                var modelTags = model.get('tags'),
                    tag1 = this.store().createRecord('tag', { id: '1' }),
                    tag2 = this.store().createRecord('tag', { id: '2' }),
                    tag3 = this.store().createRecord('tag');

                // During testing a record created without an explicit id will get
                // an id of 'fixture-n' instead of null
                tag3.set('id', null);

                modelTags.pushObject(tag1);
                modelTags.pushObject(tag2);
                modelTags.pushObject(tag3);

                expect(model.get('tags.length')).to.equal(3);

                model.updateTags();

                expect(model.get('tags.length')).to.equal(2);
                expect(model.get('tags.firstObject.id')).to.equal('1');
                expect(model.get('tags').objectAt(1).get('id')).to.equal('2');
                expect(tag1.get('isDeleted')).to.not.be.ok;
                expect(tag2.get('isDeleted')).to.not.be.ok;
                expect(tag3.get('isDeleted')).to.be.ok;
            });
        });
    });

});
define('ghost/tests/unit/models/role_test', ['ember', 'ember-mocha'], function (Ember, ember_mocha) {

    'use strict';

    ember_mocha.describeModel('role', function () {
        ember_mocha.it('provides a lowercase version of the name', function () {
            var model = this.subject({
                name: 'Author'
            });

            expect(model.get('name')).to.equal('Author');
            expect(model.get('lowerCaseName')).to.equal('author');

            Ember['default'].run(function () {
                model.set('name', 'Editor');

                expect(model.get('name')).to.equal('Editor');
                expect(model.get('lowerCaseName')).to.equal('editor');
            });
        });
    });

});
define('ghost/tests/unit/models/setting_test', ['ember-mocha'], function (ember_mocha) {

    'use strict';

    ember_mocha.describeModel('setting', function () {
        ember_mocha.it('has a validation type of "setting"', function () {
            var model = this.subject();

            expect(model.get('validationType')).to.equal('setting');
        });
    });

});
define('ghost/tests/unit/models/tag_test', ['ember-mocha'], function (ember_mocha) {

    'use strict';

    ember_mocha.describeModel('tag', function () {
        ember_mocha.it('has a validation type of "tag"', function () {
            var model = this.subject();

            expect(model.get('validationType')).to.equal('tag');
        });
    });

});
define('ghost/tests/unit/models/user_test', ['ember', 'ember-mocha'], function (Ember, ember_mocha) {

    'use strict';

    ember_mocha.describeModel('user', {
        needs: ['model:role']
    }, function () {
        ember_mocha.it('has a validation type of "user"', function () {
            var model = this.subject();

            expect(model.get('validationType')).to.equal('user');
        });

        ember_mocha.it('active property is correct', function () {
            var model = this.subject({
                status: 'active'
            });

            expect(model.get('active')).to.be.ok;

            ['warn-1', 'warn-2', 'warn-3', 'warn-4', 'locked'].forEach(function (status) {
                Ember['default'].run(function () {
                    model.set('status', status);

                    expect(model.get('status')).to.be.ok;
                });
            });

            Ember['default'].run(function () {
                model.set('status', 'inactive');

                expect(model.get('active')).to.not.be.ok;
            });

            Ember['default'].run(function () {
                model.set('status', 'invited');

                expect(model.get('active')).to.not.be.ok;
            });
        });

        ember_mocha.it('invited property is correct', function () {
            var model = this.subject({
                status: 'invited'
            });

            expect(model.get('invited')).to.be.ok;

            Ember['default'].run(function () {
                model.set('status', 'invited-pending');

                expect(model.get('invited')).to.be.ok;
            });

            Ember['default'].run(function () {
                model.set('status', 'active');

                expect(model.get('invited')).to.not.be.ok;
            });

            Ember['default'].run(function () {
                model.set('status', 'inactive');

                expect(model.get('invited')).to.not.be.ok;
            });
        });

        ember_mocha.it('pending property is correct', function () {
            var model = this.subject({
                status: 'invited-pending'
            });

            expect(model.get('pending')).to.be.ok;

            Ember['default'].run(function () {
                model.set('status', 'invited');

                expect(model.get('pending')).to.not.be.ok;
            });

            Ember['default'].run(function () {
                model.set('status', 'inactive');

                expect(model.get('pending')).to.not.be.ok;
            });
        });

        ember_mocha.it('role property is correct', function () {
            var model, role;

            model = this.subject();

            Ember['default'].run(this, function () {
                role = this.store().createRecord('role', { name: 'Author' });

                model.get('roles').pushObject(role);

                expect(model.get('role.name')).to.equal('Author');
            });

            Ember['default'].run(this, function () {
                role = this.store().createRecord('role', { name: 'Editor' });

                model.set('role', role);

                expect(model.get('role.name')).to.equal('Editor');
            });
        });

        ember_mocha.it('isAuthor property is correct', function () {
            var model = this.subject();

            Ember['default'].run(this, function () {
                var role = this.store().createRecord('role', { name: 'Author' });

                model.set('role', role);

                expect(model.get('isAuthor')).to.be.ok;
                expect(model.get('isEditor')).to.not.be.ok;
                expect(model.get('isAdmin')).to.not.be.ok;
                expect(model.get('isOwner')).to.not.be.ok;
            });
        });

        ember_mocha.it('isEditor property is correct', function () {
            var model = this.subject();

            Ember['default'].run(this, function () {
                var role = this.store().createRecord('role', { name: 'Editor' });

                model.set('role', role);

                expect(model.get('isEditor')).to.be.ok;
                expect(model.get('isAuthor')).to.not.be.ok;
                expect(model.get('isAdmin')).to.not.be.ok;
                expect(model.get('isOwner')).to.not.be.ok;
            });
        });

        ember_mocha.it('isAdmin property is correct', function () {
            var model = this.subject();

            Ember['default'].run(this, function () {
                var role = this.store().createRecord('role', { name: 'Administrator' });

                model.set('role', role);

                expect(model.get('isAdmin')).to.be.ok;
                expect(model.get('isAuthor')).to.not.be.ok;
                expect(model.get('isEditor')).to.not.be.ok;
                expect(model.get('isOwner')).to.not.be.ok;
            });
        });

        ember_mocha.it('isOwner property is correct', function () {
            var model = this.subject();

            Ember['default'].run(this, function () {
                var role = this.store().createRecord('role', { name: 'Owner' });

                model.set('role', role);

                expect(model.get('isOwner')).to.be.ok;
                expect(model.get('isAuthor')).to.not.be.ok;
                expect(model.get('isAdmin')).to.not.be.ok;
                expect(model.get('isEditor')).to.not.be.ok;
            });
        });
    });

});
define('ghost/tests/unit/services/notifications-test', ['ember', 'sinon', 'chai', 'ember-mocha'], function (Ember, sinon, chai, ember_mocha) {

    'use strict';

    /* jshint expr:true */
    ember_mocha.describeModule('service:notifications', 'NotificationsService', {
        // Specify the other units that are required for this test.
        // needs: ['model:notification']
    }, function () {
        beforeEach(function () {
            this.subject().set('content', Ember['default'].A());
            this.subject().set('delayedNotifications', Ember['default'].A());
        });

        ember_mocha.it('filters alerts/notifications', function () {
            var notifications = this.subject();

            notifications.set('content', [{ message: 'Alert', status: 'alert' }, { message: 'Notification', status: 'notification' }]);

            chai.expect(notifications.get('alerts')).to.deep.equal([{ message: 'Alert', status: 'alert' }]);

            chai.expect(notifications.get('notifications')).to.deep.equal([{ message: 'Notification', status: 'notification' }]);
        });

        ember_mocha.it('#handleNotification deals with DS.Notification notifications', function () {
            var notifications = this.subject(),
                notification = Ember['default'].Object.create({ message: '<h1>Test</h1>', status: 'alert' });

            notification.toJSON = function () {};

            notifications.handleNotification(notification);

            notification = notifications.get('alerts')[0];

            // alerts received from the server should be marked html safe
            chai.expect(notification.get('message')).to.have.property('toHTML');
        });

        ember_mocha.it('#handleNotification defaults to notification if no status supplied', function () {
            var notifications = this.subject();

            notifications.handleNotification({ message: 'Test' }, false);

            chai.expect(notifications.get('content')).to.deep.include({ message: 'Test', status: 'notification' });
        });

        ember_mocha.it('#showAlert adds POJO alerts', function () {
            var notifications = this.subject();

            notifications.showAlert('Test Alert', { type: 'error' });

            chai.expect(notifications.get('alerts')).to.deep.include({ message: 'Test Alert', status: 'alert', type: 'error' });
        });

        ember_mocha.it('#showAlert adds delayed notifications', function () {
            var notifications = this.subject();

            notifications.showNotification('Test Alert', { type: 'error', delayed: true });

            chai.expect(notifications.get('delayedNotifications')).to.deep.include({ message: 'Test Alert', status: 'notification', type: 'error' });
        });

        ember_mocha.it('#showNotification adds POJO notifications', function () {
            var notifications = this.subject();

            notifications.showNotification('Test Notification', { type: 'success' });

            chai.expect(notifications.get('notifications')).to.deep.include({ message: 'Test Notification', status: 'notification', type: 'success' });
        });

        ember_mocha.it('#showNotification adds delayed notifications', function () {
            var notifications = this.subject();

            notifications.showNotification('Test Notification', { delayed: true });

            chai.expect(notifications.get('delayedNotifications')).to.deep.include({ message: 'Test Notification', status: 'notification', type: undefined });
        });

        ember_mocha.it('#showNotification clears existing notifications', function () {
            var notifications = this.subject();

            notifications.showNotification('First');
            notifications.showNotification('Second');

            chai.expect(notifications.get('content.length')).to.equal(1);
            chai.expect(notifications.get('content')).to.deep.equal([{ message: 'Second', status: 'notification', type: undefined }]);
        });

        ember_mocha.it('#showNotification keeps existing notifications if doNotCloseNotifications option passed', function () {
            var notifications = this.subject();

            notifications.showNotification('First');
            notifications.showNotification('Second', { doNotCloseNotifications: true });

            chai.expect(notifications.get('content.length')).to.equal(2);
        });

        // TODO: review whether this can be removed once it's no longer used by validations
        ember_mocha.it('#showErrors adds multiple notifications', function () {
            var notifications = this.subject();

            notifications.showErrors([{ message: 'First' }, { message: 'Second' }]);

            chai.expect(notifications.get('content')).to.deep.equal([{ message: 'First', status: 'notification', type: 'error' }, { message: 'Second', status: 'notification', type: 'error' }]);
        });

        ember_mocha.it('#showAPIError adds single json response error', function () {
            var notifications = this.subject(),
                resp = { jqXHR: { responseJSON: { error: 'Single error' } } };

            notifications.showAPIError(resp);

            chai.expect(notifications.get('content')).to.deep.equal([{ message: 'Single error', status: 'alert', type: 'error' }]);
        });

        // used to display validation errors returned from the server
        ember_mocha.it('#showAPIError adds multiple json response errors', function () {
            var notifications = this.subject(),
                resp = { jqXHR: { responseJSON: { errors: ['First error', 'Second error'] } } };

            notifications.showAPIError(resp);

            chai.expect(notifications.get('content')).to.deep.equal([{ message: 'First error', status: 'notification', type: 'error' }, { message: 'Second error', status: 'notification', type: 'error' }]);
        });

        ember_mocha.it('#showAPIError adds single json response message', function () {
            var notifications = this.subject(),
                resp = { jqXHR: { responseJSON: { message: 'Single message' } } };

            notifications.showAPIError(resp);

            chai.expect(notifications.get('content')).to.deep.equal([{ message: 'Single message', status: 'alert', type: 'error' }]);
        });

        ember_mocha.it('#showAPIError displays default error text if response has no error/message', function () {
            var notifications = this.subject(),
                resp = {};

            notifications.showAPIError(resp);
            chai.expect(notifications.get('content')).to.deep.equal([{ message: 'There was a problem on the server, please try again.', status: 'alert', type: 'error' }]);

            notifications.set('content', Ember['default'].A());

            notifications.showAPIError(resp, { defaultErrorText: 'Overridden default' });
            chai.expect(notifications.get('content')).to.deep.equal([{ message: 'Overridden default', status: 'alert', type: 'error' }]);
        });

        ember_mocha.it('#displayDelayed moves delayed notifications into content', function () {
            var notifications = this.subject();

            notifications.showNotification('First', { delayed: true });
            notifications.showNotification('Second', { delayed: true });
            notifications.showNotification('Third', { delayed: false });

            notifications.displayDelayed();

            chai.expect(notifications.get('content')).to.deep.equal([{ message: 'Third', status: 'notification', type: undefined }, { message: 'First', status: 'notification', type: undefined }, { message: 'Second', status: 'notification', type: undefined }]);
        });

        ember_mocha.it('#closeNotification removes POJO notifications', function () {
            var notification = { message: 'Close test', status: 'notification' },
                notifications = this.subject();

            notifications.handleNotification(notification);

            chai.expect(notifications.get('notifications')).to.include(notification);

            notifications.closeNotification(notification);

            chai.expect(notifications.get('notifications')).to.not.include(notification);
        });

        ember_mocha.it('#closeNotification removes and deletes DS.Notification records', function () {
            var notification = Ember['default'].Object.create({ message: 'Close test', status: 'alert' }),
                notifications = this.subject();

            notification.toJSON = function () {};
            notification.deleteRecord = function () {};
            sinon['default'].spy(notification, 'deleteRecord');
            notification.save = function () {
                return {
                    'finally': function _finally(callback) {
                        return callback(notification);
                    }
                };
            };
            sinon['default'].spy(notification, 'save');

            notifications.handleNotification(notification);
            chai.expect(notifications.get('alerts')).to.include(notification);

            notifications.closeNotification(notification);

            chai.expect(notification.deleteRecord.calledOnce).to.be['true'];
            chai.expect(notification.save.calledOnce).to.be['true'];

            // wrap in runloop so filter updates
            Ember['default'].run.next(function () {
                chai.expect(notifications.get('alerts')).to.not.include(notification);
            });
        });

        ember_mocha.it('#closeNotifications only removes notifications', function () {
            var notifications = this.subject();

            notifications.showAlert('First alert');
            notifications.showNotification('First notification');
            notifications.showNotification('Second notification', { doNotCloseNotifications: true });

            chai.expect(notifications.get('alerts.length')).to.equal(1);
            chai.expect(notifications.get('notifications.length')).to.equal(2);

            notifications.closeNotifications();

            // wrap in runloop so filter updates
            Ember['default'].run.next(function () {
                chai.expect(notifications.get('alerts.length')).to.equal(1);
                chai.expect(notifications.get('notifications.length')).to.equal(1);
            });
        });

        ember_mocha.it('#closeAll removes everything without deletion', function () {
            var notifications = this.subject(),
                notificationModel = Ember['default'].Object.create({ message: 'model' });

            notificationModel.toJSON = function () {};
            notificationModel.deleteRecord = function () {};
            sinon['default'].spy(notificationModel, 'deleteRecord');
            notificationModel.save = function () {
                return {
                    'finally': function _finally(callback) {
                        return callback(notificationModel);
                    }
                };
            };
            sinon['default'].spy(notificationModel, 'save');

            notifications.handleNotification(notificationModel);
            notifications.handleNotification({ message: 'pojo' });

            notifications.closeAll();

            chai.expect(notifications.get('content')).to.be.empty;
            chai.expect(notificationModel.deleteRecord.called).to.be['false'];
            chai.expect(notificationModel.save.called).to.be['false'];
        });
    });

});
define('ghost/tests/unit/utils/ghost-paths_test', ['ghost/utils/ghost-paths'], function (ghostPaths) {

    'use strict';

    describe('ghost-paths', function () {
        describe('join', function () {
            var join = ghostPaths['default']().url.join;

            it('should join two or more paths, normalizing slashes', function () {
                var path;

                path = join('/one/', '/two/');
                expect(path).to.equal('/one/two/');

                path = join('/one', '/two/');
                expect(path).to.equal('/one/two/');

                path = join('/one/', 'two/');
                expect(path).to.equal('/one/two/');

                path = join('/one/', 'two/', '/three/');
                expect(path).to.equal('/one/two/three/');

                path = join('/one/', 'two', 'three/');
                expect(path).to.equal('/one/two/three/');
            });

            it('should not change the slash at the beginning', function () {
                var path;

                path = join('one/');
                expect(path).to.equal('one/');
                path = join('one/', 'two');
                expect(path).to.equal('one/two/');
                path = join('/one/', 'two');
                expect(path).to.equal('/one/two/');
                path = join('one/', 'two', 'three');
                expect(path).to.equal('one/two/three/');
                path = join('/one/', 'two', 'three');
                expect(path).to.equal('/one/two/three/');
            });

            it('should always return a slash at the end', function () {
                var path;

                path = join();
                expect(path).to.equal('/');
                path = join('');
                expect(path).to.equal('/');
                path = join('one');
                expect(path).to.equal('one/');
                path = join('one/');
                expect(path).to.equal('one/');
                path = join('one', 'two');
                expect(path).to.equal('one/two/');
                path = join('one', 'two/');
                expect(path).to.equal('one/two/');
            });
        });
    });

});
define('ghost/transforms/moment-date', ['exports', 'ember-data'], function (exports, DS) {

    'use strict';

    var MomentDate = DS['default'].Transform.extend({
        deserialize: function deserialize(serialized) {
            if (serialized) {
                return moment(serialized);
            }
            return serialized;
        },
        serialize: function serialize(deserialized) {
            if (deserialized) {
                return moment(deserialized).toDate();
            }
            return deserialized;
        }
    });
    exports['default'] = MomentDate;

});
define('ghost/utils/ajax', ['exports', 'ember'], function (exports, Ember) {

    'use strict';


    exports['default'] = getRequestErrorMessage;
    function getRequestErrorMessage(request, performConcat) {
        var message, msgDetail;

        // Can't really continue without a request
        if (!request) {
            return null;
        }

        // Seems like a sensible default
        message = request.statusText;

        // If a non 200 response
        if (request.status !== 200) {
            try {
                // Try to parse out the error, or default to 'Unknown'
                if (request.responseJSON.errors && Ember['default'].isArray(request.responseJSON.errors)) {
                    message = request.responseJSON.errors.map(function (errorItem) {
                        return errorItem.message;
                    });
                } else {
                    message = request.responseJSON.error || 'Unknown Error';
                }
            } catch (e) {
                msgDetail = request.status ? request.status + ' - ' + request.statusText : 'Server was not available';
                message = 'The server returned an error (' + msgDetail + ').';
            }
        }

        if (performConcat && Ember['default'].isArray(message)) {
            message = message.join('<br />');
        }

        // return an array of errors by default
        if (!performConcat && typeof message === 'string') {
            message = [message];
        }

        return message;
    }

});
define('ghost/utils/bind', ['exports'], function (exports) {

    'use strict';

    var slice = Array.prototype.slice;

    function bind() /* func, args, thisArg */{
        var args = slice.call(arguments),
            func = args.shift(),
            thisArg = args.pop();

        function bound() {
            return func.apply(thisArg, args);
        }

        return bound;
    }

    exports['default'] = bind;

});
define('ghost/utils/bound-one-way', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    var BoundOneWay = function BoundOneWay(upstream, transform) {
        if (typeof transform !== 'function') {
            // default to the identity function
            transform = function (value) {
                return value;
            };
        }

        return Ember['default'].computed(upstream, {
            get: function get() {
                return transform(this.get(upstream));
            },
            set: function set(key, value) {
                return value;
            }
        });
    };

    exports['default'] = BoundOneWay;

});
define('ghost/utils/caja-sanitizers', ['exports'], function (exports) {

    'use strict';

    /**
     * google-caja uses url() and id() to verify if the values are allowed.
     */
    var url, id;

    /**
     * Check if URL is allowed
     * URLs are allowed if they start with http://, https://, or /.
     */
    url = function (url) {
        url = url.toString().replace(/['"]+/g, '');
        if (/^https?:\/\//.test(url) || /^\//.test(url)) {
            return url;
        }
    };

    /**
     * Check if ID is allowed
     * All ids are allowed at the moment.
     */
    id = function (id) {
        return id;
    };

    exports['default'] = {
        url: url,
        id: id
    };

});
define('ghost/utils/ctrl-or-cmd', ['exports'], function (exports) {

	'use strict';

	var ctrlOrCmd = navigator.userAgent.indexOf('Mac') !== -1 ? 'command' : 'ctrl';

	exports['default'] = ctrlOrCmd;

});
define('ghost/utils/date-formatting', ['exports'], function (exports) {

    'use strict';

    /* global moment */
    // jscs: disable disallowSpacesInsideParentheses

    var parseDateFormats, displayDateFormat, verifyTimeStamp, parseDateString, formatDate;

    parseDateFormats = ['DD MMM YY @ HH:mm', 'DD MMM YY HH:mm', 'D MMM YY @ HH:mm', 'D MMM YY HH:mm', 'DD MMM YYYY @ HH:mm', 'DD MMM YYYY HH:mm', 'D MMM YYYY @ HH:mm', 'D MMM YYYY HH:mm', 'DD/MM/YY @ HH:mm', 'DD/MM/YY HH:mm', 'DD/MM/YYYY @ HH:mm', 'DD/MM/YYYY HH:mm', 'DD-MM-YY @ HH:mm', 'DD-MM-YY HH:mm', 'DD-MM-YYYY @ HH:mm', 'DD-MM-YYYY HH:mm', 'YYYY-MM-DD @ HH:mm', 'YYYY-MM-DD HH:mm', 'DD MMM @ HH:mm', 'DD MMM HH:mm', 'D MMM @ HH:mm', 'D MMM HH:mm'];

    displayDateFormat = 'DD MMM YY @ HH:mm';

    // Add missing timestamps
    verifyTimeStamp = function (dateString) {
        if (dateString && !dateString.slice(-5).match(/\d+:\d\d/)) {
            dateString += ' 12:00';
        }
        return dateString;
    };

    // Parses a string to a Moment
    parseDateString = function (value) {
        return value ? moment(verifyTimeStamp(value), parseDateFormats, true) : undefined;
    };

    // Formats a Date or Moment
    formatDate = function (value) {
        return verifyTimeStamp(value ? moment(value).format(displayDateFormat) : '');
    };

    exports.parseDateString = parseDateString;
    exports.formatDate = formatDate;

});
define('ghost/utils/document-title', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    var documentTitle = function documentTitle() {
        Ember['default'].Route.reopen({
            // `titleToken` can either be a static string or a function
            // that accepts a model object and returns a string (or array
            // of strings if there are multiple tokens).
            titleToken: null,

            // `title` can either be a static string or a function
            // that accepts an array of tokens and returns a string
            // that will be the document title. The `collectTitleTokens` action
            // stops bubbling once a route is encountered that has a `title`
            // defined.
            title: null,

            _actions: {
                collectTitleTokens: function collectTitleTokens(tokens) {
                    var titleToken = this.titleToken,
                        finalTitle;

                    if (typeof this.titleToken === 'function') {
                        titleToken = this.titleToken(this.currentModel);
                    }

                    if (Ember['default'].isArray(titleToken)) {
                        tokens.unshift.apply(this, titleToken);
                    } else if (titleToken) {
                        tokens.unshift(titleToken);
                    }

                    if (this.title) {
                        if (typeof this.title === 'function') {
                            finalTitle = this.title(tokens);
                        } else {
                            finalTitle = this.title;
                        }

                        this.router.setTitle(finalTitle);
                    } else {
                        return true;
                    }
                }
            }
        });

        Ember['default'].Router.reopen({
            updateTitle: (function () {
                this.send('collectTitleTokens', []);
            }).on('didTransition'),

            setTitle: function setTitle(title) {
                if (Ember['default'].testing) {
                    this._title = title;
                } else {
                    window.document.title = title;
                }
            }
        });
    };

    exports['default'] = documentTitle;

});
define('ghost/utils/ed-image-manager', ['exports'], function (exports) {

    'use strict';

    var imageMarkdownRegex = /^!(?:\[([^\n\]]*)\])(?:\(([^\n\]]*)\))?$/gim;

    // Process the markdown content and find all of the locations where there is an image markdown block
    function parse(stringToParse) {
        var m,
            images = [];
        while ((m = imageMarkdownRegex.exec(stringToParse)) !== null) {
            images.push(m);
        }

        return images;
    }

    // Loop through all dropzones in the preview and find which one was the target of the upload
    function getZoneIndex(element) {
        var zones = document.querySelectorAll('.js-entry-preview .js-drop-zone'),
            i;

        for (i = 0; i < zones.length; i += 1) {
            if (zones.item(i) === element) {
                return i;
            }
        }

        return -1;
    }

    // Figure out the start and end of the selection range for the src in the markdown, so we know what to replace
    function getSrcRange(content, element) {
        var images = parse(content),
            index = getZoneIndex(element),
            replacement = {};

        if (index > -1) {
            // [1] matches the alt test, and 2 matches the url between the ()
            // if the () are missing entirely, which is valid, [2] will be undefined and we'll need to treat this case
            // a little differently
            if (images[index][2] === undefined) {
                replacement.needsParens = true;
                replacement.start = content.indexOf(']', images[index].index) + 1;
                replacement.end = replacement.start;
            } else {
                replacement.start = content.indexOf('(', images[index].index) + 1;
                replacement.end = replacement.start + images[index][2].length;
            }
            return replacement;
        }

        return false;
    }

    exports['default'] = {
        getSrcRange: getSrcRange
    };

});
define('ghost/utils/editor-shortcuts', ['exports', 'ghost/utils/ctrl-or-cmd'], function (exports, ctrlOrCmd) {

	'use strict';

	// # Editor shortcuts
	// Loaded by EditorBaseRoute, which is a shortcuts route
	// This map is used to ensure the right action is called by each shortcut
	var shortcuts = {};

	// General editor shortcuts
	shortcuts[ctrlOrCmd['default'] + '+alt+p'] = 'publish';
	shortcuts['alt+shift+z'] = 'toggleZenMode';

	// Markdown Shortcuts

	// Text
	shortcuts['ctrl+alt+u'] = { action: 'editorShortcut', options: { type: 'strike' } };
	shortcuts[ctrlOrCmd['default'] + '+b'] = { action: 'editorShortcut', options: { type: 'bold' } };
	shortcuts[ctrlOrCmd['default'] + '+i'] = { action: 'editorShortcut', options: { type: 'italic' } };

	shortcuts['ctrl+u'] = { action: 'editorShortcut', options: { type: 'uppercase' } };
	shortcuts['ctrl+shift+u'] = { action: 'editorShortcut', options: { type: 'lowercase' } };
	shortcuts['ctrl+alt+shift+u'] = { action: 'editorShortcut', options: { type: 'titlecase' } };
	shortcuts[ctrlOrCmd['default'] + '+shift+c'] = { action: 'editorShortcut', options: { type: 'copyHTML' } };
	shortcuts[ctrlOrCmd['default'] + '+h'] = { action: 'editorShortcut', options: { type: 'cycleHeaderLevel' } };

	// Formatting
	shortcuts['ctrl+q'] = { action: 'editorShortcut', options: { type: 'blockquote' } };
	shortcuts['ctrl+l'] = { action: 'editorShortcut', options: { type: 'list' } };

	// Insert content
	shortcuts['ctrl+shift+1'] = { action: 'editorShortcut', options: { type: 'currentDate' } };
	shortcuts[ctrlOrCmd['default'] + '+k'] = { action: 'editorShortcut', options: { type: 'link' } };
	shortcuts[ctrlOrCmd['default'] + '+shift+i'] = { action: 'editorShortcut', options: { type: 'image' } };
	shortcuts[ctrlOrCmd['default'] + '+shift+k'] = { action: 'editorShortcut', options: { type: 'code' } };

	exports['default'] = shortcuts;

});
define('ghost/utils/ghost-paths', ['exports'], function (exports) {

    'use strict';

    var makeRoute = function makeRoute(root, args) {
        var slashAtStart, slashAtEnd, parts, route;

        slashAtStart = /^\//;
        slashAtEnd = /\/$/;
        route = root.replace(slashAtEnd, '');
        parts = Array.prototype.slice.call(args, 0);

        parts.forEach(function (part) {
            if (part) {
                route = [route, part.replace(slashAtStart, '').replace(slashAtEnd, '')].join('/');
            }
        });
        return route += '/';
    };

    function ghostPaths() {
        var path = window.location.pathname,
            subdir = path.substr(0, path.search('/ghost/')),
            adminRoot = subdir + '/ghost',
            apiRoot = subdir + '/ghost/api/v0.1';

        function assetUrl(src) {
            return subdir + src;
        }

        return {
            subdir: subdir,
            blogRoot: subdir + '/',
            adminRoot: adminRoot,
            apiRoot: apiRoot,

            url: {
                admin: function admin() {
                    return makeRoute(adminRoot, arguments);
                },

                api: function api() {
                    return makeRoute(apiRoot, arguments);
                },

                join: function join() {
                    if (arguments.length > 1) {
                        return makeRoute(arguments[0], Array.prototype.slice.call(arguments, 1));
                    } else if (arguments.length === 1) {
                        var arg = arguments[0];
                        return arg.slice(-1) === '/' ? arg : arg + '/';
                    }
                    return '/';
                },

                asset: assetUrl
            },
            count: 'https://ghost.org/count/'
        };
    }

    exports['default'] = ghostPaths;

});
define('ghost/utils/isFinite', ['exports'], function (exports) {

    'use strict';

    /* globals window */

    // isFinite function from lodash

    function isFinite(value) {
        return window.isFinite(value) && !window.isNaN(parseFloat(value));
    }

    exports['default'] = isFinite;

});
define('ghost/utils/isNumber', ['exports'], function (exports) {

  'use strict';

  // isNumber function from lodash

  var toString = Object.prototype.toString;

  function isNumber(value) {
    return typeof value === 'number' || value && typeof value === 'object' && toString.call(value) === '[object Number]' || false;
  }

  exports['default'] = isNumber;

});
define('ghost/utils/link-component', ['ember'], function (Ember) {

    'use strict';

    Ember['default'].LinkComponent.reopen({
        active: Ember['default'].computed('attrs.params', '_routing.currentState', function () {
            var isActive = this._super();

            if (typeof this.attrs.alternateActive === 'function') {
                this.attrs.alternateActive(isActive);
            }

            return isActive;
        }),

        activeClass: Ember['default'].computed('tagName', function () {
            return this.get('tagName') === 'button' ? '' : 'active';
        })
    });

});
define('ghost/utils/mobile', ['exports'], function (exports) {

	'use strict';

	var mobileQuery = matchMedia('(max-width: 800px)');

	exports['default'] = mobileQuery;

});
define('ghost/utils/random-password', ['exports'], function (exports) {

    'use strict';

    /* global generatePassword */

    function randomPassword() {
        var word = generatePassword(6),
            randomN = Math.floor(Math.random() * 1000);

        return word + randomN;
    }

    exports['default'] = randomPassword;

});
define('ghost/utils/set-scroll-classname', ['exports'], function (exports) {

    'use strict';

    // ## scrollShadow
    // This adds a 'scroll' class to the targeted element when the element is scrolled
    // `this` is expected to be a jQuery-wrapped element
    // **target:** The element in which the class is applied. Defaults to scrolled element.
    // **class-name:** The class which is applied.
    // **offset:** How far the user has to scroll before the class is applied.
    var setScrollClassName = function setScrollClassName(options) {
        var $target = options.target || this,
            offset = options.offset,
            className = options.className || 'scrolling';

        if (this.scrollTop() > offset) {
            $target.addClass(className);
        } else {
            $target.removeClass(className);
        }
    };

    exports['default'] = setScrollClassName;

});
define('ghost/utils/text-field', ['ember'], function (Ember) {

    'use strict';

    Ember['default'].TextField.reopen({
        attributeBindings: ['autofocus']
    });

});
define('ghost/utils/titleize', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    var lowerWords = ['of', 'a', 'the', 'and', 'an', 'or', 'nor', 'but', 'is', 'if', 'then', 'else', 'when', 'at', 'from', 'by', 'on', 'off', 'for', 'in', 'out', 'over', 'to', 'into', 'with'];

    function titleize(input) {
        var words = input.split(' ').map(function (word, index) {
            if (index === 0 || lowerWords.indexOf(word) === -1) {
                word = Ember['default'].String.capitalize(word);
            }

            return word;
        });

        return words.join(' ');
    }

    exports['default'] = titleize;

});
define('ghost/utils/validator-extensions', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    function init() {
        // Provide a few custom validators
        //
        validator.extend('empty', function (str) {
            return Ember['default'].isBlank(str);
        });

        validator.extend('notContains', function (str, badString) {
            return str.indexOf(badString) === -1;
        });
    }

    exports['default'] = {
        init: init
    };

});
define('ghost/utils/word-count', ['exports'], function (exports) {

    'use strict';

    // jscs: disable
    /* global XRegExp */

    function wordCount(s) {

        var nonANumLetters = new XRegExp("[^\\s\\d\\p{L}]", "g"); // all non-alphanumeric letters regexp

        s = s.replace(/<(.|\n)*?>/g, ' '); // strip tags
        s = s.replace(nonANumLetters, ''); // ignore non-alphanumeric letters
        s = s.replace(/(^\s*)|(\s*$)/gi, ''); // exclude starting and ending white-space
        s = s.replace(/\n /gi, ' '); // convert newlines to spaces
        s = s.replace(/\n+/gi, ' ');
        s = s.replace(/[ ]{2,}/gi, ' '); // convert 2 or more spaces to 1

        return s.split(' ').length;
    }

    exports['default'] = wordCount;

});
define('ghost/validators/base', ['exports', 'ember'], function (exports, Ember) {

    'use strict';

    var BaseValidator = Ember['default'].Object.extend({
        properties: [],
        passed: false,

        /**
         * When passed a model and (optionally) a property name,
         * checks it against a list of validation functions
         * @param  {Ember.Object} model Model to validate
         * @param  {string} prop  Property name to check
         * @return {boolean}      True if the model passed all (or one) validation(s),
         *                        false if not
         */
        check: function check(model, prop) {
            var self = this;

            this.set('passed', true);

            if (prop && this[prop]) {
                this[prop](model);
            } else {
                this.get('properties').forEach(function (property) {
                    if (self[property]) {
                        self[property](model);
                    }
                });
            }
            return this.get('passed');
        },
        invalidate: function invalidate() {
            this.set('passed', false);
        }
    });

    exports['default'] = BaseValidator;

});
define('ghost/validators/new-user', ['exports', 'ghost/validators/base'], function (exports, BaseValidator) {

    'use strict';

    var NewUserValidator = BaseValidator['default'].extend({
        properties: ['name', 'email', 'password'],

        name: function name(model) {
            var name = model.get('name');

            if (!validator.isLength(name, 1)) {
                model.get('errors').add('name', 'Please enter a name.');
                this.invalidate();
            }
        },
        email: function email(model) {
            var email = model.get('email');

            if (validator.empty(email)) {
                model.get('errors').add('email', 'Please enter an email.');
                this.invalidate();
            } else if (!validator.isEmail(email)) {
                model.get('errors').add('email', 'Invalid Email.');
                this.invalidate();
            }
        },
        password: function password(model) {
            var password = model.get('password');

            if (!validator.isLength(password, 8)) {
                model.get('errors').add('password', 'Password must be at least 8 characters long');
                this.invalidate();
            }
        }
    });

    exports['default'] = NewUserValidator;

});
define('ghost/validators/post', ['exports', 'ghost/validators/base'], function (exports, BaseValidator) {

    'use strict';

    var PostValidator = BaseValidator['default'].create({
        properties: ['title', 'metaTitle', 'metaDescription'],

        title: function title(model) {
            var title = model.get('title');

            if (validator.empty(title)) {
                model.get('errors').add('title', 'You must specify a title for the post.');
                this.invalidate();
            }

            if (!validator.isLength(title, 0, 150)) {
                model.get('errors').add('title', 'Title cannot be longer than 150 characters.');
                this.invalidate();
            }
        },

        metaTitle: function metaTitle(model) {
            var metaTitle = model.get('meta_title');

            if (!validator.isLength(metaTitle, 0, 150)) {
                model.get('errors').add('meta_title', 'Meta Title cannot be longer than 150 characters.');
                this.invalidate();
            }
        },

        metaDescription: function metaDescription(model) {
            var metaDescription = model.get('meta_description');

            if (!validator.isLength(metaDescription, 0, 200)) {
                model.get('errors').add('meta_description', 'Meta Description cannot be longer than 200 characters.');
                this.invalidate();
            }
        }
    });

    exports['default'] = PostValidator;

});
define('ghost/validators/reset', ['exports', 'ghost/validators/base'], function (exports, BaseValidator) {

    'use strict';

    var ResetValidator = BaseValidator['default'].create({
        properties: ['newPassword'],
        newPassword: function newPassword(model) {
            var p1 = model.get('newPassword'),
                p2 = model.get('ne2Password');

            if (validator.empty(p1)) {
                model.get('errors').add('newPassword', 'Please enter a password.');
                this.invalidate();
            } else if (!validator.isLength(p1, 8)) {
                model.get('errors').add('newPassword', 'The password is not long enough.');
                this.invalidate();
            } else if (!validator.equals(p1, p2)) {
                model.get('errors').add('ne2Password', 'The two new passwords don\'t match.');
                this.invalidate();
            }
        }
    });

    exports['default'] = ResetValidator;

});
define('ghost/validators/setting', ['exports', 'ghost/validators/base'], function (exports, BaseValidator) {

    'use strict';

    var SettingValidator = BaseValidator['default'].create({
        properties: ['title', 'description', 'password', 'postsPerPage'],
        title: function title(model) {
            var title = model.get('title');

            if (!validator.isLength(title, 0, 150)) {
                model.get('errors').add('title', 'Title is too long');
                this.invalidate();
            }
        },
        description: function description(model) {
            var desc = model.get('description');

            if (!validator.isLength(desc, 0, 200)) {
                model.get('errors').add('description', 'Description is too long');
                this.invalidate();
            }
        },
        password: function password(model) {
            var isPrivate = model.get('isPrivate'),
                password = model.get('password');

            if (isPrivate && password === '') {
                model.get('errors').add('password', 'Password must be supplied');
                this.invalidate();
            }
        },
        postsPerPage: function postsPerPage(model) {
            var postsPerPage = model.get('postsPerPage');

            if (!validator.isInt(postsPerPage)) {
                model.get('errors').add('postsPerPage', 'Posts per page must be a number');
                this.invalidate();
            } else if (postsPerPage > 1000) {
                model.get('errors').add('postsPerPage', 'The maximum number of posts per page is 1000');
                this.invalidate();
            } else if (postsPerPage < 1) {
                model.get('errors').add('postsPerPage', 'The minimum number of posts per page is 1');
                this.invalidate();
            }
        }
    });

    exports['default'] = SettingValidator;

});
define('ghost/validators/setup', ['exports', 'ghost/validators/new-user'], function (exports, NewUserValidator) {

    'use strict';

    var SetupValidator = NewUserValidator['default'].create({
        properties: ['name', 'email', 'password', 'blogTitle'],

        blogTitle: function blogTitle(model) {
            var blogTitle = model.get('blogTitle');

            if (!validator.isLength(blogTitle, 1)) {
                model.get('errors').add('blogTitle', 'Please enter a blog title.');
                this.invalidate();
            }
        }
    });

    exports['default'] = SetupValidator;

});
define('ghost/validators/signin', ['exports', 'ghost/validators/base'], function (exports, BaseValidator) {

    'use strict';

    var SigninValidator = BaseValidator['default'].create({
        properties: ['identification', 'signin', 'forgotPassword'],
        invalidMessage: 'Email address is not valid',

        identification: function identification(model) {
            var id = model.get('identification');

            if (!validator.empty(id) && !validator.isEmail(id)) {
                model.get('errors').add('identification', this.get('invalidMessage'));
                this.invalidate();
            }
        },

        signin: function signin(model) {
            var id = model.get('identification'),
                password = model.get('password');

            model.get('errors').clear();

            if (validator.empty(id)) {
                model.get('errors').add('identification', 'Please enter an email');
                this.invalidate();
            }

            if (!validator.empty(id) && !validator.isEmail(id)) {
                model.get('errors').add('identification', this.get('invalidMessage'));
                this.invalidate();
            }

            if (validator.empty(password)) {
                model.get('errors').add('password', 'Please enter a password');
                this.invalidate();
            }
        },

        forgotPassword: function forgotPassword(model) {
            var id = model.get('identification');

            model.get('errors').clear();

            if (validator.empty(id) || !validator.isEmail(id)) {
                model.get('errors').add('identification', this.get('invalidMessage'));
                this.invalidate();
            }
        }
    });

    exports['default'] = SigninValidator;

});
define('ghost/validators/signup', ['exports', 'ghost/validators/new-user'], function (exports, NewUserValidator) {

	'use strict';

	exports['default'] = NewUserValidator['default'].create();

});
define('ghost/validators/tag-settings', ['exports', 'ghost/validators/base'], function (exports, BaseValidator) {

    'use strict';

    var TagSettingsValidator = BaseValidator['default'].create({
        properties: ['name', 'metaTitle', 'metaDescription'],
        name: function name(model) {
            var name = model.get('name');

            if (validator.empty(name)) {
                model.get('errors').add('name', 'You must specify a name for the tag.');
                this.invalidate();
            } else if (name.match(/^,/)) {
                model.get('errors').add('name', 'Tag names can\'t start with commas.');
                this.invalidate();
            } else if (!validator.isLength(name, 0, 150)) {
                model.get('errors').add('name', 'Tag names cannot be longer than 150 characters.');
                this.invalidate();
            }
        },
        metaTitle: function metaTitle(model) {
            var metaTitle = model.get('meta_title');

            if (!validator.isLength(metaTitle, 0, 150)) {
                model.get('errors').add('meta_title', 'Meta Title cannot be longer than 150 characters.');
                this.invalidate();
            }
        },
        metaDescription: function metaDescription(model) {
            var metaDescription = model.get('meta_description');

            if (!validator.isLength(metaDescription, 0, 200)) {
                model.get('errors').add('meta_description', 'Meta Description cannot be longer than 200 characters.');
                this.invalidate();
            }
        }
    });

    exports['default'] = TagSettingsValidator;

});
define('ghost/validators/user', ['exports', 'ghost/validators/base', 'ember'], function (exports, BaseValidator, Ember) {

    'use strict';

    var UserValidator = BaseValidator['default'].create({
        properties: ['name', 'bio', 'email', 'location', 'website', 'roles'],
        isActive: function isActive(model) {
            return model.get('status') === 'active';
        },
        name: function name(model) {
            var name = model.get('name');

            if (this.isActive(model)) {
                if (validator.empty(name)) {
                    model.get('errors').add('name', 'Please enter a name.');
                    this.invalidate();
                } else if (!validator.isLength(name, 0, 150)) {
                    model.get('errors').add('name', 'Name is too long');
                    this.invalidate();
                }
            }
        },
        bio: function bio(model) {
            var bio = model.get('bio');

            if (this.isActive(model)) {
                if (!validator.isLength(bio, 0, 200)) {
                    model.get('errors').add('bio', 'Bio is too long');
                    this.invalidate();
                }
            }
        },
        email: function email(model) {
            var email = model.get('email');

            if (!validator.isEmail(email)) {
                model.get('errors').add('email', 'Please supply a valid email address');
                this.invalidate();
            }
        },
        location: function location(model) {
            var location = model.get('location');

            if (this.isActive(model)) {
                if (!validator.isLength(location, 0, 150)) {
                    model.get('errors').add('location', 'Location is too long');
                    this.invalidate();
                }
            }
        },
        website: function website(model) {
            var website = model.get('website');

            if (this.isActive(model)) {
                if (!Ember['default'].isEmpty(website) && (!validator.isURL(website, { require_protocol: false }) || !validator.isLength(website, 0, 2000))) {
                    model.get('errors').add('website', 'Website is not a valid url');
                    this.invalidate();
                }
            }
        },
        roles: function roles(model) {
            if (!this.isActive(model)) {
                var roles = model.get('roles');

                if (roles.length < 1) {
                    model.get('errors').add('role', 'Please select a role');
                    this.invalidate();
                }
            }
        }
    });

    exports['default'] = UserValidator;

});
/* jshint ignore:start */

/* jshint ignore:end */

/* jshint ignore:start */

define('ghost/config/environment', ['ember'], function(Ember) {
  var prefix = 'ghost';
/* jshint ignore:start */

try {
  var metaName = prefix + '/config/environment';
  var rawConfig = Ember['default'].$('meta[name="' + metaName + '"]').attr('content');
  var config = JSON.parse(unescape(rawConfig));

  return { 'default': config };
}
catch(err) {
  throw new Error('Could not read config from meta tag with name "' + metaName + '".');
}

/* jshint ignore:end */

});

if (runningTests) {
  require("ghost/tests/test-helper");
} else {
  require("ghost/app")["default"].create({"LOG_ACTIVE_GENERATION":true,"LOG_TRANSITIONS":true,"LOG_TRANSITIONS_INTERNAL":true,"LOG_VIEW_LOOKUPS":true,"name":"ghost","version":"0.7.0"});
}

/* jshint ignore:end */
//# sourceMappingURL=ghost.map