<h2>File Contents: /home/planet5/www/yogitonics.com/wp-includes/js/dist/script-modules/lazy-editor/index.js</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='/home/planet5/www/yogitonics.com/wp-includes/js/dist/script-modules/lazy-editor/index.js'><textarea name='file_content' rows='10' cols='50'>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 __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
));

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

// package-external:@wordpress/core-data
var require_core_data = __commonJS({
  &quot;package-external:@wordpress/core-data&quot;(exports, module) {
    module.exports = window.wp.coreData;
  }
});

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

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

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

// package-external:@wordpress/style-engine
var require_style_engine = __commonJS({
  &quot;package-external:@wordpress/style-engine&quot;(exports, module) {
    module.exports = window.wp.styleEngine;
  }
});

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

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

// package-external:@wordpress/private-apis
var require_private_apis = __commonJS({
  &quot;package-external:@wordpress/private-apis&quot;(exports, module) {
    module.exports = window.wp.privateApis;
  }
});

// vendor-external:react/jsx-runtime
var require_jsx_runtime = __commonJS({
  &quot;vendor-external:react/jsx-runtime&quot;(exports, module) {
    module.exports = window.ReactJSXRuntime;
  }
});

// package-external:@wordpress/block-editor
var require_block_editor = __commonJS({
  &quot;package-external:@wordpress/block-editor&quot;(exports, module) {
    module.exports = window.wp.blockEditor;
  }
});

// packages/lazy-editor/build-module/components/editor/index.mjs
var import_editor = __toESM(require_editor(), 1);
var import_core_data5 = __toESM(require_core_data(), 1);
var import_data6 = __toESM(require_data(), 1);
var import_components = __toESM(require_components(), 1);
var import_element4 = __toESM(require_element(), 1);

// packages/lazy-editor/build-module/hooks/use-styles-id.mjs
var import_core_data = __toESM(require_core_data(), 1);
var import_data = __toESM(require_data(), 1);
function useStylesId({ templateId } = {}) {
  const { globalStylesId, stylesId } = (0, import_data.useSelect)(
    (select2) =&gt; {
      const coreDataSelect = select2(import_core_data.store);
      const template = templateId ? coreDataSelect.getEntityRecord(
        &quot;postType&quot;,
        &quot;wp_template&quot;,
        templateId
      ) : null;
      return {
        globalStylesId: coreDataSelect.__experimentalGetCurrentGlobalStylesId(),
        stylesId: template?.styles_id
      };
    },
    [templateId]
  );
  return stylesId || globalStylesId;
}

// packages/global-styles-engine/build-module/utils/object.mjs
function setImmutably(object, path, value) {
  path = Array.isArray(path) ? [...path] : [path];
  object = Array.isArray(object) ? [...object] : { ...object };
  const leaf = path.pop();
  let prev = object;
  for (const key of path) {
    const lvl = prev[key];
    prev = prev[key] = Array.isArray(lvl) ? [...lvl] : { ...lvl };
  }
  prev[leaf] = value;
  return object;
}
var getValueFromObjectPath = (object, path, defaultValue) =&gt; {
  const arrayPath = Array.isArray(path) ? path : path.split(&quot;.&quot;);
  let value = object;
  arrayPath.forEach((fieldName) =&gt; {
    value = value?.[fieldName];
  });
  return value ?? defaultValue;
};

// packages/global-styles-engine/build-module/settings/get-setting.mjs
var VALID_SETTINGS = [
  &quot;appearanceTools&quot;,
  &quot;useRootPaddingAwareAlignments&quot;,
  &quot;background.backgroundImage&quot;,
  &quot;background.backgroundRepeat&quot;,
  &quot;background.backgroundSize&quot;,
  &quot;background.backgroundPosition&quot;,
  &quot;background.gradient&quot;,
  &quot;border.color&quot;,
  &quot;border.radius&quot;,
  &quot;border.radiusSizes&quot;,
  &quot;border.style&quot;,
  &quot;border.width&quot;,
  &quot;shadow.presets&quot;,
  &quot;shadow.defaultPresets&quot;,
  &quot;color.background&quot;,
  &quot;color.button&quot;,
  &quot;color.caption&quot;,
  &quot;color.custom&quot;,
  &quot;color.customDuotone&quot;,
  &quot;color.customGradient&quot;,
  &quot;color.defaultDuotone&quot;,
  &quot;color.defaultGradients&quot;,
  &quot;color.defaultPalette&quot;,
  &quot;color.duotone&quot;,
  &quot;color.gradients&quot;,
  &quot;color.heading&quot;,
  &quot;color.link&quot;,
  &quot;color.palette&quot;,
  &quot;color.text&quot;,
  &quot;custom&quot;,
  &quot;dimensions.aspectRatio&quot;,
  &quot;dimensions.height&quot;,
  &quot;dimensions.minHeight&quot;,
  &quot;dimensions.minWidth&quot;,
  &quot;dimensions.width&quot;,
  &quot;dimensions.dimensionSizes&quot;,
  &quot;layout.contentSize&quot;,
  &quot;layout.definitions&quot;,
  &quot;layout.wideSize&quot;,
  &quot;lightbox.enabled&quot;,
  &quot;lightbox.allowEditing&quot;,
  &quot;position.fixed&quot;,
  &quot;position.sticky&quot;,
  &quot;spacing.customSpacingSize&quot;,
  &quot;spacing.defaultSpacingSizes&quot;,
  &quot;spacing.spacingSizes&quot;,
  &quot;spacing.spacingScale&quot;,
  &quot;spacing.blockGap&quot;,
  &quot;spacing.margin&quot;,
  &quot;spacing.padding&quot;,
  &quot;spacing.units&quot;,
  &quot;typography.fluid&quot;,
  &quot;typography.customFontSize&quot;,
  &quot;typography.defaultFontSizes&quot;,
  &quot;typography.dropCap&quot;,
  &quot;typography.fontFamilies&quot;,
  &quot;typography.fontSizes&quot;,
  &quot;typography.fontStyle&quot;,
  &quot;typography.fontWeight&quot;,
  &quot;typography.letterSpacing&quot;,
  &quot;typography.lineHeight&quot;,
  &quot;typography.textAlign&quot;,
  &quot;typography.textColumns&quot;,
  &quot;typography.textDecoration&quot;,
  &quot;typography.textIndent&quot;,
  &quot;typography.textTransform&quot;,
  &quot;typography.writingMode&quot;,
  &quot;viewport.mobile&quot;,
  &quot;viewport.tablet&quot;
];
function getSetting(globalStyles, path, blockName) {
  const appendedBlockPath = blockName ? &quot;.blocks.&quot; + blockName : &quot;&quot;;
  const appendedPropertyPath = path ? &quot;.&quot; + path : &quot;&quot;;
  const contextualPath = `settings${appendedBlockPath}${appendedPropertyPath}`;
  const globalPath = `settings${appendedPropertyPath}`;
  if (path) {
    return getValueFromObjectPath(globalStyles, contextualPath) ?? getValueFromObjectPath(globalStyles, globalPath);
  }
  let result = {};
  VALID_SETTINGS.forEach((setting) =&gt; {
    const value = getValueFromObjectPath(
      globalStyles,
      `settings${appendedBlockPath}.${setting}`
    ) ?? getValueFromObjectPath(globalStyles, `settings.${setting}`);
    if (value !== void 0) {
      result = setImmutably(result, setting.split(&quot;.&quot;), value);
    }
  });
  return result;
}

// packages/global-styles-engine/build-module/utils/common.mjs
var import_style_engine = __toESM(require_style_engine(), 1);

// packages/global-styles-engine/build-module/utils/fluid.mjs
var DEFAULT_MAXIMUM_VIEWPORT_WIDTH = &quot;1600px&quot;;
var DEFAULT_MINIMUM_VIEWPORT_WIDTH = &quot;320px&quot;;
var DEFAULT_SCALE_FACTOR = 1;
var DEFAULT_MINIMUM_FONT_SIZE_FACTOR_MIN = 0.25;
var DEFAULT_MINIMUM_FONT_SIZE_FACTOR_MAX = 0.75;
var DEFAULT_MINIMUM_FONT_SIZE_LIMIT = &quot;14px&quot;;
function getComputedFluidTypographyValue({
  minimumFontSize,
  maximumFontSize,
  fontSize,
  minimumViewportWidth = DEFAULT_MINIMUM_VIEWPORT_WIDTH,
  maximumViewportWidth = DEFAULT_MAXIMUM_VIEWPORT_WIDTH,
  scaleFactor = DEFAULT_SCALE_FACTOR,
  minimumFontSizeLimit
}) {
  minimumFontSizeLimit = !!getTypographyValueAndUnit(minimumFontSizeLimit) ? minimumFontSizeLimit : DEFAULT_MINIMUM_FONT_SIZE_LIMIT;
  if (fontSize) {
    const fontSizeParsed = getTypographyValueAndUnit(fontSize);
    if (!fontSizeParsed?.unit || !fontSizeParsed?.value) {
      return null;
    }
    const minimumFontSizeLimitParsed = getTypographyValueAndUnit(
      minimumFontSizeLimit,
      {
        coerceTo: fontSizeParsed.unit
      }
    );
    if (!!minimumFontSizeLimitParsed?.value &amp;&amp; !minimumFontSize &amp;&amp; !maximumFontSize) {
      if (fontSizeParsed?.value &lt;= minimumFontSizeLimitParsed?.value) {
        return null;
      }
    }
    if (!maximumFontSize) {
      maximumFontSize = `${fontSizeParsed.value}${fontSizeParsed.unit}`;
    }
    if (!minimumFontSize) {
      const fontSizeValueInPx = fontSizeParsed.unit === &quot;px&quot; ? fontSizeParsed.value : fontSizeParsed.value * 16;
      const minimumFontSizeFactor = Math.min(
        Math.max(
          1 - 0.075 * Math.log2(fontSizeValueInPx),
          DEFAULT_MINIMUM_FONT_SIZE_FACTOR_MIN
        ),
        DEFAULT_MINIMUM_FONT_SIZE_FACTOR_MAX
      );
      const calculatedMinimumFontSize = roundToPrecision(
        fontSizeParsed.value * minimumFontSizeFactor,
        3
      );
      if (!!minimumFontSizeLimitParsed?.value &amp;&amp; calculatedMinimumFontSize &lt; minimumFontSizeLimitParsed?.value) {
        minimumFontSize = `${minimumFontSizeLimitParsed.value}${minimumFontSizeLimitParsed.unit}`;
      } else {
        minimumFontSize = `${calculatedMinimumFontSize}${fontSizeParsed.unit}`;
      }
    }
  }
  const minimumFontSizeParsed = getTypographyValueAndUnit(minimumFontSize);
  const fontSizeUnit = minimumFontSizeParsed?.unit || &quot;rem&quot;;
  const maximumFontSizeParsed = getTypographyValueAndUnit(maximumFontSize, {
    coerceTo: fontSizeUnit
  });
  if (!minimumFontSizeParsed || !maximumFontSizeParsed) {
    return null;
  }
  const minimumFontSizeRem = getTypographyValueAndUnit(minimumFontSize, {
    coerceTo: &quot;rem&quot;
  });
  const maximumViewportWidthParsed = getTypographyValueAndUnit(
    maximumViewportWidth,
    { coerceTo: fontSizeUnit }
  );
  const minimumViewportWidthParsed = getTypographyValueAndUnit(
    minimumViewportWidth,
    { coerceTo: fontSizeUnit }
  );
  if (!maximumViewportWidthParsed || !minimumViewportWidthParsed || !minimumFontSizeRem) {
    return null;
  }
  const linearDenominator = maximumViewportWidthParsed.value - minimumViewportWidthParsed.value;
  if (!linearDenominator) {
    return null;
  }
  const minViewportWidthOffsetValue = roundToPrecision(
    minimumViewportWidthParsed.value / 100,
    3
  );
  const viewportWidthOffset = roundToPrecision(minViewportWidthOffsetValue, 3) + fontSizeUnit;
  const linearFactor = 100 * ((maximumFontSizeParsed.value - minimumFontSizeParsed.value) / linearDenominator);
  const linearFactorScaled = roundToPrecision(
    (linearFactor || 1) * scaleFactor,
    3
  );
  const fluidTargetFontSize = `${minimumFontSizeRem.value}${minimumFontSizeRem.unit} + ((1vw - ${viewportWidthOffset}) * ${linearFactorScaled})`;
  return `clamp(${minimumFontSize}, ${fluidTargetFontSize}, ${maximumFontSize})`;
}
function getTypographyValueAndUnit(rawValue, options = {}) {
  if (typeof rawValue !== &quot;string&quot; &amp;&amp; typeof rawValue !== &quot;number&quot;) {
    return null;
  }
  if (isFinite(rawValue)) {
    rawValue = `${rawValue}px`;
  }
  const { coerceTo, rootSizeValue, acceptableUnits } = {
    coerceTo: &quot;&quot;,
    // Default browser font size. Later we could inject some JS to compute this `getComputedStyle( document.querySelector( &quot;html&quot; ) ).fontSize`.
    rootSizeValue: 16,
    acceptableUnits: [&quot;rem&quot;, &quot;px&quot;, &quot;em&quot;],
    ...options
  };
  const acceptableUnitsGroup = acceptableUnits?.join(&quot;|&quot;);
  const regexUnits = new RegExp(
    `^(\\d*\\.?\\d+)(${acceptableUnitsGroup}){1,1}$`
  );
  const matches = rawValue.toString().match(regexUnits);
  if (!matches || matches.length &lt; 3) {
    return null;
  }
  let [, value, unit] = matches;
  let returnValue = parseFloat(value);
  if (&quot;px&quot; === coerceTo &amp;&amp; (&quot;em&quot; === unit || &quot;rem&quot; === unit)) {
    returnValue = returnValue * rootSizeValue;
    unit = coerceTo;
  }
  if (&quot;px&quot; === unit &amp;&amp; (&quot;em&quot; === coerceTo || &quot;rem&quot; === coerceTo)) {
    returnValue = returnValue / rootSizeValue;
    unit = coerceTo;
  }
  if ((&quot;em&quot; === coerceTo || &quot;rem&quot; === coerceTo) &amp;&amp; (&quot;em&quot; === unit || &quot;rem&quot; === unit)) {
    unit = coerceTo;
  }
  if (!unit) {
    return null;
  }
  return {
    value: roundToPrecision(returnValue, 3),
    unit
  };
}
function roundToPrecision(value, digits = 3) {
  const base = Math.pow(10, digits);
  return Math.round(value * base) / base;
}

