Proyectos de Subversion Moodle

/**

 * TinyMCE version 7.7.1 (2025-03-05)

 */

(function () {

    'use strict';

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

    const random = () => window.crypto.getRandomValues(new Uint32Array(1))[0] / 4294967295;

    let unique = 0;

    const generate = prefix => {

      const date = new Date();

      const time = date.getTime();

      const random$1 = Math.floor(random() * 1000000000);

      unique++;

      return prefix + '_' + random$1 + unique + String(time);

    };

    const insertTable = (editor, columns, rows) => {

      editor.execCommand('mceInsertTable', false, {

        rows,

        columns

      });

    };

    const insertBlob = (editor, base64, blob) => {

      const blobCache = editor.editorUpload.blobCache;

      const blobInfo = blobCache.create(generate('mceu'), blob, base64);

      blobCache.add(blobInfo);

      editor.insertContent(editor.dom.createHTML('img', { src: blobInfo.blobUri() }));

    };

    const blobToBase64 = blob => {

      return new Promise(resolve => {

        const reader = new FileReader();

        reader.onloadend = () => {

          resolve(reader.result.split(',')[1]);

        };

        reader.readAsDataURL(blob);

      });

    };

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

    const pickFile = editor => new Promise(resolve => {

      let resolved = false;

      const fileInput = document.createElement('input');

      fileInput.type = 'file';

      fileInput.accept = 'image/*';

      fileInput.style.position = 'fixed';

      fileInput.style.left = '0';

      fileInput.style.top = '0';

      fileInput.style.opacity = '0.001';

      document.body.appendChild(fileInput);

      const resolveFileInput = value => {

        var _a;

        if (!resolved) {

          (_a = fileInput.parentNode) === null || _a === void 0 ? void 0 : _a.removeChild(fileInput);

          resolved = true;

          resolve(value);

        }

      };

      const changeHandler = e => {

        resolveFileInput(Array.prototype.slice.call(e.target.files));

      };

      fileInput.addEventListener('input', changeHandler);

      fileInput.addEventListener('change', changeHandler);

      const cancelHandler = e => {

        const cleanup = () => {

          resolveFileInput([]);

        };

        if (!resolved) {

          if (e.type === 'focusin') {

            global.setEditorTimeout(editor, cleanup, 1000);

          } else {

            cleanup();

          }

        }

        editor.off('focusin remove', cancelHandler);

      };

      editor.on('focusin remove', cancelHandler);

      fileInput.click();

    });

    const register$1 = editor => {

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

        if (!editor.queryCommandSupported('QuickbarInsertImage')) {

          editor.addCommand('QuickbarInsertImage', () => {

            pickFile(editor).then(files => {

              if (files.length > 0) {

                const blob = files[0];

                blobToBase64(blob).then(base64 => {

                  insertBlob(editor, base64, blob);

                });

              }

            });

          });

        }

      });

    };

    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 isSimpleType = type => value => typeof value === type;

    const isString = isType('string');

    const isBoolean = isSimpleType('boolean');

    const isNullable = a => a === null || a === undefined;

    const isNonNullable = a => !isNullable(a);

    const isFunction = isSimpleType('function');

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

    const register = editor => {

      const registerOption = editor.options.register;

      const toolbarProcessor = defaultValue => value => {

        const valid = isBoolean(value) || isString(value);

        if (valid) {

          if (isBoolean(value)) {

            return {

              value: value ? defaultValue : '',

              valid

            };

          } else {

            return {

              value: value.trim(),

              valid

            };

          }

        } else {

          return {

            valid: false,

            message: 'Must be a boolean or string.'

          };

        }

      };

      const defaultSelectionToolbar = 'bold italic | quicklink h2 h3 blockquote';

      registerOption('quickbars_selection_toolbar', {

        processor: toolbarProcessor(defaultSelectionToolbar),

        default: defaultSelectionToolbar

      });

      const defaultInsertToolbar = 'quickimage quicktable';

      registerOption('quickbars_insert_toolbar', {

        processor: toolbarProcessor(defaultInsertToolbar),

        default: defaultInsertToolbar

      });

      const defaultImageToolbar = 'alignleft aligncenter alignright';

      registerOption('quickbars_image_toolbar', {

        processor: toolbarProcessor(defaultImageToolbar),

        default: defaultImageToolbar

      });

    };

    const getTextSelectionToolbarItems = option('quickbars_selection_toolbar');

    const getInsertToolbarItems = option('quickbars_insert_toolbar');

    const getImageToolbarItems = option('quickbars_image_toolbar');

    const setupButtons = editor => {

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

        icon: 'image',

        tooltip: 'Insert image',

        onAction: () => editor.execCommand('QuickbarInsertImage')

      });

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

        icon: 'table',

        tooltip: 'Insert table',

        onAction: () => {

          insertTable(editor, 2, 2);

        }

      });

    };

    const constant = value => {

      return () => {

        return value;

      };

    };

    const never = constant(false);

    class Optional {

      constructor(tag, value) {

        this.tag = tag;

        this.value = value;

      }

      static some(value) {

        return new Optional(true, value);

      }

      static none() {

        return Optional.singletonNone;

      }

      fold(onNone, onSome) {

        if (this.tag) {

          return onSome(this.value);

        } else {

          return onNone();

        }

      }

      isSome() {

        return this.tag;

      }

      isNone() {

        return !this.tag;

      }

      map(mapper) {

        if (this.tag) {

          return Optional.some(mapper(this.value));

        } else {

          return Optional.none();

        }

      }

      bind(binder) {

        if (this.tag) {

          return binder(this.value);

        } else {

          return Optional.none();

        }

      }

      exists(predicate) {

        return this.tag && predicate(this.value);

      }

      forall(predicate) {

        return !this.tag || predicate(this.value);

      }

      filter(predicate) {

        if (!this.tag || predicate(this.value)) {

          return this;

        } else {

          return Optional.none();

        }

      }

      getOr(replacement) {

        return this.tag ? this.value : replacement;

      }

      or(replacement) {

        return this.tag ? this : replacement;

      }

      getOrThunk(thunk) {

        return this.tag ? this.value : thunk();

      }

      orThunk(thunk) {

        return this.tag ? this : thunk();

      }

      getOrDie(message) {

        if (!this.tag) {

          throw new Error(message !== null && message !== void 0 ? message : 'Called getOrDie on None');

        } else {

          return this.value;

        }

      }

      static from(value) {

        return isNonNullable(value) ? Optional.some(value) : Optional.none();

      }

      getOrNull() {

        return this.tag ? this.value : null;

      }

      getOrUndefined() {

        return this.value;

      }

      each(worker) {

        if (this.tag) {

          worker(this.value);

        }

      }

      toArray() {

        return this.tag ? [this.value] : [];

      }

      toString() {

        return this.tag ? `some(${ this.value })` : 'none()';

      }

    }

    Optional.singletonNone = new Optional(false);

    typeof window !== 'undefined' ? window : Function('return this;')();

    const ELEMENT = 1;

    const name = element => {

      const r = element.dom.nodeName;

      return r.toLowerCase();

    };

    const has$1 = (element, key) => {

      const dom = element.dom;

      return dom && dom.hasAttribute ? dom.hasAttribute(key) : false;

    };

    var ClosestOrAncestor = (is, ancestor, scope, a, isRoot) => {

      if (is(scope, a)) {

        return Optional.some(scope);

      } else if (isFunction(isRoot) && isRoot(scope)) {

        return Optional.none();

      } else {

        return ancestor(scope, a, isRoot);

      }

    };

    const fromHtml = (html, scope) => {

      const doc = scope || document;

      const div = doc.createElement('div');

      div.innerHTML = html;

      if (!div.hasChildNodes() || div.childNodes.length > 1) {

        const message = 'HTML does not have a single root node';

        console.error(message, html);

        throw new Error(message);

      }

      return fromDom(div.childNodes[0]);

    };

    const fromTag = (tag, scope) => {

      const doc = scope || document;

      const node = doc.createElement(tag);

      return fromDom(node);

    };

    const fromText = (text, scope) => {

      const doc = scope || document;

      const node = doc.createTextNode(text);

      return fromDom(node);

    };

    const fromDom = node => {

      if (node === null || node === undefined) {

        throw new Error('Node cannot be null or undefined');

      }

      return { dom: node };

    };

    const fromPoint = (docElm, x, y) => Optional.from(docElm.dom.elementFromPoint(x, y)).map(fromDom);

    const SugarElement = {

      fromHtml,

      fromTag,

      fromText,

      fromDom,

      fromPoint

    };

    const is = (element, selector) => {

      const dom = element.dom;

      if (dom.nodeType !== ELEMENT) {

        return false;

      } else {

        const elem = dom;

        if (elem.matches !== undefined) {

          return elem.matches(selector);

        } else if (elem.msMatchesSelector !== undefined) {

          return elem.msMatchesSelector(selector);

        } else if (elem.webkitMatchesSelector !== undefined) {

          return elem.webkitMatchesSelector(selector);

        } else if (elem.mozMatchesSelector !== undefined) {

          return elem.mozMatchesSelector(selector);

        } else {

          throw new Error('Browser lacks native selectors');

        }

      }

    };

    const ancestor$1 = (scope, predicate, isRoot) => {

      let element = scope.dom;

      const stop = isFunction(isRoot) ? isRoot : never;

      while (element.parentNode) {

        element = element.parentNode;

        const el = SugarElement.fromDom(element);

        if (predicate(el)) {

          return Optional.some(el);

        } else if (stop(el)) {

          break;

        }

      }

      return Optional.none();

    };

    const closest$2 = (scope, predicate, isRoot) => {

      const is = (s, test) => test(s);

      return ClosestOrAncestor(is, ancestor$1, scope, predicate, isRoot);

    };

    const closest$1 = (scope, predicate, isRoot) => closest$2(scope, predicate, isRoot).isSome();

    const ancestor = (scope, selector, isRoot) => ancestor$1(scope, e => is(e, selector), isRoot);

    const closest = (scope, selector, isRoot) => {

      const is$1 = (element, selector) => is(element, selector);

      return ClosestOrAncestor(is$1, ancestor, scope, selector, isRoot);

    };

    const addToEditor$1 = editor => {

      const insertToolbarItems = getInsertToolbarItems(editor);

      if (insertToolbarItems.length > 0) {

        editor.ui.registry.addContextToolbar('quickblock', {

          predicate: node => {

            const sugarNode = SugarElement.fromDom(node);

            const textBlockElementsMap = editor.schema.getTextBlockElements();

            const isRoot = elem => elem.dom === editor.getBody();

            return !has$1(sugarNode, 'data-mce-bogus') && closest(sugarNode, 'table,[data-mce-bogus="all"]', isRoot).fold(() => closest$1(sugarNode, elem => name(elem) in textBlockElementsMap && editor.dom.isEmpty(elem.dom), isRoot), never);

          },

          items: insertToolbarItems,

          position: 'line',

          scope: 'editor'

        });

      }

    };

    const supports = element => element.dom.classList !== undefined;

    const has = (element, clazz) => supports(element) && element.dom.classList.contains(clazz);

    const addToEditor = editor => {

      const isEditable = node => editor.dom.isEditable(node);

      const isInEditableContext = el => isEditable(el.parentElement);

      const isImage = node => {

        const isImageFigure = node.nodeName === 'FIGURE' && /image/i.test(node.className);

        const isImage = node.nodeName === 'IMG' || isImageFigure;

        const isPagebreak = has(SugarElement.fromDom(node), 'mce-pagebreak');

        return isImage && isInEditableContext(node) && !isPagebreak;

      };

      const imageToolbarItems = getImageToolbarItems(editor);

      if (imageToolbarItems.length > 0) {

        editor.ui.registry.addContextToolbar('imageselection', {

          predicate: isImage,

          items: imageToolbarItems,

          position: 'node'

        });

      }

      const textToolbarItems = getTextSelectionToolbarItems(editor);

      if (textToolbarItems.length > 0) {

        editor.ui.registry.addContextToolbar('textselection', {

          predicate: node => !isImage(node) && !editor.selection.isCollapsed() && isEditable(node),

          items: textToolbarItems,

          position: 'selection',

          scope: 'editor'

        });

      }

    };

    var Plugin = () => {

      global$1.add('quickbars', editor => {

        register(editor);

        register$1(editor);

        setupButtons(editor);

        addToEditor$1(editor);

        addToEditor(editor);

      });

    };

    Plugin();

})();