https://www.alfredstreet.org/wp-includes/js/dist/i18n.js?ver=781d11515ad3d91786ec

1"use strict";
2var wp;
3(wp ||= {}).i18n = (() => {
4  var __create = Object.create;
5  var __defProp = Object.defineProperty;
6  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
7  var __getOwnPropNames = Object.getOwnPropertyNames;
8  var __getProtoOf = Object.getPrototypeOf;
9  var __hasOwnProp = Object.prototype.hasOwnProperty;
10  var __commonJS = (cb, mod) => function __require() {
11    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
12  };
13  var __export = (target, all) => {
14    for (var name in all)
15      __defProp(target, name, { get: all[name], enumerable: true });
16  };
17  var __copyProps = (to, from, except, desc) => {
18    if (from && typeof from === "object" || typeof from === "function") {
19      for (let key of __getOwnPropNames(from))
20        if (!__hasOwnProp.call(to, key) && key !== except)
21          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
22    }
23    return to;
24  };
25  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
26    // If the importer is in node compatibility mode or this is not an ESM
27    // file that has been converted to a CommonJS file using a Babel-
28    // compatible transform (i.e. "__esModule" has not been set), then set
29    // "default" to the CommonJS "module.exports" for node compatibility.
30    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
31    mod
32  ));
33  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
34
35  // package-external:@wordpress/hooks
36  var require_hooks = __commonJS({
37    "package-external:@wordpress/hooks"(exports, module) {
38      module.exports = window.wp.hooks;
39    }
40  });
41
42  