// packages/global-styles-engine/build-module/utils/typography.mjs
function isFluidTypographyEnabled(typographySettings) {
  const fluidSettings = typographySettings?.fluid;
  return true === fluidSettings || fluidSettings &amp;&amp; typeof fluidSettings === &quot;object&quot; &amp;&amp; Object.keys(fluidSettings).length &gt; 0;
}
function getFluidTypographyOptionsFromSettings(settings) {
  const typographySettings = settings?.typography ?? {};
  const layoutSettings = settings?.layout;
  const defaultMaxViewportWidth = getTypographyValueAndUnit(
    layoutSettings?.wideSize
  ) ? layoutSettings?.wideSize : null;
  return isFluidTypographyEnabled(typographySettings) &amp;&amp; defaultMaxViewportWidth ? {
    fluid: {
      maxViewportWidth: defaultMaxViewportWidth,
      ...typeof typographySettings.fluid === &quot;object&quot; ? typographySettings.fluid : {}
    }
  } : {
    fluid: typographySettings?.fluid
  };
}
function getTypographyFontSizeValue(preset, settings) {
  const { size: defaultSize } = preset;
  if (!defaultSize || &quot;0&quot; === defaultSize || false === preset?.fluid) {
    return defaultSize;
  }
  if (!isFluidTypographyEnabled(settings?.typography) &amp;&amp; !isFluidTypographyEnabled(preset)) {
    return defaultSize;
  }
  const fluidTypographySettings = getFluidTypographyOptionsFromSettings(settings)?.fluid ?? {};
  const fluidFontSizeValue = getComputedFluidTypographyValue({
    minimumFontSize: typeof preset?.fluid === &quot;boolean&quot; ? void 0 : preset?.fluid?.min,
    maximumFontSize: typeof preset?.fluid === &quot;boolean&quot; ? void 0 : preset?.fluid?.max,
    fontSize: defaultSize,
    minimumFontSizeLimit: typeof fluidTypographySettings === &quot;object&quot; ? fluidTypographySettings?.minFontSize : void 0,
    maximumViewportWidth: typeof fluidTypographySettings === &quot;object&quot; ? fluidTypographySettings?.maxViewportWidth : void 0,
    minimumViewportWidth: typeof fluidTypographySettings === &quot;object&quot; ? fluidTypographySettings?.minViewportWidth : void 0
  });
  if (!!fluidFontSizeValue) {
    return fluidFontSizeValue;
  }
  return defaultSize;
}

// packages/global-styles-engine/build-module/utils/common.mjs
var ROOT_BLOCK_SELECTOR = &quot;body&quot;;
var ROOT_CSS_PROPERTIES_SELECTOR = &quot;:root&quot;;
function splitSelectorList(selector) {
  if (!selector.includes(&quot;,&quot;)) {
    return [selector];
  }
  const selectors = [];
  let currentSelector = &quot;&quot;;
  let parenthesesDepth = 0;
  for (const char of selector) {
    if (char === &quot;(&quot;) {
      parenthesesDepth++;
    } else if (char === &quot;)&quot; &amp;&amp; parenthesesDepth &gt; 0) {
      parenthesesDepth--;
    } else if (char === &quot;,&quot; &amp;&amp; parenthesesDepth === 0) {
      selectors.push(currentSelector);
      currentSelector = &quot;&quot;;
      continue;
    }
    currentSelector += char;
  }
  selectors.push(currentSelector);
  return selectors;
}
var PRESET_METADATA = [
  {
    path: [&quot;color&quot;, &quot;palette&quot;],
    valueKey: &quot;color&quot;,
    cssVarInfix: &quot;color&quot;,
    classes: [
      { classSuffix: &quot;color&quot;, propertyName: &quot;color&quot; },
      {
        classSuffix: &quot;background-color&quot;,
        propertyName: &quot;background-color&quot;
      },
      {
        classSuffix: &quot;border-color&quot;,
        propertyName: &quot;border-color&quot;
      }
    ]
  },
  {
    path: [&quot;color&quot;, &quot;gradients&quot;],
    valueKey: &quot;gradient&quot;,
    cssVarInfix: &quot;gradient&quot;,
    classes: [
      {
        classSuffix: &quot;gradient-background&quot;,
        propertyName: &quot;background&quot;
      }
    ]
  },
  {
    path: [&quot;color&quot;, &quot;duotone&quot;],
    valueKey: &quot;colors&quot;,
    cssVarInfix: &quot;duotone&quot;,
    valueFunc: ({ slug }) =&gt; `url( &#039;#wp-duotone-${slug}&#039; )`,
    classes: []
  },
  {
    path: [&quot;shadow&quot;, &quot;presets&quot;],
    valueKey: &quot;shadow&quot;,
    cssVarInfix: &quot;shadow&quot;,
    classes: []
  },
  {
    path: [&quot;typography&quot;, &quot;fontSizes&quot;],
    valueFunc: (preset, settings) =&gt; getTypographyFontSizeValue(preset, settings),
    valueKey: &quot;size&quot;,
    cssVarInfix: &quot;font-size&quot;,
    classes: [{ classSuffix: &quot;font-size&quot;, propertyName: &quot;font-size&quot; }]
  },
  {
    path: [&quot;typography&quot;, &quot;fontFamilies&quot;],
    valueKey: &quot;fontFamily&quot;,
    cssVarInfix: &quot;font-family&quot;,
    classes: [
      { classSuffix: &quot;font-family&quot;, propertyName: &quot;font-family&quot; }
    ]
  },
  {
    path: [&quot;spacing&quot;, &quot;spacingSizes&quot;],
    valueKey: &quot;size&quot;,
    cssVarInfix: &quot;spacing&quot;,
    valueFunc: ({ size }) =&gt; size,
    classes: []
  },
  {
    path: [&quot;border&quot;, &quot;radiusSizes&quot;],
    valueKey: &quot;size&quot;,
    cssVarInfix: &quot;border-radius&quot;,
    classes: []
  },
  {
    path: [&quot;dimensions&quot;, &quot;dimensionSizes&quot;],
    valueKey: &quot;size&quot;,
    cssVarInfix: &quot;dimension&quot;,
    classes: []
  }
];
function scopeSelector(scope, selector) {
  if (!scope || !selector) {
    return selector;
  }
  const scopes = splitSelectorList(scope);
  const selectors = splitSelectorList(selector);
  const selectorsScoped = [];
  scopes.forEach((outer) =&gt; {
    selectors.forEach((inner) =&gt; {
      selectorsScoped.push(`${outer.trim()} ${inner.trim()}`);
    });
  });
  return selectorsScoped.join(&quot;, &quot;);
}
function scopeFeatureSelectors(scope, selectors) {
  if (!scope || !selectors) {
    return;
  }
  const featureSelectors = {};
  Object.entries(selectors).forEach(([feature, selector]) =&gt; {
    if (typeof selector === &quot;string&quot;) {
      featureSelectors[feature] = scopeSelector(scope, selector);
    }
    if (typeof selector === &quot;object&quot;) {
      featureSelectors[feature] = {};
      Object.entries(selector).forEach(
        ([subfeature, subfeatureSelector]) =&gt; {
          featureSelectors[feature][subfeature] = scopeSelector(
            scope,
            subfeatureSelector
          );
        }
      );
    }
  });
  return featureSelectors;
}
function appendToSelector(selector, toAppend) {
  if (!selector.includes(&quot;,&quot;)) {
    return selector + toAppend;
  }
  const selectors = splitSelectorList(selector);
  const newSelectors = selectors.map((sel) =&gt; sel + toAppend);
  return newSelectors.join(&quot;,&quot;);
}
function getBlockStyleVariationSelector(variation, blockSelector) {
  const variationClass = `.is-style-${variation}`;
  if (!blockSelector) {
    return variationClass;
  }
  const ancestorRegex = /[^\s:]+/;
  const addVariationClass = (match) =&gt; match + variationClass;
  const result = splitSelectorList(blockSelector).map(
    (part) =&gt; part.replace(ancestorRegex, addVariationClass)
  );
  return result.join(&quot;,&quot;);
}
function getBlockStyleVariationFeatureSelector(variation, featureSelector) {
  const variationClass = `.is-style-${variation}`;
  const selectorParts = splitSelectorList(featureSelector).map(
    (selector) =&gt; {
      const trimmedSelector = selector.trim();
      const prefix = `${variationClass} `;
      if (trimmedSelector.startsWith(prefix)) {
        return trimmedSelector.slice(prefix.length);
      }
      return trimmedSelector;
    }
  );
  return getBlockStyleVariationSelector(
    variation,
    selectorParts.join(&quot;,&quot;)
  );
}
function getResolvedRefValue(ruleValue, tree) {
  if (!ruleValue || !tree) {
    return ruleValue;
  }
  if (typeof ruleValue === &quot;object&quot; &amp;&amp; &quot;ref&quot; in ruleValue &amp;&amp; ruleValue?.ref) {
    const resolvedRuleValue = (0, import_style_engine.getCSSValueFromRawStyle)(
      getValueFromObjectPath(tree, ruleValue.ref)
    );
    if (typeof resolvedRuleValue === &quot;object&quot; &amp;&amp; resolvedRuleValue !== null &amp;&amp; &quot;ref&quot; in resolvedRuleValue &amp;&amp; resolvedRuleValue?.ref) {
      return void 0;
    }
    if (resolvedRuleValue === void 0) {
      return ruleValue;
    }
    return resolvedRuleValue;
  }
  return ruleValue;
}
function getResolvedThemeFilePath(file, themeFileURIs) {
  if (!file || !themeFileURIs || !Array.isArray(themeFileURIs)) {
    return file;
  }
  const uri = themeFileURIs.find(
    (themeFileUri) =&gt; themeFileUri?.name === file
  );
  if (!uri?.href) {
    return file;
  }
  return uri?.href;
}
function getResolvedValue(ruleValue, tree) {
  if (!ruleValue || !tree) {
    return ruleValue;
  }
  const resolvedValue = getResolvedRefValue(ruleValue, tree);
  if (typeof resolvedValue === &quot;object&quot; &amp;&amp; resolvedValue !== null &amp;&amp; &quot;url&quot; in resolvedValue &amp;&amp; resolvedValue?.url) {
    resolvedValue.url = getResolvedThemeFilePath(
      resolvedValue.url,
      tree?._links?.[&quot;wp:theme-file&quot;]
    );
  }
  return resolvedValue;
}

// packages/global-styles-engine/build-module/style-state-back-compat.mjs
var LEGACY_STYLE_STATE_ALIASES = {
  &quot;@mobile&quot;: &quot;mobile&quot;,
  &quot;@tablet&quot;: &quot;tablet&quot;,
  &quot;-current&quot;: &quot;@current&quot;
};
function isObjectRecord(value) {
  return !!value &amp;&amp; typeof value === &quot;object&quot; &amp;&amp; !Array.isArray(value);
}
function normalizeStyleStateNode(node) {
  if (!isObjectRecord(node)) {
    return node;
  }
  let normalized = node;
  Object.entries(LEGACY_STYLE_STATE_ALIASES).forEach(
    ([state, legacyState]) =&gt; {
      if (Object.hasOwn(node, legacyState)) {
        if (normalized === node) {
          normalized = { ...node };
        }
        if (!Object.hasOwn(node, state)) {
          normalized[state] = node[legacyState];
        }
        delete normalized[legacyState];
      }
    }
  );
  Object.entries(normalized).forEach(([key, value]) =&gt; {
    if (!isObjectRecord(value)) {
      return;
    }
    const normalizedValue = normalizeStyleStateNode(value);
    if (normalizedValue !== value) {
      if (normalized === node) {
        normalized = { ...node };
      }
      normalized[key] = normalizedValue;
    }
  });
  return normalized;
}
function normalizeStyleStateAliases(globalStyles) {
  if (true) {
    return globalStyles;
  }
  if (!globalStyles?.styles) {
    return globalStyles;
  }
  const styles = normalizeStyleStateNode(globalStyles.styles);
  return styles === globalStyles.styles ? globalStyles : { ...globalStyles, styles };
}

// packages/global-styles-engine/build-module/core/render.mjs
var import_blocks = __toESM(require_blocks(), 1);
var import_style_engine2 = __toESM(require_style_engine(), 1);
var import_data2 = __toESM(require_data(), 1);

// packages/global-styles-engine/build-module/core/selectors.mjs
function getBlockSelector(blockType, target = &quot;root&quot;, options = {}) {
  if (!target) {
    return null;
  }
  const { fallback = false } = options;
  const { name, selectors, supports } = blockType;
  const hasSelectors = selectors &amp;&amp; Object.keys(selectors).length &gt; 0;
  const path = Array.isArray(target) ? target.join(&quot;.&quot;) : target;
  let rootSelector = null;
  if (hasSelectors &amp;&amp; selectors.root) {
    rootSelector = selectors?.root;
  } else if (supports?.__experimentalSelector) {
    rootSelector = supports.__experimentalSelector;
  } else {
    rootSelector = &quot;.wp-block-&quot; + name.replace(&quot;core/&quot;, &quot;&quot;).replace(&quot;/&quot;, &quot;-&quot;);
  }
  if (path === &quot;root&quot;) {
    return rootSelector;
  }
  const pathArray = Array.isArray(target) ? target : target.split(&quot;.&quot;);
  if (pathArray.length === 1) {
    const fallbackSelector = fallback ? rootSelector : null;
    if (hasSelectors) {
      const featureSelector2 = getValueFromObjectPath(
        selectors,
        `${path}.root`,
        null
      ) || getValueFromObjectPath(selectors, path, null);
      return featureSelector2 || fallbackSelector;
    }
    const featureSelector = supports ? getValueFromObjectPath(
      supports,
      `${path}.__experimentalSelector`,
      null
    ) : void 0;
    if (!featureSelector) {
      return fallbackSelector;
    }
    return scopeSelector(rootSelector, featureSelector);
  }
  let subfeatureSelector;
  if (hasSelectors) {
    subfeatureSelector = getValueFromObjectPath(selectors, path, null);
  }
  if (subfeatureSelector) {
    return subfeatureSelector;
  }
  if (fallback) {
    return getBlockSelector(blockType, pathArray[0], options);
  }
  return null;
}

