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 eq = t => a => t === a;

    const isUndefined = eq(undefined);

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

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

    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);

    const constant = value => {

      return () => {

        return value;

      };

    };

    const never = constant(false);

    const findUntil = (xs, pred, until) => {

      for (let i = 0, len = xs.length; i < len; i++) {

        const x = xs[i];

        if (pred(x, i)) {

          return Optional.some(x);

        } else if (until(x, i)) {

          break;

        }

      }

      return Optional.none();

    };

    const find$1 = (xs, pred) => {

      return findUntil(xs, pred, never);

    };

    const findMap = (arr, f) => {

      for (let i = 0; i < arr.length; i++) {

        const r = f(arr[i], i);

        if (r.isSome()) {

          return r;

        }

      }

      return Optional.none();

    };

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

    const cached = f => {

      let called = false;

      let r;

      return (...args) => {

        if (!called) {

          called = true;

          r = f.apply(null, args);

        }

        return r;

      };

    };

    const DeviceType = (os, browser, userAgent, mediaMatch) => {

      const isiPad = os.isiOS() && /ipad/i.test(userAgent) === true;

      const isiPhone = os.isiOS() && !isiPad;

      const isMobile = os.isiOS() || os.isAndroid();

      const isTouch = isMobile || mediaMatch('(pointer:coarse)');

      const isTablet = isiPad || !isiPhone && isMobile && mediaMatch('(min-device-width:768px)');

      const isPhone = isiPhone || isMobile && !isTablet;

      const iOSwebview = browser.isSafari() && os.isiOS() && /safari/i.test(userAgent) === false;

      const isDesktop = !isPhone && !isTablet && !iOSwebview;

      return {

        isiPad: constant(isiPad),

        isiPhone: constant(isiPhone),

        isTablet: constant(isTablet),

        isPhone: constant(isPhone),

        isTouch: constant(isTouch),

        isAndroid: os.isAndroid,

        isiOS: os.isiOS,

        isWebView: constant(iOSwebview),

        isDesktop: constant(isDesktop)

      };

    };

    const firstMatch = (regexes, s) => {

      for (let i = 0; i < regexes.length; i++) {

        const x = regexes[i];

        if (x.test(s)) {

          return x;

        }

      }

      return undefined;

    };

    const find = (regexes, agent) => {

      const r = firstMatch(regexes, agent);

      if (!r) {

        return {

          major: 0,

          minor: 0

        };

      }

      const group = i => {

        return Number(agent.replace(r, '$' + i));

      };

      return nu$2(group(1), group(2));

    };

    const detect$3 = (versionRegexes, agent) => {

      const cleanedAgent = String(agent).toLowerCase();

      if (versionRegexes.length === 0) {

        return unknown$2();

      }

      return find(versionRegexes, cleanedAgent);

    };

    const unknown$2 = () => {

      return nu$2(0, 0);

    };

    const nu$2 = (major, minor) => {

      return {

        major,

        minor

      };

    };

    const Version = {

      nu: nu$2,

      detect: detect$3,

      unknown: unknown$2

    };

    const detectBrowser$1 = (browsers, userAgentData) => {

      return findMap(userAgentData.brands, uaBrand => {

        const lcBrand = uaBrand.brand.toLowerCase();

        return find$1(browsers, browser => {

          var _a;

          return lcBrand === ((_a = browser.brand) === null || _a === void 0 ? void 0 : _a.toLowerCase());

        }).map(info => ({

          current: info.name,

          version: Version.nu(parseInt(uaBrand.version, 10), 0)

        }));

      });

    };

    const detect$2 = (candidates, userAgent) => {

      const agent = String(userAgent).toLowerCase();

      return find$1(candidates, candidate => {

        return candidate.search(agent);

      });

    };

    const detectBrowser = (browsers, userAgent) => {

      return detect$2(browsers, userAgent).map(browser => {

        const version = Version.detect(browser.versionRegexes, userAgent);

        return {

          current: browser.name,

          version

        };

      });

    };

    const detectOs = (oses, userAgent) => {

      return detect$2(oses, userAgent).map(os => {

        const version = Version.detect(os.versionRegexes, userAgent);

        return {

          current: os.name,

          version

        };

      });

    };

    const contains = (str, substr, start = 0, end) => {

      const idx = str.indexOf(substr, start);

      if (idx !== -1) {

        return isUndefined(end) ? true : idx + substr.length <= end;

      } else {

        return false;

      }

    };

    const normalVersionRegex = /.*?version\/\ ?([0-9]+)\.([0-9]+).*/;

    const checkContains = target => {

      return uastring => {

        return contains(uastring, target);

      };

    };

    const browsers = [

      {

        name: 'Edge',

        versionRegexes: [/.*?edge\/ ?([0-9]+)\.([0-9]+)$/],

        search: uastring => {

          return contains(uastring, 'edge/') && contains(uastring, 'chrome') && contains(uastring, 'safari') && contains(uastring, 'applewebkit');

        }

      },

      {

        name: 'Chromium',

        brand: 'Chromium',

        versionRegexes: [

          /.*?chrome\/([0-9]+)\.([0-9]+).*/,

          normalVersionRegex

        ],

        search: uastring => {

          return contains(uastring, 'chrome') && !contains(uastring, 'chromeframe');

        }

      },

      {

        name: 'IE',

        versionRegexes: [

          /.*?msie\ ?([0-9]+)\.([0-9]+).*/,

          /.*?rv:([0-9]+)\.([0-9]+).*/

        ],

        search: uastring => {

          return contains(uastring, 'msie') || contains(uastring, 'trident');

        }

      },

      {

        name: 'Opera',

        versionRegexes: [

          normalVersionRegex,

          /.*?opera\/([0-9]+)\.([0-9]+).*/

        ],

        search: checkContains('opera')

      },

      {

        name: 'Firefox',

        versionRegexes: [/.*?firefox\/\ ?([0-9]+)\.([0-9]+).*/],

        search: checkContains('firefox')

      },

      {

        name: 'Safari',

        versionRegexes: [

          normalVersionRegex,

          /.*?cpu os ([0-9]+)_([0-9]+).*/

        ],

        search: uastring => {

          return (contains(uastring, 'safari') || contains(uastring, 'mobile/')) && contains(uastring, 'applewebkit');

        }

      }

    ];

    const oses = [

      {

        name: 'Windows',

        search: checkContains('win'),

        versionRegexes: [/.*?windows\ nt\ ?([0-9]+)\.([0-9]+).*/]

      },

      {

        name: 'iOS',

        search: uastring => {

          return contains(uastring, 'iphone') || contains(uastring, 'ipad');

        },

        versionRegexes: [

          /.*?version\/\ ?([0-9]+)\.([0-9]+).*/,

          /.*cpu os ([0-9]+)_([0-9]+).*/,

          /.*cpu iphone os ([0-9]+)_([0-9]+).*/

        ]

      },

      {

        name: 'Android',

        search: checkContains('android'),

        versionRegexes: [/.*?android\ ?([0-9]+)\.([0-9]+).*/]

      },

      {

        name: 'macOS',

        search: checkContains('mac os x'),

        versionRegexes: [/.*?mac\ os\ x\ ?([0-9]+)_([0-9]+).*/]

      },

      {

        name: 'Linux',

        search: checkContains('linux'),

        versionRegexes: []

      },

      {

        name: 'Solaris',

        search: checkContains('sunos'),

        versionRegexes: []

      },

      {

        name: 'FreeBSD',

        search: checkContains('freebsd'),

        versionRegexes: []

      },

      {

        name: 'ChromeOS',

        search: checkContains('cros'),

        versionRegexes: [/.*?chrome\/([0-9]+)\.([0-9]+).*/]

      }

    ];

    const PlatformInfo = {

      browsers: constant(browsers),

      oses: constant(oses)

    };

    const edge = 'Edge';

    const chromium = 'Chromium';

    const ie = 'IE';

    const opera = 'Opera';

    const firefox = 'Firefox';

    const safari = 'Safari';

    const unknown$1 = () => {

      return nu$1({

        current: undefined,

        version: Version.unknown()

      });

    };

    const nu$1 = info => {

      const current = info.current;

      const version = info.version;

      const isBrowser = name => () => current === name;

      return {

        current,

        version,

        isEdge: isBrowser(edge),

        isChromium: isBrowser(chromium),

        isIE: isBrowser(ie),

        isOpera: isBrowser(opera),

        isFirefox: isBrowser(firefox),

        isSafari: isBrowser(safari)

      };

    };

    const Browser = {

      unknown: unknown$1,

      nu: nu$1,

      edge: constant(edge),

      chromium: constant(chromium),

      ie: constant(ie),

      opera: constant(opera),

      firefox: constant(firefox),

      safari: constant(safari)

    };

    const windows = 'Windows';

    const ios = 'iOS';

    const android = 'Android';

    const linux = 'Linux';

    const macos = 'macOS';

    const solaris = 'Solaris';

    const freebsd = 'FreeBSD';

    const chromeos = 'ChromeOS';

    const unknown = () => {

      return nu({

        current: undefined,

        version: Version.unknown()

      });

    };

    const nu = info => {

      const current = info.current;

      const version = info.version;

      const isOS = name => () => current === name;

      return {

        current,

        version,

        isWindows: isOS(windows),

        isiOS: isOS(ios),

        isAndroid: isOS(android),

        isMacOS: isOS(macos),

        isLinux: isOS(linux),

        isSolaris: isOS(solaris),

        isFreeBSD: isOS(freebsd),

        isChromeOS: isOS(chromeos)

      };

    };

    const OperatingSystem = {

      unknown,

      nu,

      windows: constant(windows),

      ios: constant(ios),

      android: constant(android),

      linux: constant(linux),

      macos: constant(macos),

      solaris: constant(solaris),

      freebsd: constant(freebsd),

      chromeos: constant(chromeos)

    };

    const detect$1 = (userAgent, userAgentDataOpt, mediaMatch) => {

      const browsers = PlatformInfo.browsers();

      const oses = PlatformInfo.oses();

      const browser = userAgentDataOpt.bind(userAgentData => detectBrowser$1(browsers, userAgentData)).orThunk(() => detectBrowser(browsers, userAgent)).fold(Browser.unknown, Browser.nu);

      const os = detectOs(oses, userAgent).fold(OperatingSystem.unknown, OperatingSystem.nu);

      const deviceType = DeviceType(os, browser, userAgent, mediaMatch);

      return {

        browser,

        os,

        deviceType

      };

    };

    const PlatformDetection = { detect: detect$1 };

    const mediaMatch = query => window.matchMedia(query).matches;

    let platform = cached(() => PlatformDetection.detect(window.navigator.userAgent, Optional.from(window.navigator.userAgentData), mediaMatch));

    const detect = () => platform();

    const isMacOS = () => detect().os.isMacOS();

    const isiOS = () => detect().os.isiOS();

    const getPreventClicksOnLinksScript = () => {

      const isMacOSOrIOS = isMacOS() || isiOS();

      const fn = isMacOSOrIOS => {

        document.addEventListener('click', e => {

          for (let elm = e.target; elm; elm = elm.parentNode) {

            if (elm.nodeName === 'A') {

              const anchor = elm;

              const href = anchor.getAttribute('href');

              if (href && href.startsWith('#')) {

                e.preventDefault();

                const targetElement = document.getElementById(href.substring(1));

                if (targetElement) {

                  targetElement.scrollIntoView({ behavior: 'smooth' });

                }

                return;

              }

              const isMetaKeyPressed = isMacOSOrIOS ? e.metaKey : e.ctrlKey && !e.altKey;

              if (!isMetaKeyPressed) {

                e.preventDefault();

              }

            }

          }

        }, false);

      };

      return `<script>(${ fn.toString() })(${ isMacOSOrIOS })</script>`;

    };

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

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

    const getContentStyle = option('content_style');

    const shouldUseContentCssCors = option('content_css_cors');

    const getBodyClass = option('body_class');

    const getBodyId = option('body_id');

    const getPreviewHtml = editor => {

      var _a;

      let headHtml = '';

      const encode = editor.dom.encode;

      const contentStyle = (_a = getContentStyle(editor)) !== null && _a !== void 0 ? _a : '';

      headHtml += `<base href="${ encode(editor.documentBaseURI.getURI()) }">`;

      const cors = shouldUseContentCssCors(editor) ? ' crossorigin="anonymous"' : '';

      global.each(editor.contentCSS, url => {

        headHtml += '<link type="text/css" rel="stylesheet" href="' + encode(editor.documentBaseURI.toAbsolute(url)) + '"' + cors + '>';

      });

      if (contentStyle) {

        headHtml += '<style type="text/css">' + contentStyle + '</style>';

      }

      const bodyId = getBodyId(editor);

      const bodyClass = getBodyClass(editor);

      const directionality = editor.getBody().dir;

      const dirAttr = directionality ? ' dir="' + encode(directionality) + '"' : '';

      const previewHtml = '<!DOCTYPE html>' + '<html>' + '<head>' + headHtml + '</head>' + '<body id="' + encode(bodyId) + '" class="mce-content-body ' + encode(bodyClass) + '"' + dirAttr + '>' + editor.getContent() + getPreventClicksOnLinksScript() + '</body>' + '</html>';

      return previewHtml;

    };

    const open = editor => {

      const content = getPreviewHtml(editor);

      const dataApi = editor.windowManager.open({

        title: 'Preview',

        size: 'large',

        body: {

          type: 'panel',

          items: [{

              name: 'preview',

              type: 'iframe',

              sandboxed: true,

              transparent: false

            }]

        },

        buttons: [{

            type: 'cancel',

            name: 'close',

            text: 'Close',

            primary: true

          }],

        initialData: { preview: content }

      });

      dataApi.focus('close');

    };

    const register$1 = editor => {

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

        open(editor);

      });

    };

    const register = editor => {

      const onAction = () => editor.execCommand('mcePreview');

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

        icon: 'preview',

        tooltip: 'Preview',

        onAction,

        context: 'any'

      });

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

        icon: 'preview',

        text: 'Preview',

        onAction,

        context: 'any'

      });

    };

    var Plugin = () => {

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

        register$1(editor);

        register(editor);

      });

    };

    Plugin();

})();