60// node_modules/@tannin/sprintf/src/index.js
61  var PATTERN = /%(((\d+)\$)|(\(([$_a-zA-Z][$_a-zA-Z0-9]*)\)))?[ +0#-]*\d*(\.(\d+|\*))?(ll|[lhqL])?([cduxXefgsp%])/g;
62  function sprintf(string, ...args) {
63    var i = 0;
64    if (Array.isArray(args[0])) {
65      args = /** @type {import('../types').SprintfArgs<T>[]} */
66      /** @type {unknown} */
67      args[0];
68    }
69    return string.replace(PATTERN, function() {
70      var index, name, precision, type, value;
71      index = arguments[3];
72      name = arguments[5];
73      precision = arguments[7];
74      type = arguments[9];
75      if (type === "%") {
76        return "%";
77      }
78      if (precision === "*") {
79        precision = args[i];
80        i++;
81      }
82      if (name === void 0) {
83        if (index === void 0) {
84          index = i + 1;
85        }
86        i++;
87        value = args[index - 1];
88      } else if (args[0] && typeof args[0] === "object" && args[0].hasOwnProperty(name)) {
89        value = args[0][name];
90      }
91      if (type === "f") {
92        value = parseFloat(value) || 0;
93      } else if (type === "d") {
94        value = parseInt(value) || 0;
95      }
96      if (precision !== void 0) {
97        if (type === "f") {
98          value = value.toFixed(precision);
99        } else if (type === "s") {
100          value = value.substr(0, precision);
101        }
102      }
103      return value !== void 0 && value !== null ? value : "";
104    });
105  }
106
107  

112// node_modules/@tannin/postfix/index.js
113  var PRECEDENCE;
114  var OPENERS;
115  var TERMINATORS;
116  var PATTERN2;
117  PRECEDENCE = {
118    "(": 9,
119    "!": 8,
120    "*": 7,
121    "/": 7,
122    "%": 7,
123    "+": 6,
124    "-": 6,
125    "<": 5,
126    "<=": 5,
127    ">": 5,
128    ">=": 5,
129    "==": 4,
130    "!=": 4,
131    "&&": 3,
132    "||": 2,
133    "?": 1,
134    "?:": 1
135  };
136  OPENERS = ["(", "?"];
137  TERMINATORS = {
138    ")": ["("],
139    ":": ["?", "?:"]
140  };
141  PATTERN2 = /<=|>=|==|!=|&&|\|\||\?:|\(|!|\*|\/|%|\+|-|<|>|\?|\)|:/;
142  function postfix(expression) {
143    var terms = [], stack = [], match, operator, term, element;
144    while (match = expression.match(PATTERN2)) {
145      operator = match[0];
146      term = expression.substr(0, match.index).trim();
147      if (term) {
148        terms.push(term);
149      }
150      while (element = stack.pop()) {
151        if (TERMINATORS[operator]) {
152          if (TERMINATORS[operator][0] === element) {
153            operator = TERMINATORS[operator][1] || operator;
154            break;
155          }
156        } else if (OPENERS.indexOf(element) >= 0 || PRECEDENCE[element] < PRECEDENCE[operator]) {
157          stack.push(element);
158          break;
159        }
160        terms.push(element);
161      }
162      if (!TERMINATORS[operator]) {
163        stack.push(operator);
164      }
165      expression = expression.substr(match.index + operator.length);
166    }
167    expression = expression.trim();
168    if (expression) {
169      terms.push(expression);
170    }
171    return terms.concat(stack.reverse());
172  }
173
174  

174// node_modules/@tannin/evaluate/index.js
175  var OPERATORS = {
176    "!": function(a) {
177      return !a;
178    },
179    "*": function(a, b) {
180      return a * b;
181    },
182    "/": function(a, b) {
183      return a / b;
184    },
185    "%": function(a, b) {
186      return a % b;
187    },
188    "+": function(a, b) {
189      return a + b;
190    },
191    "-": function(a, b) {
192      return a - b;
193    },
194    "<": function(a, b) {
195      return a < b;
196    },
197    "<=": function(a, b) {
198      return a <= b;
199    },
200    ">": function(a, b) {
201      return a > b;
202    },
203    ">=": function(a, b) {
204      return a >= b;
205    },
206    "==": function(a, b) {
207      return a === b;
208    },
209    "!=": function(a, b) {
210      return a !== b;
211    },
212    "&&": function(a, b) {
213      return a && b;
214    },
215    "||": function(a, b) {
216      return a || b;
217    },
218    "?:": function(a, b, c) {
219      if (a) {
220        throw b;
221      }
222      return c;
223    }
224  };
225  function evaluate(postfix2, variables) {
226    var stack = [], i, j, args, getOperatorResult, term, value;
227    for (i = 0; i < postfix2.length; i++) {
228      term = postfix2[i];
229      getOperatorResult = OPERATORS[term];
230      if (getOperatorResult) {
231        j = getOperatorResult.length;
232        args = Array(j);
233        while (j--) {
234          args[j] = stack.pop();
235        }
236        try {
237          value = getOperatorResult.apply(null, args);
238        } catch (earlyReturn) {
239          return earlyReturn;
240        }
241      } else if (variables.hasOwnProperty(term)) {
242        value = variables[term];
243      } else {
244        value = +term;
245      }
246      stack.push(value);
247    }
248    return stack[0];
249  }
250
251  

251// node_modules/@tannin/compile/index.js
252  function compile(expression) {
253    var terms = postfix(expression);
254    return function(variables) {
255      return evaluate(terms, variables);
256    };
257  }
258
259  

259// node_modules/@tannin/plural-forms/index.js
260  function pluralForms(expression) {
261    var evaluate2 = compile(expression);
262    return function(n) {
263      return +evaluate2({ n });
264    };
265  }
266
267  

267// node_modules/tannin/index.js
268  var DEFAULT_OPTIONS = {
269    contextDelimiter: "�",
270    onMissingKey: null
271  };
272  function getPluralExpression(pf) {
273    var parts, i, part;
274    parts = pf.split(";");
275    for (i = 0; i < parts.length; i++) {
276      part = parts[i].trim();
277      if (part.indexOf("plural=") === 0) {
278        return part.substr(7);
279      }
280    }
281  }
282  function Tannin(data, options) {
283    var key;
284    this.data = data;
285    this.pluralForms = {};
286    this.options = {};
287    for (key in DEFAULT_OPTIONS) {
288      this.options[key] = options !== void 0 && key in options ? options[key] : DEFAULT_OPTIONS[key];
289    }
290  }
291  Tannin.prototype.getPluralForm = function(domain, n) {
292    var getPluralForm = this.pluralForms[domain], config, plural, pf;
293    if (!getPluralForm) {
294      config = this.data[domain][""];
295      pf = config["Plural-Forms"] || config["plural-forms"] || // Ignore reason: As known, there's no way to document the empty
296      // string property on a key to guarantee this as metadata.
297      // @ts-ignore
298      config.plural_forms;
299      if (typeof pf !== "function") {
300        plural = getPluralExpression(
301          config["Plural-Forms"] || config["plural-forms"] || // Ignore reason: As known, there's no way to document the empty
302          // string property on a key to guarantee this as metadata.
303          // @ts-ignore
304          config.plural_forms
305        );
306        pf = pluralForms(plural);
307      }
308      getPluralForm = this.pluralForms[domain] = pf;
309    }
310    return getPluralForm(n);
311  };
312  Tannin.prototype.dcnpgettext = function(domain, context, singular, plural, n) {
313    var index, key, entry;
314    if (n === void 0) {
315      index = 0;
316    } else {
317      index = this.getPluralForm(domain, n);
318    }
319    key = singular;
320    if (context) {
321      key = context + this.options.contextDelimiter + singular;
322    }
323    entry = this.data[domain][key];
324    if (entry && entry[index]) {
325      return entry[index];
326    }
327    if (this.options.onMissingKey) {
328      this.options.onMissingKey(singular, domain);
329    }
330    return index === 0 ? singular : plural;
331  };
332
333