Proyectos de Subversion Moodle

/**

 * TinyMCE version 7.7.1 (2025-03-05)

 */

(function () {

    'use strict';

    var global$4 = tinymce.util.Tools.resolve('tinymce.PluginManager');

    const hasProto = (v, constructor, predicate) => {

      var _a;

      if (predicate(v, constructor.prototype)) {

        return true;

      } else {

        return ((_a = v.constructor) === null || _a === void 0 ? void 0 : _a.name) === constructor.name;

      }

    };

    const typeOf = x => {

      const t = typeof x;

      if (x === null) {

        return 'null';

      } else if (t === 'object' && Array.isArray(x)) {

        return 'array';

      } else if (t === 'object' && hasProto(x, String, (o, proto) => proto.isPrototypeOf(o))) {

        return 'string';

      } else {

        return t;

      }

    };

    const isType = type => value => typeOf(value) === type;

    const eq = t => a => t === a;

    const isString = isType('string');

    const isUndefined = eq(undefined);

    var global$3 = tinymce.util.Tools.resolve('tinymce.util.Delay');

    var global$2 = tinymce.util.Tools.resolve('tinymce.util.LocalStorage');

    var global$1 = tinymce.util.Tools.resolve('tinymce.util.Tools');

    const fireRestoreDraft = editor => editor.dispatch('RestoreDraft');

    const fireStoreDraft = editor => editor.dispatch('StoreDraft');

    const fireRemoveDraft = editor => editor.dispatch('RemoveDraft');

    const parse = timeString => {

      const multiples = {

        s: 1000,

        m: 60000

      };

      const parsedTime = /^(\d+)([ms]?)$/.exec(timeString);

      return (parsedTime && parsedTime[2] ? multiples[parsedTime[2]] : 1) * parseInt(timeString, 10);

    };

    const option = name => editor => editor.options.get(name);

    const register$1 = editor => {

      const registerOption = editor.options.register;

      const timeProcessor = value => {

        const valid = isString(value);

        if (valid) {

          return {

            value: parse(value),

            valid

          };

        } else {

          return {

            valid: false,

            message: 'Must be a string.'

          };

        }

      };

      registerOption('autosave_ask_before_unload', {

        processor: 'boolean',

        default: true

      });

      registerOption('autosave_prefix', {

        processor: 'string',

        default: 'tinymce-autosave-{path}{query}{hash}-{id}-'

      });

      registerOption('autosave_restore_when_empty', {

        processor: 'boolean',

        default: false

      });

      registerOption('autosave_interval', {

        processor: timeProcessor,

        default: '30s'

      });

      registerOption('autosave_retention', {

        processor: timeProcessor,

        default: '20m'

      });

    };

    const shouldAskBeforeUnload = option('autosave_ask_before_unload');

    const shouldRestoreWhenEmpty = option('autosave_restore_when_empty');

    const getAutoSaveInterval = option('autosave_interval');

    const getAutoSaveRetention = option('autosave_retention');

    const getAutoSavePrefix = editor => {

      const location = document.location;

      return editor.options.get('autosave_prefix').replace(/{path}/g, location.pathname).replace(/{query}/g, location.search).replace(/{hash}/g, location.hash).replace(/{id}/g, editor.id);

    };

    const isEmpty = (editor, html) => {

      if (isUndefined(html)) {

        return editor.dom.isEmpty(editor.getBody());

      } else {

        const trimmedHtml = global$1.trim(html);

        if (trimmedHtml === '') {

          return true;

        } else {

          const fragment = new DOMParser().parseFromString(trimmedHtml, 'text/html');

          return editor.dom.isEmpty(fragment);

        }

      }

    };

    const hasDraft = editor => {

      var _a;

      const time = parseInt((_a = global$2.getItem(getAutoSavePrefix(editor) + 'time')) !== null && _a !== void 0 ? _a : '0', 10) || 0;

      if (new Date().getTime() - time > getAutoSaveRetention(editor)) {

        removeDraft(editor, false);

        return false;

      }

      return true;

    };

    const removeDraft = (editor, fire) => {

      const prefix = getAutoSavePrefix(editor);

      global$2.removeItem(prefix + 'draft');

      global$2.removeItem(prefix + 'time');

      if (fire !== false) {

        fireRemoveDraft(editor);

      }

    };

    const storeDraft = editor => {

      const prefix = getAutoSavePrefix(editor);

      if (!isEmpty(editor) && editor.isDirty()) {

        global$2.setItem(prefix + 'draft', editor.getContent({

          format: 'raw',

          no_events: true

        }));

        global$2.setItem(prefix + 'time', new Date().getTime().toString());

        fireStoreDraft(editor);

      }

    };

    const restoreDraft = editor => {

      var _a;

      const prefix = getAutoSavePrefix(editor);

      if (hasDraft(editor)) {

        editor.setContent((_a = global$2.getItem(prefix + 'draft')) !== null && _a !== void 0 ? _a : '', { format: 'raw' });

        fireRestoreDraft(editor);

      }

    };

    const startStoreDraft = editor => {

      const interval = getAutoSaveInterval(editor);

      global$3.setEditorInterval(editor, () => {

        storeDraft(editor);

      }, interval);

    };

    const restoreLastDraft = editor => {

      editor.undoManager.transact(() => {

        restoreDraft(editor);

        removeDraft(editor);

      });

      editor.focus();

    };

    const get = editor => ({

      hasDraft: () => hasDraft(editor),

      storeDraft: () => storeDraft(editor),

      restoreDraft: () => restoreDraft(editor),

      removeDraft: fire => removeDraft(editor, fire),

      isEmpty: html => isEmpty(editor, html)

    });

    var global = tinymce.util.Tools.resolve('tinymce.EditorManager');

    const setup = editor => {

      editor.editorManager.on('BeforeUnload', e => {

        let msg;

        global$1.each(global.get(), editor => {

          if (editor.plugins.autosave) {

            editor.plugins.autosave.storeDraft();

          }

          if (!msg && editor.isDirty() && shouldAskBeforeUnload(editor)) {

            msg = editor.translate('You have unsaved changes are you sure you want to navigate away?');

          }

        });

        if (msg) {

          e.preventDefault();

          e.returnValue = msg;

        }

      });

    };

    const makeSetupHandler = editor => api => {

      const shouldEnable = () => hasDraft(editor) && !editor.mode.isReadOnly();

      api.setEnabled(shouldEnable());

      const editorEventCallback = () => api.setEnabled(shouldEnable());

      editor.on('StoreDraft RestoreDraft RemoveDraft', editorEventCallback);

      return () => editor.off('StoreDraft RestoreDraft RemoveDraft', editorEventCallback);

    };

    const register = editor => {

      startStoreDraft(editor);

      const onAction = () => {

        restoreLastDraft(editor);

      };

      editor.ui.registry.addButton('restoredraft', {

        tooltip: 'Restore last draft',

        icon: 'restore-draft',

        onAction,

        onSetup: makeSetupHandler(editor)

      });

      editor.ui.registry.addMenuItem('restoredraft', {

        text: 'Restore last draft',

        icon: 'restore-draft',

        onAction,

        onSetup: makeSetupHandler(editor)

      });

    };

    var Plugin = () => {

      global$4.add('autosave', editor => {

        register$1(editor);

        setup(editor);

        register(editor);

        editor.on('init', () => {

          if (shouldRestoreWhenEmpty(editor) && editor.dom.isEmpty(editor.getBody())) {

            restoreDraft(editor);

          }

        });

        return get(editor);

      });

    };

    Plugin();

})();