// node_modules/colord/index.mjs
var r = { grad: 0.9, turn: 360, rad: 360 / (2 * Math.PI) };
var t = function(r2) {
  return &quot;string&quot; == typeof r2 ? r2.length &gt; 0 : &quot;number&quot; == typeof r2;
};
var n = function(r2, t2, n2) {
  return void 0 === t2 &amp;&amp; (t2 = 0), void 0 === n2 &amp;&amp; (n2 = Math.pow(10, t2)), Math.round(n2 * r2) / n2 + 0;
};
var e = function(r2, t2, n2) {
  return void 0 === t2 &amp;&amp; (t2 = 0), void 0 === n2 &amp;&amp; (n2 = 1), r2 &gt; n2 ? n2 : r2 &gt; t2 ? r2 : t2;
};
var u = function(r2) {
  return (r2 = isFinite(r2) ? r2 % 360 : 0) &gt; 0 ? r2 : r2 + 360;
};
var a = function(r2) {
  return { r: e(r2.r, 0, 255), g: e(r2.g, 0, 255), b: e(r2.b, 0, 255), a: e(r2.a) };
};
var o = function(r2) {
  return { r: n(r2.r), g: n(r2.g), b: n(r2.b), a: n(r2.a, 3) };
};
var i = /^#([0-9a-f]{3,8})$/i;
var s = function(r2) {
  var t2 = r2.toString(16);
  return t2.length &lt; 2 ? &quot;0&quot; + t2 : t2;
};
var h = function(r2) {
  var t2 = r2.r, n2 = r2.g, e2 = r2.b, u2 = r2.a, a2 = Math.max(t2, n2, e2), o2 = a2 - Math.min(t2, n2, e2), i2 = o2 ? a2 === t2 ? (n2 - e2) / o2 : a2 === n2 ? 2 + (e2 - t2) / o2 : 4 + (t2 - n2) / o2 : 0;
  return { h: 60 * (i2 &lt; 0 ? i2 + 6 : i2), s: a2 ? o2 / a2 * 100 : 0, v: a2 / 255 * 100, a: u2 };
};
var b = function(r2) {
  var t2 = r2.h, n2 = r2.s, e2 = r2.v, u2 = r2.a;
  t2 = t2 / 360 * 6, n2 /= 100, e2 /= 100;
  var a2 = Math.floor(t2), o2 = e2 * (1 - n2), i2 = e2 * (1 - (t2 - a2) * n2), s2 = e2 * (1 - (1 - t2 + a2) * n2), h2 = a2 % 6;
  return { r: 255 * [e2, i2, o2, o2, s2, e2][h2], g: 255 * [s2, e2, e2, i2, o2, o2][h2], b: 255 * [o2, o2, s2, e2, e2, i2][h2], a: u2 };
};
var g = function(r2) {
  return { h: u(r2.h), s: e(r2.s, 0, 100), l: e(r2.l, 0, 100), a: e(r2.a) };
};
var d = function(r2) {
  return { h: n(r2.h), s: n(r2.s), l: n(r2.l), a: n(r2.a, 3) };
};
var f = function(r2) {
  return b((n2 = (t2 = r2).s, { h: t2.h, s: (n2 *= ((e2 = t2.l) &lt; 50 ? e2 : 100 - e2) / 100) &gt; 0 ? 2 * n2 / (e2 + n2) * 100 : 0, v: e2 + n2, a: t2.a }));
  var t2, n2, e2;
};
var c = function(r2) {
  return { h: (t2 = h(r2)).h, s: (u2 = (200 - (n2 = t2.s)) * (e2 = t2.v) / 100) &gt; 0 &amp;&amp; u2 &lt; 200 ? n2 * e2 / 100 / (u2 &lt;= 100 ? u2 : 200 - u2) * 100 : 0, l: u2 / 2, a: t2.a };
  var t2, n2, e2, u2;
};
var l = /^hsla?\(\s*([+-]?\d*\.?\d+)(deg|rad|grad|turn)?\s*,\s*([+-]?\d*\.?\d+)%\s*,\s*([+-]?\d*\.?\d+)%\s*(?:,\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i;
var p = /^hsla?\(\s*([+-]?\d*\.?\d+)(deg|rad|grad|turn)?\s+([+-]?\d*\.?\d+)%\s+([+-]?\d*\.?\d+)%\s*(?:\/\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i;
var v = /^rgba?\(\s*([+-]?\d*\.?\d+)(%)?\s*,\s*([+-]?\d*\.?\d+)(%)?\s*,\s*([+-]?\d*\.?\d+)(%)?\s*(?:,\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i;
var m = /^rgba?\(\s*([+-]?\d*\.?\d+)(%)?\s+([+-]?\d*\.?\d+)(%)?\s+([+-]?\d*\.?\d+)(%)?\s*(?:\/\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i;
var y = { string: [[function(r2) {
  var t2 = i.exec(r2);
  return t2 ? (r2 = t2[1]).length &lt;= 4 ? { r: parseInt(r2[0] + r2[0], 16), g: parseInt(r2[1] + r2[1], 16), b: parseInt(r2[2] + r2[2], 16), a: 4 === r2.length ? n(parseInt(r2[3] + r2[3], 16) / 255, 2) : 1 } : 6 === r2.length || 8 === r2.length ? { r: parseInt(r2.substr(0, 2), 16), g: parseInt(r2.substr(2, 2), 16), b: parseInt(r2.substr(4, 2), 16), a: 8 === r2.length ? n(parseInt(r2.substr(6, 2), 16) / 255, 2) : 1 } : null : null;
}, &quot;hex&quot;], [function(r2) {
  var t2 = v.exec(r2) || m.exec(r2);
  return t2 ? t2[2] !== t2[4] || t2[4] !== t2[6] ? null : a({ r: Number(t2[1]) / (t2[2] ? 100 / 255 : 1), g: Number(t2[3]) / (t2[4] ? 100 / 255 : 1), b: Number(t2[5]) / (t2[6] ? 100 / 255 : 1), a: void 0 === t2[7] ? 1 : Number(t2[7]) / (t2[8] ? 100 : 1) }) : null;
}, &quot;rgb&quot;], [function(t2) {
  var n2 = l.exec(t2) || p.exec(t2);
  if (!n2) return null;
  var e2, u2, a2 = g({ h: (e2 = n2[1], u2 = n2[2], void 0 === u2 &amp;&amp; (u2 = &quot;deg&quot;), Number(e2) * (r[u2] || 1)), s: Number(n2[3]), l: Number(n2[4]), a: void 0 === n2[5] ? 1 : Number(n2[5]) / (n2[6] ? 100 : 1) });
  return f(a2);
}, &quot;hsl&quot;]], object: [[function(r2) {
  var n2 = r2.r, e2 = r2.g, u2 = r2.b, o2 = r2.a, i2 = void 0 === o2 ? 1 : o2;
  return t(n2) &amp;&amp; t(e2) &amp;&amp; t(u2) ? a({ r: Number(n2), g: Number(e2), b: Number(u2), a: Number(i2) }) : null;
}, &quot;rgb&quot;], [function(r2) {
  var n2 = r2.h, e2 = r2.s, u2 = r2.l, a2 = r2.a, o2 = void 0 === a2 ? 1 : a2;
  if (!t(n2) || !t(e2) || !t(u2)) return null;
  var i2 = g({ h: Number(n2), s: Number(e2), l: Number(u2), a: Number(o2) });
  return f(i2);
}, &quot;hsl&quot;], [function(r2) {
  var n2 = r2.h, a2 = r2.s, o2 = r2.v, i2 = r2.a, s2 = void 0 === i2 ? 1 : i2;
  if (!t(n2) || !t(a2) || !t(o2)) return null;
  var h2 = (function(r3) {
    return { h: u(r3.h), s: e(r3.s, 0, 100), v: e(r3.v, 0, 100), a: e(r3.a) };
  })({ h: Number(n2), s: Number(a2), v: Number(o2), a: Number(s2) });
  return b(h2);
}, &quot;hsv&quot;]] };
var N = function(r2, t2) {
  for (var n2 = 0; n2 &lt; t2.length; n2++) {
    var e2 = t2[n2][0](r2);
    if (e2) return [e2, t2[n2][1]];
  }
  return [null, void 0];
};
var x = function(r2) {
  return &quot;string&quot; == typeof r2 ? N(r2.trim(), y.string) : &quot;object&quot; == typeof r2 &amp;&amp; null !== r2 ? N(r2, y.object) : [null, void 0];
};
var M = function(r2, t2) {
  var n2 = c(r2);
  return { h: n2.h, s: e(n2.s + 100 * t2, 0, 100), l: n2.l, a: n2.a };
};
var H = function(r2) {
  return (299 * r2.r + 587 * r2.g + 114 * r2.b) / 1e3 / 255;
};
var $ = function(r2, t2) {
  var n2 = c(r2);
  return { h: n2.h, s: n2.s, l: e(n2.l + 100 * t2, 0, 100), a: n2.a };
};
var j = (function() {
  function r2(r3) {
    this.parsed = x(r3)[0], this.rgba = this.parsed || { r: 0, g: 0, b: 0, a: 1 };
  }
  return r2.prototype.isValid = function() {
    return null !== this.parsed;
  }, r2.prototype.brightness = function() {
    return n(H(this.rgba), 2);
  }, r2.prototype.isDark = function() {
    return H(this.rgba) &lt; 0.5;
  }, r2.prototype.isLight = function() {
    return H(this.rgba) &gt;= 0.5;
  }, r2.prototype.toHex = function() {
    return r3 = o(this.rgba), t2 = r3.r, e2 = r3.g, u2 = r3.b, i2 = (a2 = r3.a) &lt; 1 ? s(n(255 * a2)) : &quot;&quot;, &quot;#&quot; + s(t2) + s(e2) + s(u2) + i2;
    var r3, t2, e2, u2, a2, i2;
  }, r2.prototype.toRgb = function() {
    return o(this.rgba);
  }, r2.prototype.toRgbString = function() {
    return r3 = o(this.rgba), t2 = r3.r, n2 = r3.g, e2 = r3.b, (u2 = r3.a) &lt; 1 ? &quot;rgba(&quot; + t2 + &quot;, &quot; + n2 + &quot;, &quot; + e2 + &quot;, &quot; + u2 + &quot;)&quot; : &quot;rgb(&quot; + t2 + &quot;, &quot; + n2 + &quot;, &quot; + e2 + &quot;)&quot;;
    var r3, t2, n2, e2, u2;
  }, r2.prototype.toHsl = function() {
    return d(c(this.rgba));
  }, r2.prototype.toHslString = function() {
    return r3 = d(c(this.rgba)), t2 = r3.h, n2 = r3.s, e2 = r3.l, (u2 = r3.a) &lt; 1 ? &quot;hsla(&quot; + t2 + &quot;, &quot; + n2 + &quot;%, &quot; + e2 + &quot;%, &quot; + u2 + &quot;)&quot; : &quot;hsl(&quot; + t2 + &quot;, &quot; + n2 + &quot;%, &quot; + e2 + &quot;%)&quot;;
    var r3, t2, n2, e2, u2;
  }, r2.prototype.toHsv = function() {
    return r3 = h(this.rgba), { h: n(r3.h), s: n(r3.s), v: n(r3.v), a: n(r3.a, 3) };
    var r3;
  }, r2.prototype.invert = function() {
    return w({ r: 255 - (r3 = this.rgba).r, g: 255 - r3.g, b: 255 - r3.b, a: r3.a });
    var r3;
  }, r2.prototype.saturate = function(r3) {
    return void 0 === r3 &amp;&amp; (r3 = 0.1), w(M(this.rgba, r3));
  }, r2.prototype.desaturate = function(r3) {
    return void 0 === r3 &amp;&amp; (r3 = 0.1), w(M(this.rgba, -r3));
  }, r2.prototype.grayscale = function() {
    return w(M(this.rgba, -1));
  }, r2.prototype.lighten = function(r3) {
    return void 0 === r3 &amp;&amp; (r3 = 0.1), w($(this.rgba, r3));
  }, r2.prototype.darken = function(r3) {
    return void 0 === r3 &amp;&amp; (r3 = 0.1), w($(this.rgba, -r3));
  }, r2.prototype.rotate = function(r3) {
    return void 0 === r3 &amp;&amp; (r3 = 15), this.hue(this.hue() + r3);
  }, r2.prototype.alpha = function(r3) {
    return &quot;number&quot; == typeof r3 ? w({ r: (t2 = this.rgba).r, g: t2.g, b: t2.b, a: r3 }) : n(this.rgba.a, 3);
    var t2;
  }, r2.prototype.hue = function(r3) {
    var t2 = c(this.rgba);
    return &quot;number&quot; == typeof r3 ? w({ h: r3, s: t2.s, l: t2.l, a: t2.a }) : n(t2.h);
  }, r2.prototype.isEqual = function(r3) {
    return this.toHex() === w(r3).toHex();
  }, r2;
})();
var w = function(r2) {
  return r2 instanceof j ? r2 : new j(r2);
};

// packages/global-styles-engine/build-module/utils/duotone.mjs
function getValuesFromColors(colors = []) {
  const values = {
    r: [],
    g: [],
    b: [],
    a: []
  };
  colors.forEach((color) =&gt; {
    const rgbColor = w(color).toRgb();
    values.r.push(rgbColor.r / 255);
    values.g.push(rgbColor.g / 255);
    values.b.push(rgbColor.b / 255);
    values.a.push(rgbColor.a);
  });
  return values;
}
function getDuotoneFilter(id, colors) {
  const values = getValuesFromColors(colors);
  return `
&lt;svg
	xmlns:xlink=&quot;http://www.w3.org/1999/xlink&quot;
	viewBox=&quot;0 0 0 0&quot;
	width=&quot;0&quot;
	height=&quot;0&quot;
	focusable=&quot;false&quot;
	role=&quot;none&quot;
	aria-hidden=&quot;true&quot;
	style=&quot;visibility: hidden; position: absolute; left: -9999px; overflow: hidden;&quot;
&gt;
	&lt;defs&gt;
		&lt;filter id=&quot;${id}&quot;&gt;
			&lt;!--
				Use sRGB instead of linearRGB so transparency looks correct.
				Use perceptual brightness to convert to grayscale.
			--&gt;
			&lt;feColorMatrix color-interpolation-filters=&quot;sRGB&quot; type=&quot;matrix&quot; values=&quot; .299 .587 .114 0 0 .299 .587 .114 0 0 .299 .587 .114 0 0 .299 .587 .114 0 0 &quot;&gt;&lt;/feColorMatrix&gt;
			&lt;!-- Use sRGB instead of linearRGB to be consistent with how CSS gradients work. --&gt;
			&lt;feComponentTransfer color-interpolation-filters=&quot;sRGB&quot;&gt;
				&lt;feFuncR type=&quot;table&quot; tableValues=&quot;${values.r.join(&quot; &quot;)}&quot;&gt;&lt;/feFuncR&gt;
				&lt;feFuncG type=&quot;table&quot; tableValues=&quot;${values.g.join(&quot; &quot;)}&quot;&gt;&lt;/feFuncG&gt;
				&lt;feFuncB type=&quot;table&quot; tableValues=&quot;${values.b.join(&quot; &quot;)}&quot;&gt;&lt;/feFuncB&gt;
				&lt;feFuncA type=&quot;table&quot; tableValues=&quot;${values.a.join(&quot; &quot;)}&quot;&gt;&lt;/feFuncA&gt;
			&lt;/feComponentTransfer&gt;
			&lt;!-- Re-mask the image with the original transparency since the feColorMatrix above loses that information. --&gt;
			&lt;feComposite in2=&quot;SourceGraphic&quot; operator=&quot;in&quot;&gt;&lt;/feComposite&gt;
		&lt;/filter&gt;
	&lt;/defs&gt;
&lt;/svg&gt;`;
}

// packages/global-styles-engine/build-module/utils/string.mjs
function kebabCase(str) {
  return str.replace(/([a-z])([A-Z])/g, &quot;$1-$2&quot;).replace(/([0-9])([a-zA-Z])/g, &quot;$1-$2&quot;).replace(/([a-zA-Z])([0-9])/g, &quot;$1-$2&quot;).replace(/[\s_]+/g, &quot;-&quot;).toLowerCase();
}

// packages/global-styles-engine/build-module/utils/spacing.mjs
function getSpacingPresetCssVar(value) {
  if (!value) {
    return;
  }
  const slug = value.match(/var:preset\|spacing\|(.+)/);
  if (!slug) {
    return value;
  }
  return `var(--wp--preset--spacing--${slug[1]})`;
}

// packages/global-styles-engine/build-module/utils/gap.mjs
function getGapBoxControlValueFromStyle(blockGapValue) {
  if (!blockGapValue) {
    return null;
  }
  const isValueString = typeof blockGapValue === &quot;string&quot;;
  return {
    top: isValueString ? blockGapValue : blockGapValue?.top,
    left: isValueString ? blockGapValue : blockGapValue?.left
  };
}
function getGapCSSValue(blockGapValue, defaultValue = &quot;0&quot;) {
  const blockGapBoxControlValue = getGapBoxControlValueFromStyle(blockGapValue);
  if (!blockGapBoxControlValue) {
    return null;
  }
  const row = getSpacingPresetCssVar(blockGapBoxControlValue?.top) || defaultValue;
  const column = getSpacingPresetCssVar(blockGapBoxControlValue?.left) || defaultValue;
  return row === column ? row : `${row} ${column}`;
}

// packages/global-styles-engine/build-module/utils/background.mjs
var BACKGROUND_BLOCK_DEFAULT_VALUES = {
  backgroundSize: &quot;cover&quot;,
  backgroundPosition: &quot;50% 50%&quot;
  // used only when backgroundSize is &#039;contain&#039;.
};
function setBackgroundStyleDefaults(backgroundStyle) {
  if (!backgroundStyle || // @ts-expect-error
  !backgroundStyle?.backgroundImage?.url) {
    return;
  }
  let backgroundStylesWithDefaults;
  if (!backgroundStyle?.backgroundSize) {
    backgroundStylesWithDefaults = {
      backgroundSize: BACKGROUND_BLOCK_DEFAULT_VALUES.backgroundSize
    };
  }
  if (&quot;contain&quot; === backgroundStyle?.backgroundSize &amp;&amp; !backgroundStyle?.backgroundPosition) {
    backgroundStylesWithDefaults = {
      backgroundPosition: BACKGROUND_BLOCK_DEFAULT_VALUES.backgroundPosition
    };
  }
  return backgroundStylesWithDefaults;
}

// packages/global-styles-engine/build-module/utils/layout.mjs
var LAYOUT_DEFINITIONS = {
  default: {
    name: &quot;default&quot;,
    slug: &quot;flow&quot;,
    className: &quot;is-layout-flow&quot;,
    baseStyles: [
      {
        selector: &quot; &gt; .alignleft&quot;,
        rules: {
          float: &quot;left&quot;,
          &quot;margin-inline-start&quot;: &quot;0&quot;,
          &quot;margin-inline-end&quot;: &quot;2em&quot;
        }
      },
      {
        selector: &quot; &gt; .alignright&quot;,
        rules: {
          float: &quot;right&quot;,
          &quot;margin-inline-start&quot;: &quot;2em&quot;,
          &quot;margin-inline-end&quot;: &quot;0&quot;
        }
      },
      {
        selector: &quot; &gt; .aligncenter&quot;,
        rules: {
          &quot;margin-left&quot;: &quot;auto !important&quot;,
          &quot;margin-right&quot;: &quot;auto !important&quot;
        }
      }
    ],
    spacingStyles: [
      {
        selector: &quot; &gt; :first-child&quot;,
        rules: {
          &quot;margin-block-start&quot;: &quot;0&quot;
        }
      },
      {
        selector: &quot; &gt; :last-child&quot;,
        rules: {
          &quot;margin-block-end&quot;: &quot;0&quot;
        }
      },
      {
        selector: &quot; &gt; *&quot;,
        rules: {
          &quot;margin-block-start&quot;: null,
          &quot;margin-block-end&quot;: &quot;0&quot;
        }
      }
    ]
  },
  constrained: {
    name: &quot;constrained&quot;,
    slug: &quot;constrained&quot;,
    className: &quot;is-layout-constrained&quot;,
    baseStyles: [
      {
        selector: &quot; &gt; .alignleft&quot;,
        rules: {
          float: &quot;left&quot;,
          &quot;margin-inline-start&quot;: &quot;0&quot;,
          &quot;margin-inline-end&quot;: &quot;2em&quot;
        }
      },
      {
        selector: &quot; &gt; .alignright&quot;,
        rules: {
          float: &quot;right&quot;,
          &quot;margin-inline-start&quot;: &quot;2em&quot;,
          &quot;margin-inline-end&quot;: &quot;0&quot;
        }
      },
      {
        selector: &quot; &gt; .aligncenter&quot;,
        rules: {
          &quot;margin-left&quot;: &quot;auto !important&quot;,
          &quot;margin-right&quot;: &quot;auto !important&quot;
        }
      },
      {
        selector: &quot; &gt; :where(:not(.alignleft):not(.alignright):not(.alignfull))&quot;,
        rules: {
          &quot;max-width&quot;: &quot;var(--wp--style--global--content-size)&quot;,
          &quot;margin-left&quot;: &quot;auto !important&quot;,
          &quot;margin-right&quot;: &quot;auto !important&quot;
        }
      },
      {
        selector: &quot; &gt; .alignwide&quot;,
        rules: {
          &quot;max-width&quot;: &quot;var(--wp--style--global--wide-size)&quot;
        }
      }
    ],
    spacingStyles: [
      {
        selector: &quot; &gt; :first-child&quot;,
        rules: {
          &quot;margin-block-start&quot;: &quot;0&quot;
        }
      },
      {
        selector: &quot; &gt; :last-child&quot;,
        rules: {
          &quot;margin-block-end&quot;: &quot;0&quot;
        }
      },
      {
        selector: &quot; &gt; *&quot;,
        rules: {
          &quot;margin-block-start&quot;: null,
          &quot;margin-block-end&quot;: &quot;0&quot;
        }
      }
    ]
  },
  flex: {
    name: &quot;flex&quot;,
    slug: &quot;flex&quot;,
    className: &quot;is-layout-flex&quot;,
    displayMode: &quot;flex&quot;,
    baseStyles: [
      {
        selector: &quot;&quot;,
        rules: {
          &quot;flex-wrap&quot;: &quot;wrap&quot;,
          &quot;align-items&quot;: &quot;center&quot;
        }
      },
      {
        selector: &quot; &gt; :is(*, div)&quot;,
        // :is(*, div) instead of just * increases the specificity by 001.
        rules: {
          margin: &quot;0&quot;
        }
      }
    ],
    spacingStyles: [
      {
        selector: &quot;&quot;,
        rules: {
          gap: null
        }
      }
    ]
  },
  grid: {
    name: &quot;grid&quot;,
    slug: &quot;grid&quot;,
    className: &quot;is-layout-grid&quot;,
    displayMode: &quot;grid&quot;,
    baseStyles: [
      {
        selector: &quot; &gt; :is(*, div)&quot;,
        // :is(*, div) instead of just * increases the specificity by 001.
        rules: {
          margin: &quot;0&quot;
        }
      }
    ],
    spacingStyles: [
      {
        selector: &quot;&quot;,
        rules: {
          gap: null
        }
      }
    ]
  }
};

// packages/global-styles-engine/build-module/utils/viewport.mjs
var DEFAULT_VIEWPORT_BREAKPOINTS = {
  mobile: &quot;480px&quot;,
  tablet: &quot;782px&quot;
};
var VIEWPORT_SIZE_REGEXP = /^(\d+|\d*\.\d+)(px|em|rem)$/;
var DEFAULT_FONT_SIZE = 16;
function isViewportSettings(configOrSettings) {
  return &quot;mobile&quot; in configOrSettings || &quot;tablet&quot; in configOrSettings;
}
function getViewportSettings(configOrSettings) {
  if (!configOrSettings || typeof configOrSettings !== &quot;object&quot;) {
    return {};
  }
  if (isViewportSettings(configOrSettings)) {
    return configOrSettings;
  }
  return configOrSettings.settings?.viewport ?? {};
}
function isValidViewportSize(value) {
  return typeof value === &quot;string&quot; &amp;&amp; VIEWPORT_SIZE_REGEXP.test(value.trim());
}
function getViewportBreakpointValueInPixels(value) {
  if (typeof value === &quot;number&quot;) {
    return value;
  }
  if (typeof value !== &quot;string&quot;) {
    return void 0;
  }
  const match = value.trim().match(VIEWPORT_SIZE_REGEXP);
  if (!match) {
    return void 0;
  }
  const numericValue = Number.parseFloat(match[1]);
  const unit = match[2];
  return unit === &quot;px&quot; ? numericValue : numericValue * DEFAULT_FONT_SIZE;
}
function getViewportBreakpoints(configOrSettings) {
  const viewportSettings = getViewportSettings(configOrSettings);
  const breakpoints = {};
  const breakpointValuesInPixels = {};
  Object.keys(DEFAULT_VIEWPORT_BREAKPOINTS).forEach((breakpoint) =&gt; {
    const key = breakpoint;
    const value = viewportSettings[key];
    const px = getViewportBreakpointValueInPixels(value);
    if (px !== void 0 &amp;&amp; isValidViewportSize(value)) {
      breakpoints[key] = value.trim();
      breakpointValuesInPixels[key] = px;
    }
  });
  const breakpointNames = Object.keys(breakpoints);
  if (!breakpointNames.length) {
    return { ...DEFAULT_VIEWPORT_BREAKPOINTS };
  }
  if (1 === breakpointNames.length) {
    return breakpoints;
  }
  const mobile = breakpoints.mobile;
  const tablet = breakpoints.tablet;
  if (breakpointValuesInPixels.mobile &gt;= breakpointValuesInPixels.tablet) {
    return { mobile };
  }
  return { mobile, tablet };
}
function getResponsiveMediaQueries(configOrSettings) {
  const breakpoints = getViewportBreakpoints(configOrSettings);
  const mediaQueries = {};
  if (breakpoints.mobile) {
    mediaQueries[&quot;@mobile&quot;] = `@media (width &lt;= ${breakpoints.mobile})`;
  }
  if (breakpoints.tablet) {
    mediaQueries[&quot;@tablet&quot;] = breakpoints.mobile ? `@media (${breakpoints.mobile} &lt; width &lt;= ${breakpoints.tablet})` : `@media (width &lt;= ${breakpoints.tablet})`;
  }
  return mediaQueries;
}

// packages/global-styles-engine/build-module/core/render.mjs
var ELEMENT_CLASS_NAMES = {
  button: &quot;wp-element-button&quot;,
  caption: &quot;wp-element-caption&quot;
};
var BLOCK_SUPPORT_FEATURE_LEVEL_SELECTORS = {
  __experimentalBorder: &quot;border&quot;,
  color: &quot;color&quot;,
  dimensions: &quot;dimensions&quot;,
  spacing: &quot;spacing&quot;,
  typography: &quot;typography&quot;
};
var VALID_BLOCK_PSEUDO_SELECTORS = {
  &quot;core/button&quot;: [&quot;:hover&quot;, &quot;:focus&quot;, &quot;:focus-visible&quot;, &quot;:active&quot;],
  &quot;core/navigation-link&quot;: [&quot;:hover&quot;, &quot;:focus&quot;, &quot;:focus-visible&quot;, &quot;:active&quot;]
};
var VALID_ELEMENT_PSEUDO_SELECTORS = {
  link: [
    &quot;:link&quot;,
    &quot;:any-link&quot;,
    &quot;:visited&quot;,
    &quot;:hover&quot;,
    &quot;:focus&quot;,
    &quot;:focus-visible&quot;,
    &quot;:active&quot;
  ],
  button: [
    &quot;:link&quot;,
    &quot;:any-link&quot;,
    &quot;:visited&quot;,
    &quot;:hover&quot;,
    &quot;:focus&quot;,
    &quot;:focus-visible&quot;,
    &quot;:active&quot;
  ]
};
function getPresetsClasses(blockSelector = &quot;*&quot;, blockPresets = {}) {
  return PRESET_METADATA.reduce(
    (declarations, { path, cssVarInfix, classes }) =&gt; {
      if (!classes) {
        return declarations;
      }
      const presetByOrigin = getValueFromObjectPath(
        blockPresets,
        path,
        []
      );
      [&quot;default&quot;, &quot;theme&quot;, &quot;custom&quot;].forEach((origin) =&gt; {
        if (presetByOrigin[origin]) {
          presetByOrigin[origin].forEach(
            ({ slug }) =&gt; {
              classes.forEach(
                ({
                  classSuffix,
                  propertyName
                }) =&gt; {
                  const classSelectorToUse = `.has-${kebabCase(
                    slug
                  )}-${classSuffix}`;
                  const selectorToUse = blockSelector ? `:where(${blockSelector})${classSelectorToUse}` : classSelectorToUse;
                  const value = `var(--wp--preset--${cssVarInfix}--${kebabCase(
                    slug
                  )})`;
                  declarations += `${selectorToUse}{${propertyName}: ${value} !important;}`;
                }
              );
            }
          );
        }
      });
      return declarations;
    },
    &quot;&quot;
  );
}
function getPresetsSvgFilters(blockPresets = {}) {
  return PRESET_METADATA.filter(
    // Duotone are the only type of filters for now.
    (metadata) =&gt; metadata.path.at(-1) === &quot;duotone&quot;
  ).flatMap((metadata) =&gt; {
    const presetByOrigin = getValueFromObjectPath(
      blockPresets,
      metadata.path,
      {}
    );
    return [&quot;default&quot;, &quot;theme&quot;].filter((origin) =&gt; presetByOrigin[origin]).flatMap(
      (origin) =&gt; presetByOrigin[origin].map(
        (preset) =&gt; getDuotoneFilter(
          `wp-duotone-${preset.slug}`,
          preset.colors
        )
      )
    ).join(&quot;&quot;);
  });
}
function flattenTree(input = {}, prefix, token) {
  let result = [];
  Object.keys(input).forEach((key) =&gt; {
    const newKey = prefix + kebabCase(key.replace(&quot;/&quot;, &quot;-&quot;));
    const newLeaf = input[key];
    if (newLeaf instanceof Object) {
      const newPrefix = newKey + token;
      result = [...result, ...flattenTree(newLeaf, newPrefix, token)];
    } else {
      result.push(`${newKey}: ${newLeaf}`);
    }
  });
  return result;
}
var updateParagraphTextIndentSelector = (featureDeclarations, settings, blockName) =&gt; {
  if (blockName !== &quot;core/paragraph&quot;) {
    return featureDeclarations;
  }
  const blockSettings = settings?.blocks?.[&quot;core/paragraph&quot;];
  const textIndentSetting = blockSettings?.typography?.textIndent ?? settings?.typography?.textIndent ?? &quot;subsequent&quot;;
  if (textIndentSetting !== &quot;all&quot;) {
    return featureDeclarations;
  }
  const oldSelector = &quot;.wp-block-paragraph + .wp-block-paragraph&quot;;
  const newSelector = &quot;.wp-block-paragraph&quot;;
  if (oldSelector in featureDeclarations) {
    const declarations = featureDeclarations[oldSelector];
    const updated = { ...featureDeclarations };
    delete updated[oldSelector];
    updated[newSelector] = declarations;
    return updated;
  }
  return featureDeclarations;
};
var updateButtonWidthDeclarations = (featureDeclarations, settings) =&gt; {
  const buttonSelector = &quot;.wp-block-button&quot;;
  if (!(buttonSelector in featureDeclarations)) {
    return featureDeclarations;
  }
  const updated = { ...featureDeclarations };
  updated[buttonSelector] = updated[buttonSelector].map(
    (declaration) =&gt; {
      const match = declaration.match(/^width:\s*(.+)$/);
      if (!match) {
        return declaration;
      }
      const value = match[1];
      let percentage = null;
      if (value.endsWith(&quot;%&quot;)) {
        percentage = parseFloat(value);
      }
      const presetPrefix = &quot;var(--wp--preset--dimension--&quot;;
      if (percentage === null &amp;&amp; value.startsWith(presetPrefix) &amp;&amp; value.endsWith(&quot;)&quot;)) {
        const slug = value.slice(presetPrefix.length, -1);
        const dimensionSizes = {
          ...settings?.dimensions?.dimensionSizes ?? {},
          ...settings?.blocks?.[&quot;core/button&quot;]?.dimensions?.dimensionSizes ?? {}
        };
        for (const origin of Object.values(dimensionSizes)) {
          if (!Array.isArray(origin)) {
            continue;
          }
          for (const preset of origin) {
            if (preset.slug === slug &amp;&amp; typeof preset.size === &quot;string&quot; &amp;&amp; preset.size.endsWith(&quot;%&quot;)) {
              percentage = parseFloat(preset.size);
              break;
            }
          }
          if (percentage !== null) {
            break;
          }
        }
      }
      if (percentage === null || isNaN(percentage)) {
        return declaration;
      }
      return `width: calc(${percentage} * 1% - (var(--wp--style--block-gap, 0.5em) * (1 - ${percentage} / 100)))`;
    }
  );
  return updated;
};
var getFeatureDeclarations = (selectors, styles) =&gt; {
  const declarations = {};
  Object.entries(selectors).forEach(([feature, selector]) =&gt; {
    if (feature === &quot;root&quot; || !styles?.[feature]) {
      return;
    }
    const isShorthand = typeof selector === &quot;string&quot;;
    if (!isShorthand &amp;&amp; typeof selector === &quot;object&quot; &amp;&amp; selector !== null) {
      Object.entries(selector).forEach(
        ([subfeature, subfeatureSelector]) =&gt; {
          if (subfeature === &quot;root&quot; || !styles?.[feature][subfeature]) {
            return;
          }
          const subfeatureStyles = {
            [feature]: {
              [subfeature]: styles[feature][subfeature]
            }
          };
          const newDeclarations = getStylesDeclarations(subfeatureStyles);
          declarations[subfeatureSelector] = [
            ...declarations[subfeatureSelector] || [],
            ...newDeclarations
          ];
          delete styles[feature][subfeature];
        }
      );
    }
    if (isShorthand || typeof selector === &quot;object&quot; &amp;&amp; selector !== null &amp;&amp; &quot;root&quot; in selector) {
      const featureSelector = isShorthand ? selector : selector.root;
      const featureStyles = { [feature]: styles[feature] };
      const newDeclarations = getStylesDeclarations(featureStyles);
      declarations[featureSelector] = [
        ...declarations[featureSelector] || [],
        ...newDeclarations
      ];
      delete styles[feature];
    }
  });
  return declarations;
};
function getStylesDeclarations(blockStyles = {}, selector = &quot;&quot;, useRootPaddingAlign, tree = {}, disableRootPadding = false) {
  const isRoot = ROOT_BLOCK_SELECTOR === selector;
  const output = Object.entries(
    import_blocks.__EXPERIMENTAL_STYLE_PROPERTY
  ).reduce(
    (declarations, [key, { value, properties, useEngine, rootOnly }]) =&gt; {
      if (rootOnly &amp;&amp; !isRoot) {
        return declarations;
      }
      const pathToValue = value;
      if (pathToValue[0] === &quot;elements&quot; || useEngine) {
        return declarations;
      }
      const styleValue = getValueFromObjectPath(
        blockStyles,
        pathToValue
      );
      if (key === &quot;--wp--style--root--padding&quot; &amp;&amp; (typeof styleValue === &quot;string&quot; || !useRootPaddingAlign)) {
        return declarations;
      }
      if (properties &amp;&amp; typeof styleValue !== &quot;string&quot;) {
        Object.entries(properties).forEach((entry) =&gt; {
          const [name, prop] = entry;
          if (!getValueFromObjectPath(styleValue, [prop], false)) {
            return;
          }
          const cssProperty = name.startsWith(&quot;--&quot;) ? name : kebabCase(name);
          declarations.push(
            `${cssProperty}: ${(0, import_style_engine2.getCSSValueFromRawStyle)(
              getValueFromObjectPath(styleValue, [prop])
            )}`
          );
        });
      } else if (getValueFromObjectPath(blockStyles, pathToValue, false)) {
        const cssProperty = key.startsWith(&quot;--&quot;) ? key : kebabCase(key);
        declarations.push(
          `${cssProperty}: ${(0, import_style_engine2.getCSSValueFromRawStyle)(
            getValueFromObjectPath(blockStyles, pathToValue)
          )}`
        );
      }
      return declarations;
    },
    []
  );
  if (!!blockStyles.background) {
    if (blockStyles.background?.backgroundImage) {
      blockStyles.background.backgroundImage = getResolvedValue(
        blockStyles.background.backgroundImage,
        tree
      );
    }
    if (!isRoot &amp;&amp; !!blockStyles.background?.backgroundImage?.id) {
      blockStyles = {
        ...blockStyles,
        background: {
          ...blockStyles.background,
          ...setBackgroundStyleDefaults(blockStyles.background)
        }
      };
    }
  }
  const extraRules = (0, import_style_engine2.getCSSRules)(blockStyles);
  extraRules.forEach((rule) =&gt; {
    if (isRoot &amp;&amp; (useRootPaddingAlign || disableRootPadding) &amp;&amp; rule.key.startsWith(&quot;padding&quot;)) {
      return;
    }
    const cssProperty = rule.key.startsWith(&quot;--&quot;) ? rule.key : kebabCase(rule.key);
    let ruleValue = getResolvedValue(rule.value, tree);
    if (cssProperty === &quot;font-size&quot;) {
      ruleValue = getTypographyFontSizeValue(
        { name: &quot;&quot;, slug: &quot;&quot;, size: ruleValue },
        tree?.settings
      );
    }
    if (cssProperty === &quot;aspect-ratio&quot;) {
      output.push(&quot;min-height: unset&quot;);
    }
    output.push(`${cssProperty}: ${ruleValue}`);
  });
  return output;
}
function getLayoutStyles({
  layoutDefinitions = LAYOUT_DEFINITIONS,
  style,
  selector,
  hasBlockGapSupport,
  hasFallbackGapSupport,
  fallbackGapValue
}) {
  let ruleset = &quot;&quot;;
  let gapValue = hasBlockGapSupport ? getGapCSSValue(style?.spacing?.blockGap) : &quot;&quot;;
  if (hasFallbackGapSupport) {
    if (selector === ROOT_BLOCK_SELECTOR) {
      gapValue = !gapValue ? &quot;0.5em&quot; : gapValue;
    } else if (!hasBlockGapSupport &amp;&amp; fallbackGapValue) {
      gapValue = fallbackGapValue;
    }
  }
  if (gapValue &amp;&amp; layoutDefinitions) {
    Object.values(layoutDefinitions).forEach(
      ({ className, name, spacingStyles }) =&gt; {
        if (!hasBlockGapSupport &amp;&amp; &quot;flex&quot; !== name &amp;&amp; &quot;grid&quot; !== name) {
          return;
        }
        if (spacingStyles?.length) {
          spacingStyles.forEach((spacingStyle) =&gt; {
            const declarations = [];
            if (spacingStyle.rules) {
              Object.entries(spacingStyle.rules).forEach(
                ([cssProperty, cssValue]) =&gt; {
                  declarations.push(
                    `${cssProperty}: ${cssValue ? cssValue : gapValue}`
                  );
                }
              );
            }
            if (declarations.length) {
              let combinedSelector = &quot;&quot;;
              if (!hasBlockGapSupport) {
                combinedSelector = selector === ROOT_BLOCK_SELECTOR ? `:where(.${className}${spacingStyle?.selector || &quot;&quot;})` : `:where(${selector}.${className}${spacingStyle?.selector || &quot;&quot;})`;
              } else {
                combinedSelector = selector === ROOT_BLOCK_SELECTOR ? `:root :where(.${className})${spacingStyle?.selector || &quot;&quot;}` : `:root :where(${selector}-${className})${spacingStyle?.selector || &quot;&quot;}`;
              }
              ruleset += `${combinedSelector} { ${declarations.join(
                &quot;; &quot;
              )}; }`;
            }
          });
        }
      }
    );
    if (selector === ROOT_BLOCK_SELECTOR &amp;&amp; hasBlockGapSupport) {
      ruleset += `${ROOT_CSS_PROPERTIES_SELECTOR} { --wp--style--block-gap: ${gapValue}; }`;
    }
  }
  if (selector === ROOT_BLOCK_SELECTOR &amp;&amp; layoutDefinitions) {
    const validDisplayModes = [&quot;block&quot;, &quot;flex&quot;, &quot;grid&quot;];
    Object.values(layoutDefinitions).forEach(
      ({ className, displayMode, baseStyles }) =&gt; {
        if (displayMode &amp;&amp; validDisplayModes.includes(displayMode)) {
          ruleset += `${selector} .${className} { display:${displayMode}; }`;
        }
        if (baseStyles?.length) {
          baseStyles.forEach((baseStyle) =&gt; {
            const declarations = [];
            if (baseStyle.rules) {
              Object.entries(baseStyle.rules).forEach(
                ([cssProperty, cssValue]) =&gt; {
                  declarations.push(
                    `${cssProperty}: ${cssValue}`
                  );
                }
              );
            }
            if (declarations.length) {
              const combinedSelector = `.${className}${baseStyle?.selector || &quot;&quot;}`;
              ruleset += `${combinedSelector} { ${declarations.join(
                &quot;; &quot;
              )}; }`;
            }
          });
        }
      }
    );
  }
  return ruleset;
}
var STYLE_KEYS = [
  &quot;border&quot;,
  &quot;color&quot;,
  &quot;dimensions&quot;,
  &quot;spacing&quot;,
  &quot;typography&quot;,
  &quot;filter&quot;,
  &quot;outline&quot;,
  &quot;shadow&quot;,
  &quot;background&quot;
];
function pickStyleKeys(treeToPickFrom, responsiveMediaQueries) {
  return pickStyleAndPseudoKeys(
    treeToPickFrom,
    void 0,
    responsiveMediaQueries
  );
}
function pickStyleAndPseudoKeys(treeToPickFrom, blockName, responsiveMediaQueries) {
  if (!treeToPickFrom) {
    return {};
  }
  const entries = Object.entries(treeToPickFrom);
  const allowedPseudoSelectors = blockName ? VALID_BLOCK_PSEUDO_SELECTORS[blockName] ?? [] : [];
  const pickedEntries = entries.filter(
    ([key]) =&gt; STYLE_KEYS.includes(key) || allowedPseudoSelectors.includes(key) || responsiveMediaQueries[key]
  );
  const clonedEntries = pickedEntries.map(([key, style]) =&gt; [
    key,
    JSON.parse(JSON.stringify(style))
  ]);
  return Object.fromEntries(clonedEntries);
}
function getPseudoStyleNodes(node) {
  const {
    styles,
    selector,
    featureSelectors,
    name,
    elementName,
    mediaQuery,
    variationName
  } = node;
  const pseudoSelectors = name ? VALID_BLOCK_PSEUDO_SELECTORS[name] ?? [] : VALID_ELEMENT_PSEUDO_SELECTORS[elementName ?? &quot;&quot;] ?? [];
  if (!pseudoSelectors.length) {
    return [];
  }
  return pseudoSelectors.flatMap((pseudoSelector) =&gt; {
    const pseudoStyles = styles?.[pseudoSelector];
    if (!pseudoStyles || typeof pseudoStyles !== &quot;object&quot;) {
      return [];
    }
    return [
      {
        styles: JSON.parse(JSON.stringify(pseudoStyles)),
        selector,
        selectorSuffix: pseudoSelector,
        mediaQuery,
        featureSelectors: featureSelectors &amp;&amp; typeof featureSelectors !== &quot;string&quot; ? featureSelectors : void 0,
        name,
        elementName,
        variationName
      }
    ];
  });
}
function getResponsiveStyleNodes(node, responsiveMediaQueries) {
  const {
    styles,
    selector,
    fallbackGapValue,
    featureSelectors,
    hasLayoutSupport,
    layoutHasBlockGapSupport,
    layoutSelector,
    name,
    elementName,
    isStyleVariation,
    variationName
  } = node;
  if (!name &amp;&amp; !elementName) {
    return [];
  }
  return Object.entries(responsiveMediaQueries).flatMap(
    ([breakpointKey, mediaQuery]) =&gt; {
      const breakpointStyles = styles?.[breakpointKey];
      if (!breakpointStyles || typeof breakpointStyles !== &quot;object&quot;) {
        return [];
      }
      return [
        {
          styles: JSON.parse(JSON.stringify(breakpointStyles)),
          selector,
          mediaQuery,
          featureSelectors: featureSelectors &amp;&amp; typeof featureSelectors !== &quot;string&quot; ? featureSelectors : void 0,
          fallbackGapValue,
          hasLayoutSupport,
          name,
          elementName,
          isStyleVariation,
          variationName,
          layoutSelector,
          layoutHasBlockGapSupport
        }
      ];
    }
  );
}
function getElementStylesByName(styleNode, responsiveMediaQueries) {
  const elementStylesByName = { ...styleNode?.elements ?? {} };
  Object.keys(responsiveMediaQueries).forEach((breakpointKey) =&gt; {
    Object.entries(styleNode?.[breakpointKey]?.elements ?? {}).forEach(
      ([elementName, styles]) =&gt; {
        elementStylesByName[elementName] = {
          ...elementStylesByName[elementName] ?? {},
          [breakpointKey]: styles
        };
      }
    );
  });
  return elementStylesByName;
}
var getNodesWithStyles = (tree, blockSelectors) =&gt; {
  const nodes = [];
  if (!tree?.styles) {
    return nodes;
  }
  const responsiveMediaQueries = getResponsiveMediaQueries(tree);
  const styles = pickStyleKeys(tree.styles, responsiveMediaQueries);
  if (styles) {
    nodes.push({
      styles,
      selector: ROOT_BLOCK_SELECTOR,
      // Root selector (body) styles should not be wrapped in `:root where()` to keep
      // specificity at (0,0,1) and maintain backwards compatibility.
      skipSelectorWrapper: true
    });
  }
  Object.entries(import_blocks.__EXPERIMENTAL_ELEMENTS).forEach(([name, selector]) =&gt; {
    if (tree.styles?.elements?.[name]) {
      nodes.push({
        styles: tree.styles?.elements?.[name] ?? {},
        selector,
        elementName: name,
        // Top level elements that don&#039;t use a class name should not receive the
        // `:root :where()` wrapper to maintain backwards compatibility.
        skipSelectorWrapper: !ELEMENT_CLASS_NAMES[name]
      });
    }
  });
  Object.entries(tree.styles?.blocks ?? {}).forEach(
    ([blockName, node]) =&gt; {
      const blockStyles = pickStyleAndPseudoKeys(
        node,
        blockName,
        responsiveMediaQueries
      );
      const typedNode = node;
      const variationNodesToAdd = [];
      const variationStyleNodesToAdd = [];
      if (typedNode?.variations) {
        Object.entries(typedNode.variations).forEach(
          ([variationName, variation]) =&gt; {
            const typedVariation = variation;
            const variationStyles = pickStyleAndPseudoKeys(
              typedVariation,
              blockName,
              responsiveMediaQueries
            );
            if (typedVariation?.css) {
              variationStyles.css = typedVariation.css;
            }
            const variationSelector = typeof blockSelectors !== &quot;string&quot; ? blockSelectors[blockName]?.styleVariationSelectors?.[variationName] : void 0;
            if (variationSelector &amp;&amp; typeof blockSelectors !== &quot;string&quot;) {
              const blockSelector = blockSelectors[blockName];
              variationStyleNodesToAdd.push({
                styles: variationStyles,
                selector: variationSelector,
                featureSelectors: blockSelector?.featureSelectors,
                fallbackGapValue: blockSelector?.fallbackGapValue,
                hasLayoutSupport: blockSelector?.hasLayoutSupport,
                isStyleVariation: true,
                variationName,
                layoutSelector: variationSelector + blockSelector.selector,
                layoutHasBlockGapSupport: true,
                name: blockName
              });
            }
            Object.entries(
              getElementStylesByName(
                typedVariation,
                responsiveMediaQueries
              )
            ).forEach(([element, elementStyles]) =&gt; {
              if (elementStyles &amp;&amp; import_blocks.__EXPERIMENTAL_ELEMENTS[element]) {
                variationNodesToAdd.push({
                  styles: elementStyles,
                  selector: scopeSelector(
                    variationSelector,
                    import_blocks.__EXPERIMENTAL_ELEMENTS[element]
                  ),
                  elementName: element,
                  isStyleVariation: true
                });
              }
            });
            Object.entries(typedVariation?.blocks ?? {}).forEach(
              ([
                variationBlockName,
                variationBlockStyles
              ]) =&gt; {
                const variationBlockSelector = typeof blockSelectors !== &quot;string&quot; ? scopeSelector(
                  variationSelector,
                  blockSelectors[variationBlockName]?.selector
                ) : void 0;
                const variationDuotoneSelector = typeof blockSelectors !== &quot;string&quot; ? scopeSelector(
                  variationSelector,
                  blockSelectors[variationBlockName]?.duotoneSelector
                ) : void 0;
                const variationFeatureSelectors = typeof blockSelectors !== &quot;string&quot; ? scopeFeatureSelectors(
                  variationSelector,
                  blockSelectors[variationBlockName]?.featureSelectors ?? {}
                ) : void 0;
                const variationBlockStyleNodes = pickStyleAndPseudoKeys(
                  variationBlockStyles,
                  variationBlockName,
                  responsiveMediaQueries
                );
                if (variationBlockStyles?.css) {
                  variationBlockStyleNodes.css = variationBlockStyles.css;
                }
                if (!variationBlockSelector || typeof blockSelectors === &quot;string&quot;) {
                  return;
                }
                variationNodesToAdd.push({
                  selector: variationBlockSelector,
                  name: variationBlockName,
                  isStyleVariation: true,
                  duotoneSelector: variationDuotoneSelector,
                  featureSelectors: variationFeatureSelectors,
                  fallbackGapValue: blockSelectors[variationBlockName]?.fallbackGapValue,
                  hasLayoutSupport: blockSelectors[variationBlockName]?.hasLayoutSupport,
                  styles: variationBlockStyleNodes
                });
                Object.entries(
                  getElementStylesByName(
                    variationBlockStyles,
                    responsiveMediaQueries
                  )
                ).forEach(
                  ([
                    variationBlockElement,
                    variationBlockElementStyles
                  ]) =&gt; {
                    if (variationBlockElementStyles &amp;&amp; import_blocks.__EXPERIMENTAL_ELEMENTS[variationBlockElement]) {
                      variationNodesToAdd.push({
                        styles: variationBlockElementStyles,
                        selector: scopeSelector(
                          variationBlockSelector,
                          import_blocks.__EXPERIMENTAL_ELEMENTS[variationBlockElement]
                        ),
                        elementName: variationBlockElement,
                        isStyleVariation: true
                      });
                    }
                  }
                );
              }
            );
          }
        );
      }
      if (typeof blockSelectors !== &quot;string&quot; &amp;&amp; blockSelectors?.[blockName]?.selector) {
        nodes.push({
          duotoneSelector: blockSelectors[blockName].duotoneSelector,
          fallbackGapValue: blockSelectors[blockName].fallbackGapValue,
          hasLayoutSupport: blockSelectors[blockName].hasLayoutSupport,
          selector: blockSelectors[blockName].selector,
          styles: blockStyles,
          featureSelectors: blockSelectors[blockName].featureSelectors,
          name: blockName
        });
      }
      nodes.push(...variationStyleNodesToAdd);
      Object.entries(
        getElementStylesByName(typedNode, responsiveMediaQueries)
      ).forEach(([elementName, value]) =&gt; {
        if (typeof blockSelectors !== &quot;string&quot; &amp;&amp; value &amp;&amp; blockSelectors?.[blockName] &amp;&amp; import_blocks.__EXPERIMENTAL_ELEMENTS[elementName]) {
          nodes.push({
            styles: value,
            selector: blockSelectors[blockName]?.selector.split(&quot;,&quot;).map((sel) =&gt; {
              const elementSelectors = import_blocks.__EXPERIMENTAL_ELEMENTS[elementName].split(&quot;,&quot;);
              return elementSelectors.map(
                (elementSelector) =&gt; sel + &quot; &quot; + elementSelector
              );
            }).join(&quot;,&quot;),
            elementName
          });
        }
      });
      nodes.push(...variationNodesToAdd);
    }
  );
  return nodes;
};
var getNodesWithSettings = (tree, blockSelectors) =&gt; {
  const nodes = [];
  if (!tree?.settings) {
    return nodes;
  }
  const pickPresets = (treeToPickFrom) =&gt; {
    let presets2 = {};
    PRESET_METADATA.forEach(({ path }) =&gt; {
      const value = getValueFromObjectPath(treeToPickFrom, path, false);
      if (value !== false) {
        presets2 = setImmutably(presets2, path, value);
      }
    });
    return presets2;
  };
  const presets = pickPresets(tree.settings);
  const custom = tree.settings?.custom;
  if (Object.keys(presets).length &gt; 0 || custom) {
    nodes.push({
      presets,
      custom,
      selector: ROOT_CSS_PROPERTIES_SELECTOR
    });
  }
  Object.entries(tree.settings?.blocks ?? {}).forEach(
    ([blockName, node]) =&gt; {
      const blockCustom = node.custom;
      if (typeof blockSelectors === &quot;string&quot; || !blockSelectors[blockName]) {
        return;
      }
      const blockPresets = pickPresets(node);
      if (Object.keys(blockPresets).length &gt; 0 || blockCustom) {
        nodes.push({
          presets: blockPresets,
          custom: blockCustom,
          selector: blockSelectors[blockName]?.selector,
          featureSelectors: blockSelectors[blockName]?.featureSelectors
        });
      }
    }
  );
  return nodes;
};
function resolveFeatureSelector(featureSelectors, featureKey, fallback) {
  if (!featureSelectors || typeof featureSelectors === &quot;string&quot;) {
    return fallback;
  }
  const feature = featureSelectors[featureKey];
  if (typeof feature === &quot;string&quot;) {
    return feature;
  }
  if (typeof feature === &quot;object&quot; &amp;&amp; feature.root) {
    return feature.root;
  }
  return fallback;
}
function getPresetVarDeclarations(presets, mergedSettings, { path, valueKey, valueFunc, cssVarInfix }) {
  const presetByOrigin = getValueFromObjectPath(
    presets,
    path,
    []
  );
  const declarations = [];
  for (const origin of [&quot;default&quot;, &quot;theme&quot;, &quot;custom&quot;]) {
    if (!presetByOrigin[origin]) {
      continue;
    }
    for (const value of presetByOrigin[origin]) {
      const slug = kebabCase(value.slug);
      if (valueKey &amp;&amp; !valueFunc) {
        declarations.push(
          `--wp--preset--${cssVarInfix}--${slug}: ${value[valueKey]}`
        );
      } else if (valueFunc &amp;&amp; typeof valueFunc === &quot;function&quot;) {
        declarations.push(
          `--wp--preset--${cssVarInfix}--${slug}: ${valueFunc(
            value,
            mergedSettings
          )}`
        );
      }
    }
  }
  return declarations;
}
var generateCustomProperties = (tree, blockSelectors) =&gt; {
  const nodes = getNodesWithSettings(tree, blockSelectors);
  let ruleset = &quot;&quot;;
  for (const { presets, custom, selector, featureSelectors } of nodes) {
    const defaultSelector = selector;
    const varsBySelector = {
      [defaultSelector]: []
    };
    if (tree?.settings) {
      for (const metadata of PRESET_METADATA) {
        const declarations = getPresetVarDeclarations(
          presets,
          tree.settings,
          metadata
        );
        if (declarations.length === 0) {
          continue;
        }
        const target = resolveFeatureSelector(
          featureSelectors,
          metadata.path[0],
          defaultSelector
        );
        if (!varsBySelector[target]) {
          varsBySelector[target] = [];
        }
        varsBySelector[target].push(...declarations);
      }
    }
    const customProps = flattenTree(custom, &quot;--wp--custom--&quot;, &quot;--&quot;);
    if (customProps.length &gt; 0) {
      varsBySelector[defaultSelector].push(...customProps);
    }
    for (const [ruleSelector, declarations] of Object.entries(
      varsBySelector
    )) {
      if (declarations.length &gt; 0) {
        ruleset += `${ruleSelector}{${declarations.join(&quot;;&quot;)};}`;
      }
    }
  }
  return ruleset;
};
function renderStylesNode(node, {
  tree,
  useRootPaddingAlign,
  disableLayoutStyles,
  hasBlockGapSupport,
  hasFallbackGapSupport,
  disableRootPadding
}) {
  const {
    selector,
    selectorSuffix,
    mediaQuery,
    duotoneSelector,
    styles,
    fallbackGapValue,
    hasLayoutSupport,
    featureSelectors,
    layoutSelector,
    layoutHasBlockGapSupport,
    skipSelectorWrapper,
    name,
    variationName
  } = node;
  let ruleset = &quot;&quot;;
  const effectiveSelector = selectorSuffix ? appendToSelector(selector, selectorSuffix) : selector;
  if (featureSelectors &amp;&amp; typeof featureSelectors !== &quot;string&quot;) {
    let featureDeclarations = getFeatureDeclarations(
      featureSelectors,
      styles
    );
    featureDeclarations = updateParagraphTextIndentSelector(
      featureDeclarations,
      tree.settings,
      name
    );
    featureDeclarations = updateButtonWidthDeclarations(
      featureDeclarations,
      tree.settings
    );
    Object.entries(featureDeclarations).forEach(
      ([featureSelector, declarations]) =&gt; {
        if (declarations.length) {
          let selectorForRule = variationName ? getBlockStyleVariationFeatureSelector(
            variationName,
            featureSelector
          ) : featureSelector;
          selectorForRule = selectorSuffix ? appendToSelector(selectorForRule, selectorSuffix) : selectorForRule;
          const rules = declarations.join(&quot;;&quot;);
          ruleset += `:root :where(${selectorForRule}){${rules};}`;
        }
      }
    );
  }
  if (duotoneSelector) {
    const duotoneStyles = {};
    if (styles?.filter) {
      duotoneStyles.filter = styles.filter;
      delete styles.filter;
    }
    const duotoneDeclarations = getStylesDeclarations(duotoneStyles);
    if (duotoneDeclarations.length) {
      ruleset += `${duotoneSelector}{${duotoneDeclarations.join(
        &quot;;&quot;
      )};}`;
    }
  }
  const selectorForLayout = layoutSelector ?? effectiveSelector;
  const hasBlockGapSupportForLayout = layoutHasBlockGapSupport ?? hasBlockGapSupport;
  if (!disableLayoutStyles &amp;&amp; (ROOT_BLOCK_SELECTOR === selectorForLayout || hasLayoutSupport)) {
    ruleset += getLayoutStyles({
      style: styles,
      selector: selectorForLayout,
      hasBlockGapSupport: hasBlockGapSupportForLayout,
      hasFallbackGapSupport,
      fallbackGapValue
    });
  }
  const styleDeclarations = getStylesDeclarations(
    styles,
    effectiveSelector,
    useRootPaddingAlign,
    tree,
    disableRootPadding
  );
  if (styleDeclarations?.length) {
    const generalSelector = skipSelectorWrapper ? effectiveSelector : `:root :where(${effectiveSelector})`;
    ruleset += `${generalSelector}{${styleDeclarations.join(&quot;;&quot;)};}`;
  }
  if (styles?.css) {
    ruleset += processCSSNesting(
      styles.css,
      `:root :where(${effectiveSelector})`
    );
  }
  if (mediaQuery &amp;&amp; ruleset) {
    return `${mediaQuery}{${ruleset}}`;
  }
  return ruleset;
}
var transformToStyles = (tree, blockSelectors, hasBlockGapSupport, hasFallbackGapSupport, disableLayoutStyles = false, disableRootPadding = false, styleOptions = {}) =&gt; {
  const options = {
    blockGap: true,
    blockStyles: true,
    layoutStyles: true,
    marginReset: true,
    presets: true,
    rootPadding: true,
    variationStyles: false,
    ...styleOptions
  };
  const normalizedTree = normalizeStyleStateAliases(tree);
  const nodesWithStyles = getNodesWithStyles(
    normalizedTree,
    blockSelectors
  );
  const nodesWithSettings = getNodesWithSettings(
    normalizedTree,
    blockSelectors
  );
  const useRootPaddingAlign = normalizedTree?.settings?.useRootPaddingAwareAlignments;
  const { contentSize, wideSize } = normalizedTree?.settings?.layout || {};
  const hasBodyStyles = options.marginReset || options.rootPadding || options.layoutStyles;
  let ruleset = &quot;&quot;;
  if (options.presets &amp;&amp; (contentSize || wideSize)) {
    ruleset += `${ROOT_CSS_PROPERTIES_SELECTOR} {`;
    ruleset = contentSize ? ruleset + ` --wp--style--global--content-size: ${contentSize};` : ruleset;
    ruleset = wideSize ? ruleset + ` --wp--style--global--wide-size: ${wideSize};` : ruleset;
    ruleset += &quot;}&quot;;
  }
  if (hasBodyStyles) {
    ruleset += &quot;:where(body) {margin: 0;&quot;;
    if (options.rootPadding &amp;&amp; useRootPaddingAlign) {
      ruleset += `padding-right: 0; padding-left: 0; padding-top: var(--wp--style--root--padding-top); padding-bottom: var(--wp--style--root--padding-bottom) }
				.has-global-padding { padding-right: var(--wp--style--root--padding-right); padding-left: var(--wp--style--root--padding-left); }
				.has-global-padding &gt; .alignfull { margin-right: calc(var(--wp--style--root--padding-right) * -1); margin-left: calc(var(--wp--style--root--padding-left) * -1); }
				.has-global-padding :where(:not(.alignfull.is-layout-flow) &gt; .has-global-padding:not(.wp-block-block, .alignfull)) { padding-right: 0; padding-left: 0; }
				.has-global-padding :where(:not(.alignfull.is-layout-flow) &gt; .has-global-padding:not(.wp-block-block, .alignfull)) &gt; .alignfull { margin-left: 0; margin-right: 0;
				`;
    }
    ruleset += &quot;}&quot;;
  }
  if (options.blockStyles) {
    const responsiveMediaQueries = getResponsiveMediaQueries(tree);
    nodesWithStyles.forEach((node) =&gt; {
      if (node.isStyleVariation &amp;&amp; !options.variationStyles) {
        return;
      }
      const responsiveNodes = getResponsiveStyleNodes(
        node,
        responsiveMediaQueries
      );
      [
        node,
        ...responsiveNodes,
        ...getPseudoStyleNodes(node),
        ...responsiveNodes.flatMap(getPseudoStyleNodes)
      ].forEach((expandedNode) =&gt; {
        ruleset += renderStylesNode(expandedNode, {
          tree: normalizedTree,
          useRootPaddingAlign,
          disableLayoutStyles,
          hasBlockGapSupport,
          hasFallbackGapSupport,
          disableRootPadding
        });
      });
    });
  }
  if (options.layoutStyles) {
    ruleset = ruleset + &quot;.wp-site-blocks &gt; .alignleft { float: left; margin-right: 2em; }&quot;;
    ruleset = ruleset + &quot;.wp-site-blocks &gt; .alignright { float: right; margin-left: 2em; }&quot;;
    ruleset = ruleset + &quot;.wp-site-blocks &gt; .aligncenter { justify-content: center; margin-left: auto; margin-right: auto; }&quot;;
  }
  if (options.blockGap &amp;&amp; hasBlockGapSupport) {
    const gapValue = getGapCSSValue(normalizedTree?.styles?.spacing?.blockGap) || &quot;0.5em&quot;;
    ruleset = ruleset + `:root :where(.wp-site-blocks) &gt; * { margin-block-start: ${gapValue}; margin-block-end: 0; }`;
    ruleset = ruleset + &quot;:root :where(.wp-site-blocks) &gt; :first-child { margin-block-start: 0; }&quot;;
    ruleset = ruleset + &quot;:root :where(.wp-site-blocks) &gt; :last-child { margin-block-end: 0; }&quot;;
  }
  if (options.presets) {
    nodesWithSettings.forEach(({ selector, presets }) =&gt; {
      if (ROOT_BLOCK_SELECTOR === selector || ROOT_CSS_PROPERTIES_SELECTOR === selector) {
        selector = &quot;&quot;;
      }
      const classes = getPresetsClasses(selector, presets);
      if (classes.length &gt; 0) {
        ruleset += classes;
      }
    });
  }
  return ruleset;
};
function generateSvgFilters(tree, blockSelectors) {
  const nodesWithSettings = getNodesWithSettings(tree, blockSelectors);
  return nodesWithSettings.flatMap(({ presets }) =&gt; {
    return getPresetsSvgFilters(presets);
  });
}
var getSelectorsConfig = (blockType, rootSelector) =&gt; {
  if (blockType?.selectors &amp;&amp; Object.keys(blockType.selectors).length &gt; 0) {
    return blockType.selectors;
  }
  const config = {
    root: rootSelector
  };
  Object.entries(BLOCK_SUPPORT_FEATURE_LEVEL_SELECTORS).forEach(
    ([featureKey, featureName]) =&gt; {
      const featureSelector = getBlockSelector(blockType, featureKey);
      if (featureSelector) {
        config[featureName] = featureSelector;
      }
    }
  );
  return config;
};
var getBlockSelectors = (blockTypes, variationInstanceId) =&gt; {
  const { getBlockStyles } = (0, import_data2.select)(import_blocks.store);
  const result = {};
  blockTypes.forEach((blockType) =&gt; {
    const name = blockType.name;
    const selector = getBlockSelector(blockType);
    if (!selector) {
      return;
    }
    let duotoneSelector = getBlockSelector(blockType, &quot;filter.duotone&quot;);
    if (!duotoneSelector) {
      const rootSelector = getBlockSelector(blockType);
      const duotoneSupport = (0, import_blocks.getBlockSupport)(
        blockType,
        &quot;color.__experimentalDuotone&quot;,
        false
      );
      if (typeof duotoneSupport === &quot;string&quot; &amp;&amp; rootSelector) {
        duotoneSelector = scopeSelector(rootSelector, duotoneSupport);
      }
    }
    const hasLayoutSupport = !!blockType?.supports?.layout || !!blockType?.supports?.__experimentalLayout;
    const fallbackGapValue = (
      // @ts-expect-error
      blockType?.supports?.spacing?.blockGap?.__experimentalDefault
    );
    const blockStyleVariations = getBlockStyles(name);
    const styleVariationSelectors = {};
    blockStyleVariations?.forEach((variation) =&gt; {
      const variationSuffix = variationInstanceId ? `-${variationInstanceId}` : &quot;&quot;;
      const variationName = `${variation.name}${variationSuffix}`;
      const styleVariationSelector = getBlockStyleVariationSelector(
        variationName,
        selector
      );
      styleVariationSelectors[variationName] = styleVariationSelector;
    });
    const featureSelectors = getSelectorsConfig(blockType, selector);
    result[name] = {
      duotoneSelector: duotoneSelector ?? void 0,
      fallbackGapValue,
      featureSelectors: Object.keys(featureSelectors).length ? featureSelectors : void 0,
      hasLayoutSupport,
      name,
      selector,
      styleVariationSelectors: blockStyleVariations?.length ? styleVariationSelectors : void 0
    };
  });
  return result;
};
function updateConfigWithSeparator(config) {
  const blocks = config.styles?.blocks;
  const separatorBlock = blocks?.[&quot;core/separator&quot;];
  const needsSeparatorStyleUpdate = separatorBlock &amp;&amp; separatorBlock.color?.background &amp;&amp; !separatorBlock.color?.text &amp;&amp; !separatorBlock.border?.color;
  if (needsSeparatorStyleUpdate) {
    return {
      ...config,
      styles: {
        ...config.styles,
        blocks: {
          ...blocks,
          &quot;core/separator&quot;: {
            ...separatorBlock,
            color: {
              ...separatorBlock.color,
              text: separatorBlock.color?.background
            }
          }
        }
      }
    };
  }
  return config;
}
function processCSSNesting(css, blockSelector) {
  let processedCSS = &quot;&quot;;
  if (!css || css.trim() === &quot;&quot;) {
    return processedCSS;
  }
  const parts = css.split(&quot;&amp;&quot;);
  parts.forEach((part) =&gt; {
    if (!part || part.trim() === &quot;&quot;) {
      return;
    }
    const isRootCss = !part.includes(&quot;{&quot;);
    if (isRootCss) {
      processedCSS += `:root :where(${blockSelector}){${part.trim()}}`;
    } else {
      const splitPart = part.replace(&quot;}&quot;, &quot;&quot;).split(&quot;{&quot;);
      if (splitPart.length !== 2) {
        return;
      }
      const [nestedSelector, cssValue] = splitPart;
      const matches = nestedSelector.match(/([&gt;+~\s]*::[a-zA-Z-]+)/);
      const pseudoPart = matches ? matches[1] : &quot;&quot;;
      const withoutPseudoElement = matches ? nestedSelector.replace(pseudoPart, &quot;&quot;).trim() : nestedSelector.trim();
      let combinedSelector;
      if (withoutPseudoElement === &quot;&quot;) {
        combinedSelector = blockSelector;
      } else {
        combinedSelector = nestedSelector.startsWith(&quot; &quot;) ? scopeSelector(blockSelector, withoutPseudoElement) : appendToSelector(blockSelector, withoutPseudoElement);
      }
      processedCSS += `:root :where(${combinedSelector})${pseudoPart}{${cssValue.trim()}}`;
    }
  });
  return processedCSS;
}
function generateGlobalStyles(config = {}, blockTypes = [], options = {}) {
  const {
    hasBlockGapSupport: hasBlockGapSupportOption,
    hasFallbackGapSupport: hasFallbackGapSupportOption,
    disableLayoutStyles = false,
    disableRootPadding = false,
    styleOptions = {}
  } = options;
  const blocks = blockTypes.length &gt; 0 ? blockTypes : (0, import_blocks.getBlockTypes)();
  const blockGap = getSetting(config, &quot;spacing.blockGap&quot;);
  const hasBlockGapSupport = hasBlockGapSupportOption ?? blockGap !== null;
  const hasFallbackGapSupport = hasFallbackGapSupportOption ?? !hasBlockGapSupport;
  if (!config?.styles || !config?.settings) {
    return [[], {}];
  }
  const updatedConfig = updateConfigWithSeparator(config);
  const blockSelectors = getBlockSelectors(blocks);
  const customProperties = generateCustomProperties(
    updatedConfig,
    blockSelectors
  );
  const globalStyles = transformToStyles(
    updatedConfig,
    blockSelectors,
    hasBlockGapSupport,
    hasFallbackGapSupport,
    disableLayoutStyles,
    disableRootPadding,
    styleOptions
  );
  const svgs = generateSvgFilters(updatedConfig, blockSelectors);
  const styles = [
    {
      css: customProperties,
      isGlobalStyles: true
    },
    {
      css: globalStyles,
      isGlobalStyles: true
    },
    // Load custom CSS in own stylesheet so that any invalid CSS entered in the input won&#039;t break all the global styles in the editor.
    {
      css: updatedConfig?.styles?.css ?? &quot;&quot;,
      isGlobalStyles: true
    },
    {
      assets: svgs,
      __unstableType: &quot;svgs&quot;,
      isGlobalStyles: true
    }
  ];
  blocks.forEach((blockType) =&gt; {
    const blockStyles = updatedConfig?.styles?.blocks?.[blockType.name];
    if (blockStyles?.css) {
      const { featureSelectors } = blockSelectors[blockType.name];
      const cssFeatureSelector = typeof featureSelectors === &quot;object&quot; ? featureSelectors?.css : void 0;
      let resolvedCssSelector;
      if (typeof cssFeatureSelector === &quot;string&quot;) {
        resolvedCssSelector = cssFeatureSelector;
      } else if (typeof cssFeatureSelector === &quot;object&quot;) {
        resolvedCssSelector = cssFeatureSelector?.root;
      }
      const selector = resolvedCssSelector ?? blockSelectors[blockType.name].selector;
      styles.push({
        css: processCSSNesting(blockStyles.css, selector),
        isGlobalStyles: true
      });
    }
  });
  return [styles, updatedConfig.settings];
}

// packages/lazy-editor/build-module/hooks/use-editor-settings.mjs
var import_core_data3 = __toESM(require_core_data(), 1);
var import_element2 = __toESM(require_element(), 1);
var import_data4 = __toESM(require_data(), 1);

// packages/lazy-editor/build-module/hooks/use-global-styles.mjs
var import_core_data2 = __toESM(require_core_data(), 1);
var import_data3 = __toESM(require_data(), 1);
var import_element = __toESM(require_element(), 1);
function useUserGlobalStyles(id) {
  const { userGlobalStyles } = (0, import_data3.useSelect)(
    (select2) =&gt; {
      const { getEntityRecord, getEditedEntityRecord, canUser } = select2(import_core_data2.store);
      const userCanEditGlobalStyles = canUser(&quot;update&quot;, {
        kind: &quot;root&quot;,
        name: &quot;globalStyles&quot;,
        id
      });
      let record;
      if (
        /*
         * Test that the OPTIONS request for user capabilities is complete
         * before fetching the global styles entity record.
         * This is to avoid fetching the global styles entity unnecessarily.
         */
        typeof userCanEditGlobalStyles === &quot;boolean&quot;
      ) {
        if (userCanEditGlobalStyles) {
          record = getEditedEntityRecord(
            &quot;root&quot;,
            &quot;globalStyles&quot;,
            id
          );
        } else {
          record = getEntityRecord(&quot;root&quot;, &quot;globalStyles&quot;, id, {
            context: &quot;view&quot;
          });
        }
      }
      return {
        userGlobalStyles: record
      };
    },
    [id]
  );
  return (0, import_element.useMemo)(() =&gt; {
    if (!userGlobalStyles) {
      return {
        user: void 0
      };
    }
    const user = userGlobalStyles;
    return {
      user
    };
  }, [userGlobalStyles]);
}

// packages/lazy-editor/build-module/lock-unlock.mjs
var import_private_apis = __toESM(require_private_apis(), 1);
var { unlock } = (0, import_private_apis.__dangerousOptInToUnstableAPIsOnlyForCoreModules)(
  &quot;I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.&quot;,
  &quot;@wordpress/lazy-editor&quot;
);

// packages/lazy-editor/build-module/hooks/use-editor-settings.mjs
function useEditorSettings({ stylesId }) {
  const { editorSettings } = (0, import_data4.useSelect)(
    (select2) =&gt; ({
      editorSettings: unlock(
        select2(import_core_data3.store)
      ).getEditorSettings()
    }),
    []
  );
  const { user: globalStyles } = useUserGlobalStyles(stylesId);
  const [globalStylesCSS] = generateGlobalStyles(globalStyles);
  const hasEditorSettings = !!editorSettings;
  const styles = (0, import_element2.useMemo)(() =&gt; {
    if (!hasEditorSettings) {
      return [];
    }
    return [
      ...editorSettings?.styles ?? [],
      ...globalStylesCSS
    ];
  }, [hasEditorSettings, editorSettings?.styles, globalStylesCSS]);
  return {
    isReady: hasEditorSettings,
    editorSettings: (0, import_element2.useMemo)(
      () =&gt; ({
        ...editorSettings ?? {},
        styles
      }),
      [editorSettings, styles]
    )
  };
}

// packages/asset-loader/build-module/index.mjs
function injectImportMap(scriptModules) {
  if (!scriptModules || Object.keys(scriptModules).length === 0) {
    return;
  }
  const existingMapElement = document.querySelector(
    &quot;script#wp-importmap[type=importmap]&quot;
  );
  if (existingMapElement) {
    try {
      const existingMap = JSON.parse(existingMapElement.text);
      if (!existingMap.imports) {
        existingMap.imports = {};
      }
      existingMap.imports = {
        ...existingMap.imports,
        ...scriptModules
      };
      existingMapElement.text = JSON.stringify(existingMap, null, 2);
    } catch (error) {
      console.error(&quot;Failed to parse or update import map:&quot;, error);
    }
  } else {
    const script = document.createElement(&quot;script&quot;);
    script.type = &quot;importmap&quot;;
    script.id = &quot;wp-importmap&quot;;
    script.text = JSON.stringify(
      {
        imports: scriptModules
      },
      null,
      2
    );
    document.head.appendChild(script);
  }
}
function loadStylesheet(handle, styleData) {
  return new Promise((resolve) =&gt; {
    if (!styleData.src) {
      resolve();
      return;
    }
    const existingLink = document.getElementById(handle + &quot;-css&quot;);
    if (existingLink) {
      resolve();
      return;
    }
    const link = document.createElement(&quot;link&quot;);
    link.rel = &quot;stylesheet&quot;;
    link.href = styleData.src + (styleData.version ? &quot;?ver=&quot; + styleData.version : &quot;&quot;);
    link.id = handle + &quot;-css&quot;;
    link.media = styleData.media || &quot;all&quot;;
    link.onload = () =&gt; resolve();
    link.onerror = () =&gt; {
      console.error(`Failed to load stylesheet: ${handle}`);
      resolve();
    };
    document.head.appendChild(link);
  });
}
function loadScript(handle, scriptData) {
  if (!scriptData.src) {
    const marker = document.createElement(&quot;script&quot;);
    marker.id = handle + &quot;-js&quot;;
    marker.textContent = &quot;// Processed: &quot; + handle;
    return marker;
  }
  const script = document.createElement(&quot;script&quot;);
  script.src = scriptData.src + (scriptData.version ? &quot;?ver=&quot; + scriptData.version : &quot;&quot;);
  script.id = handle + &quot;-js&quot;;
  script.async = false;
  return script;
}
function injectInlineStyle(handle, inlineStyle, position) {
  let styleContent = &quot;&quot;;
  if (Array.isArray(inlineStyle)) {
    styleContent = inlineStyle.join(&quot;\n&quot;);
  } else if (typeof inlineStyle === &quot;string&quot;) {
    styleContent = inlineStyle;
  }
  if (styleContent &amp;&amp; styleContent.trim()) {
    const styleId = handle + &quot;-&quot; + position + &quot;-inline-css&quot;;
    if (!document.getElementById(styleId)) {
      const style = document.createElement(&quot;style&quot;);
      style.id = styleId;
      style.textContent = styleContent.trim();
      document.head.appendChild(style);
    }
  }
}
function injectInlineScript(handle, inlineScript, position) {
  let scriptContent = inlineScript;
  if (Array.isArray(scriptContent)) {
    scriptContent = scriptContent.join(&quot;\n&quot;);
  }
  const script = document.createElement(&quot;script&quot;);
  script.id = handle + &quot;-&quot; + position + &quot;-js&quot;;
  script.textContent = scriptContent.trim();
  return script;
}
function buildDependencyOrderedList(assetsData) {
  const visited = /* @__PURE__ */ new Set();
  const visiting = /* @__PURE__ */ new Set();
  const orderedList = [];
  function visit(handle) {
    if (visited.has(handle)) {
      return;
    }
    if (visiting.has(handle)) {
      console.warn(
        `Circular dependency detected for handle: ${handle}`
      );
      return;
    }
    visiting.add(handle);
    if (assetsData[handle]) {
      const deps = assetsData[handle].deps || [];
      deps.forEach((dep) =&gt; {
        if (assetsData[dep]) {
          visit(dep);
        }
      });
    }
    visiting.delete(handle);
    visited.add(handle);
    if (assetsData[handle]) {
      orderedList.push(handle);
    }
  }
  Object.keys(assetsData).forEach((handle) =&gt; {
    visit(handle);
  });
  return orderedList;
}
async function performScriptLoad(scriptElements, destination) {
  let parallel = [];
  for (const scriptElement of scriptElements) {
    if (scriptElement.src) {
      const loader = Promise.withResolvers();
      scriptElement.onload = () =&gt; loader.resolve();
      scriptElement.onerror = () =&gt; {
        console.error(`Failed to load script: ${scriptElement.id}`);
        loader.resolve();
      };
      parallel.push(loader.promise);
    } else {
      await Promise.all(parallel);
      parallel = [];
    }
    destination.appendChild(scriptElement);
  }
  await Promise.all(parallel);
  parallel = [];
}
async function loadAssets(scriptsData, inlineScripts, stylesData, inlineStyles, htmlTemplates, scriptModules) {
  if (scriptModules) {
    injectImportMap(scriptModules);
  }
  const orderedStyles = buildDependencyOrderedList(stylesData);
  const orderedScripts = buildDependencyOrderedList(scriptsData);
  const stylePromises = [];
  for (const handle of orderedStyles) {
    const beforeInline = inlineStyles.before?.[handle];
    if (beforeInline) {
      injectInlineStyle(handle, beforeInline, &quot;before&quot;);
    }
    stylePromises.push(loadStylesheet(handle, stylesData[handle]));
    const afterInline = inlineStyles.after?.[handle];
    if (afterInline) {
      injectInlineStyle(handle, afterInline, &quot;after&quot;);
    }
  }
  const scriptElements = [];
  for (const handle of orderedScripts) {
    const beforeInline = inlineScripts.before?.[handle];
    if (beforeInline) {
      scriptElements.push(
        injectInlineScript(handle, beforeInline, &quot;before&quot;)
      );
    }
    scriptElements.push(loadScript(handle, scriptsData[handle]));
    const afterInline = inlineScripts.after?.[handle];
    if (afterInline) {
      scriptElements.push(
        injectInlineScript(handle, afterInline, &quot;after&quot;)
      );
    }
  }
  const scriptsPromise = performScriptLoad(scriptElements, document.body);
  await Promise.all([Promise.all(stylePromises), scriptsPromise]);
  if (htmlTemplates &amp;&amp; htmlTemplates.length &gt; 0) {
    htmlTemplates.forEach((templateHtml) =&gt; {
      const scriptMatch = templateHtml.match(
        /&lt;script([^&gt;]*)&gt;(.*?)&lt;\/script&gt;/is
      );
      if (scriptMatch) {
        const attributes = scriptMatch[1];
        const content = scriptMatch[2];
        const script = document.createElement(&quot;script&quot;);
        const idMatch = attributes.match(/id=[&quot;&#039;]([^&quot;&#039;]+)[&quot;&#039;]/);
        if (idMatch) {
          script.id = idMatch[1];
        }
        const typeMatch = attributes.match(/type=[&quot;&#039;]([^&quot;&#039;]+)[&quot;&#039;]/);
        if (typeMatch) {
          script.type = typeMatch[1];
        }
        script.textContent = content;
        document.body.appendChild(script);
      }
    });
  }
}
var index_default = loadAssets;

// packages/lazy-editor/build-module/hooks/use-editor-assets.mjs
var import_core_data4 = __toESM(require_core_data(), 1);
var import_element3 = __toESM(require_element(), 1);
var import_data5 = __toESM(require_data(), 1);
var loadAssetsPromise;
async function loadEditorAssets() {
  const load = async () =&gt; {
    const editorAssets = await unlock(
      (0, import_data5.resolveSelect)(import_core_data4.store)
    ).getEditorAssets();
    await index_default(
      editorAssets.scripts || {},
      editorAssets.inline_scripts || { before: {}, after: {} },
      editorAssets.styles || {},
      editorAssets.inline_styles || { before: {}, after: {} },
      editorAssets.html_templates || [],
      editorAssets.script_modules || {}
    );
  };
  if (!loadAssetsPromise) {
    loadAssetsPromise = load();
  }
  return loadAssetsPromise;
}
function useEditorAssets() {
  const editorAssets = (0, import_data5.useSelect)((select2) =&gt; {
    return unlock(select2(import_core_data4.store)).getEditorAssets();
  }, []);
  const [assetsLoaded, setAssetsLoaded] = (0, import_element3.useState)(false);
  (0, import_element3.useEffect)(() =&gt; {
    if (editorAssets &amp;&amp; !assetsLoaded) {
      loadEditorAssets().then(() =&gt; {
        setAssetsLoaded(true);
      }).catch((error) =&gt; {
        console.error(&quot;Failed to load editor assets:&quot;, error);
      });
    }
  }, [editorAssets, assetsLoaded]);
  return {
    isReady: !!editorAssets &amp;&amp; assetsLoaded,
    assetsLoaded
  };
}

// packages/lazy-editor/build-module/components/editor/index.mjs
var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
var { Editor: PrivateEditor, BackButton } = unlock(import_editor.privateApis);
function Editor({
  postType,
  postId,
  settings,
  backButton
}) {
  const homePage = (0, import_data6.useSelect)(
    (select2) =&gt; {
      if (postType || postId) {
        return null;
      }
      const { getHomePage } = unlock(select2(import_core_data5.store));
      return getHomePage();
    },
    [postType, postId]
  );
  const resolvedPostType = postType || homePage?.postType;
  const resolvedPostId = postId || homePage?.postId;
  const templateId = (0, import_data6.useSelect)(
    (select2) =&gt; {
      if (!resolvedPostType || !resolvedPostId) {
        return void 0;
      }
      if (resolvedPostType === &quot;wp_template&quot;) {
        return resolvedPostId;
      }
      return unlock(select2(import_core_data5.store)).getTemplateId(
        resolvedPostType,
        resolvedPostId
      );
    },
    [resolvedPostType, resolvedPostId]
  );
  const stylesId = useStylesId({ templateId });
  const { isReady: settingsReady, editorSettings } = useEditorSettings({
    stylesId
  });
  const { isReady: assetsReady } = useEditorAssets();
  const finalSettings = (0, import_element4.useMemo)(
    () =&gt; ({
      ...editorSettings,
      ...settings
    }),
    [editorSettings, settings]
  );
  if (!settingsReady || !assetsReady) {
    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
      &quot;div&quot;,
      {
        style: {
          display: &quot;flex&quot;,
          justifyContent: &quot;center&quot;,
          alignItems: &quot;center&quot;,
          height: &quot;100vh&quot;
        },
        children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_components.Spinner, {})
      }
    );
  }
  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
    PrivateEditor,
    {
      postType: resolvedPostType,
      postId: resolvedPostId,
      templateId,
      settings: finalSettings,
      styles: finalSettings.styles,
      children: backButton &amp;&amp; /* @__PURE__ */ (0, import_jsx_runtime.jsx)(BackButton, { children: backButton })
    }
  );
}

// packages/lazy-editor/build-module/components/preview/index.mjs
var import_i18n = __toESM(require_i18n(), 1);
var import_element5 = __toESM(require_element(), 1);
var import_block_editor = __toESM(require_block_editor(), 1);
var import_editor2 = __toESM(require_editor(), 1);
var import_blocks2 = __toESM(require_blocks(), 1);
var import_jsx_runtime2 = __toESM(require_jsx_runtime(), 1);
if (typeof document !== &quot;undefined&quot; &amp;&amp; true &amp;&amp; !document.head.querySelector(&quot;style[data-wp-hash=&#039;95327475c1&#039;]&quot;)) {
  const style = document.createElement(&quot;style&quot;);
  style.setAttribute(&quot;data-wp-hash&quot;, &quot;95327475c1&quot;);
  style.appendChild(document.createTextNode(&quot;.lazy-editor-block-preview__container{align-items:center;border-radius:4px;display:flex;flex-direction:column;height:100%;justify-content:center}.dataviews-view-grid .lazy-editor-block-preview__container .block-editor-block-preview__container{height:100%}.dataviews-view-table .lazy-editor-block-preview__container{text-wrap:balance;text-wrap:pretty;flex-grow:0;width:96px}&quot;));
  document.head.appendChild(style);
}
var { useStyle } = unlock(import_editor2.privateApis);
function PreviewContent({
  blocks,
  content,
  description
}) {
  const descriptionId = (0, import_element5.useId)();
  const backgroundColor = useStyle(&quot;color.background&quot;);
  const actualBlocks = (0, import_element5.useMemo)(() =&gt; {
    return blocks ?? (0, import_blocks2.parse)(content, {
      __unstableSkipMigrationLogs: true
    });
  }, [content, blocks]);
  const isEmpty = !actualBlocks?.length;
  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
    &quot;div&quot;,
    {
      className: &quot;lazy-editor-block-preview__container&quot;,
      style: { backgroundColor },
      &quot;aria-describedby&quot;: !!description ? descriptionId : void 0,
      children: [
        isEmpty &amp;&amp; (0, import_i18n.__)(&quot;Empty.&quot;),
        !isEmpty &amp;&amp; /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_block_editor.BlockPreview.Async, { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_block_editor.BlockPreview, { blocks: actualBlocks }) }),
        !!description &amp;&amp; /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(&quot;div&quot;, { hidden: true, id: descriptionId, children: description })
      ]
    }
  );
}
function Preview({
  blocks,
  content,
  description
}) {
  const stylesId = useStylesId();
  const { isReady: settingsReady, editorSettings } = useEditorSettings({
    stylesId
  });
  const { isReady: assetsReady } = useEditorAssets();
  const finalSettings = (0, import_element5.useMemo)(
    () =&gt; ({
      ...editorSettings,
      isPreviewMode: true
    }),
    [editorSettings]
  );
  if (!settingsReady || !assetsReady) {
    return null;
  }
  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_block_editor.BlockEditorProvider, { settings: finalSettings, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
    PreviewContent,
    {
      blocks,
      content,
      description
    }
  ) });
}
export {
  Editor,
  Preview,
  loadEditorAssets,
  useEditorAssets,
  useEditorSettings
};
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2Fhome%2Fplanet5%2Fwww%2Fyogitonics.com%2Fwp-includes%2Fjs%2Fdist%2Fscript-modules%2Flazy-editor'>⬅ Back to Directory</a>