Minn\Blocks

The JSON object starting at $at, brace-matched through any strings; null when there is none.

The attributes a block may bind (get_block_bindings_supported_attributes). @return list<string>

The bound attributes' values for a block about to render, as the sources answer them for a WP_Block made with the context given (each source also seeing the context it uses); the expanded bindings ride along under metadata for a pattern-overrides default. Empty when nothing is bound or nothing answered.

A static block's HTML with the bound values in place, by its type's attribute definitions: rich text and html replace what the selected element holds; an attribute source sets the selected element's attribute; anything else is left alone.

A block-less run of HTML, as the parser reads it.

A block as parse_blocks hands it out, as the value object. @param array<string, mixed> $block

The same block with other attributes. @param array<string, mixed> $attrs

The block as parse_blocks hands it to plugin code.

One attribute, or the default.

The class names declared on the block's own attributes (className).

Why a block name is invalid, or null when it is fine.

A stream over block markup, before its first token.

The name with core/ in front when it has no namespace.

Moves to the next token, HTML or delimiter; false at the end or on incomplete input.

The current token's state: one of the class constants.

incomplete-input when the text ran out inside what could be a delimiter, else null.

The JSON error from the last time attributes were asked for.

opener, closer or void for a delimiter, void for HTML, null otherwise.

The last delimiter read had the closing flag.

The delimiter's block type, null for anything else.

The block type, or core/freeform for top-level HTML and #innerHTML for HTML inside a block.

Whether the token is HTML between delimiters.

The HTML span's text, null for anything else.

Whether the token is HTML with something other than whitespace in it.

The open block types, outermost first, with #html for an HTML span. @return list<string>

Whether this token opens a block (of the type, when given): never after a closer, and HTML only at the top.

Whether the token is of the type; * matches anything.

The token's start and length in the text, null when there is no token. @return array{0: int, 1: int}|null

The delimiter's attributes, parsed now (setting the JSON error), or null. @return array<mixed>|null

A context for rendering outside a page: the home resolution and no posts.

The post being rendered, innermost first.

Enters a post's scope.

Leaves the innermost post's scope.

Inside a post template loop (as opposed to the singular view).

The comment being rendered, if any.

Enters or leaves a comment's scope.

The page number being rendered.

How many pages the listing makes.

A core block type's registered metadata; empty for a name core does not register.

A core block type's supports.

The filter for a list of colors; colors that do not parse are left out.

A color's channels: hex (3, 4, 6 or 8 digits), rgb()/rgba() and hsl()/hsla().

The block's wp-elements-N class, recording its rules; null when its element styles earn none.

Whether element styles earn a class: a link's text colour (or its hover's), a heading's, a heading level's or a button's text, background or gradient, for a kind not skipped.

The kinds a block type's colour support skips serializing.

Rewrites every wp-image-* <img> in a fragment; other images pass through.

The same for a gallery: every image also carries its data-id.

The same for a plugin block's output, where the reference adds no sizes="auto".

Every <img> and <iframe> of a content fragment as the reference's wp_filter_content_tags leaves it: an attachment's image is enriched as above (a loading it already has is kept, and an eager large one is fetched first); any other image is decoded asynchronously and, when its size is known, loaded lazily or by the page's budget; an iframe with a size is loaded lazily.

Content the engine fitted out itself, with what the_content's other callbacks added on the way (an attachment's own link, a plugin's image): an image still without its loading attributes is fitted as the rest were, then each is offered to wp_content_img_tag, as wp_filter_content_tags would.

A post's featured image at full size, in the reference's attribute order (dimensions, source, class, alt, style, then the loading attributes and the srcset). Empty when the attachment has no file.

The layout classes a core block's wrapper carries, under its type's supports (data/blocks.json).

The layout classes a block's wrapper carries, its container's rules recorded, under the theme's layout settings the render state holds (root-padding-aware alignments, block gaps).

The class a child's own layout earns (its size or place in the parent's layout), its rules recorded; null when it writes none.

A block gap as the layout reads it: a value with a character that could end a declaration or open a function (\ ( & = } or a comment) is dropped, a side of one too; anything not a string is left as it is.

A gap with its presets as custom properties, a side at a time.

A block's side padding with its presets as custom properties.

A layout with its widths checked: the first declaration of each, through the style attribute filter, empty when that drops it.

The rules for a container.

The rules a child writes from its own layout (wp_get_child_layout_style_rules): a fixed or filling flex size, a grid span, a grid position, released again (the full row for a span) in a container narrower than the columns it needs: the columns at the parent's minimum width (12rem by default) and the gaps between them (1.5rem, or 24px for a width in px).

A layout's container values: everything but the child keys.

A layout's child values: the child keys alone.

Block markup as a tree of blocks.

The first block delimiter at or after an offset: where it starts, its length, its name (core/ when it names no namespace), its attributes as written (null when it has none), and whether it closes a block or is a void one. Null when no delimiter follows.

Whether serialized content carries a block by name; a bare name means core/, and core blocks are also found by their short delimiter.

The query vars a query block's context amounts to.

The state of the request being rendered, which its runtime holds, so a request cannot count on from the one before it. Rendering with no runtime (the command line, the unit suite) shares one off-request state instead, since the counters have to survive between calls.

Makes this the state current() answers with, for the renderer that brought its own.

Whether the theme puts root padding in custom properties, which decides the constrained layout's classes.

Records what the active theme's layout settings say about root padding.

Whether the theme writes block gaps, which decides whether a layout's gap makes CSS.

Records whether the active theme's spacing settings write block gaps.

The next per-request counter value.

Adds to the page's count of content images (wp_increase_content_media_count) and returns the new count.

Content images seen so far in this page, for the loading rules.

Images a plugin's block filter removed from the page give their budget back, so the next image still counts as if the hidden ones never rendered.

Runs rendering whose images do not count toward the page's loading budget (an excerpt's): the reference fits no image while it makes one, so whatever was seen meanwhile is given back.

$filter run while the_content filters content the engine rendered: the images it already holds count as fitted out, so only what the filter's other callbacks add is fitted (fittedImage()).

Whether an image tag is one the content being filtered held when the filter began.

True once, for the image that gets fetchpriority="high".

Whether no element has taken high fetch priority yet on this page.

Takes high fetch priority off the table for the rest of the page; a plugin prioritising its own element does this.

Puts high fetch priority back on offer, so the next large enough image takes it.

Every block name the page rendered; the stylesheet prints block styles for these only.

The block names rendering met.

The next wp-elements-N class; the reference numbers these apart from the shared counter.

A navigation's aria-label: the label itself the first time, then "label N" for repeats.

A page list renders plain on its own and takes the navigation block's item classes, submenu toggles, and interactivity only while it sits inside one, so the navigation block marks the span it owns.

Leaves a navigation block.

Whether the block rendering now has its Interactivity API directives processed, as interactivity_process_directives answered for it.

Whether rendering is inside a navigation block.

Marks a nested source as being rendered; false when it is already open (a cycle).

Leaves a cycle-guarded key.

Whether a key is open: a source being rendered, or the page template ("template").

True while the block tree is shallower than the cap; deeper blocks render as nothing.

Leaves one nesting level.

How deep the block tree is right now; zero outside any block render.

A dynamic block claims its element class before rendering, so a block that renders nothing still counts.

The pending elements class, cleared.

Holds the numbered style variation class a dynamic block claimed before rendering; returns the one it replaces.

The numbered style variation class the dynamic block being rendered claimed, once: its wrapper takes it.

Notes a gallery instance.

The gallery instances rendering met.

Clears every per-request counter.

The numbered companion of a block style variation the block's class names (is-style-{name}--N), consuming the counter: a variation with styles of its own, the theme's or a registered style's (the facade answers the private minn_block_style_variation filter), whose CSS the facade prints once numbered (minn_block_style_variation_used). Null when none applies.

The per-request rendering state: counters, containers, variations, the images seen.

What is being rendered.

Sets what is being rendered.

The image tag builder.

A renderer with every dynamic block wired over the database door.

Registers the engine's own renderer for a dynamic block. A plugin's callback that already took the block over (bridge()) keeps it, as a replaced render callback does on the reference.

Hands a block to a plugin's render callback; the engine's own renderer for it stays for renderNative().

One block as HTML through the engine's own renderer for its name (its static markup when it has none), even where a plugin's callback took the block over: what a core render callback gives, so a plugin's callback that calls the one it replaced does not call itself.

Block markup as HTML, texturized.

A tree of blocks as HTML.

A core block as renderNative() renders it, without the block filters around this one block (its inner blocks keep theirs): its caller, the facade's WP_Block::render, applies them once.

A core block as its render callback called directly renders it: not a block being rendered, so enqueue_empty_block_content_assets is not asked for it (its inner blocks are), as the reference asks it only in a block's render (probe plugin-surface2).

What the runtime does to an image block's markup once the engine has rendered it: the lightbox, when the image's settings or the theme's ask for one.

The context render_block_context already gave the next block, when render_block() or a WP_Block renders it: a block that provides its own context (a tabs block's id) reads it with ownContext() rather than asking again.

The context render_block_context gave the block that has just begun to render; null when nothing did. A block's renderer reads it first, before its inner blocks begin.

One block as HTML, with the filters around it (unless renderNativeUnfiltered() asked for this one without).

The context a block's bindings read: the post being rendered (postId, postType) and what enclosing blocks provide (a synced pattern's overrides).

Renders with context provided to the blocks inside (render_block_context's job on the reference). @param array<string, mixed> $context

Whether the engine's own renderer answers for a block: a core block no plugin's callback took over. It applies the block supports it knows itself (layout, element styles); the facade's render_block filters do the rest, and all of them for any other block.

The CSS selector a block's style targets, or null.

A list of parsed blocks back to markup, freeform runs as written.

One block with its inner blocks, as the delimiter comments the parser reads.

Content wrapped in a block's delimiters; a block with no content is written self-closing.

Block attributes as the delimiter carries them.

A selector list split at its top-level commas (none inside parentheses counts), each part as written.

A state on each selector of a block's list, its leading compound selector swapped for the base; the base alone for an empty list.

Presets (var:preset|{kind}|{slug}) as their custom properties, through arrays; anything else as it is.

Declarations with a background image unset under a background colour that sets neither a background nor an image of its own.

Declarations with a solid border style for a border (or a side of one) given a width or a colour and no style.

A state's style with an explicit aspect ratio unsetting the height and minimum height, or a height or minimum height unsetting the aspect ratio.

A state's style split by the selectors a block gives its features: a feature (or one of its properties) with a selector of its own goes there, a feature's other properties to its root selector, the rest to the block's root. Groups keep the order they are first met in.

Adds a style to the group of a selector, merged into what it holds.

The reference's style definitions, by group and property (WP_Style_Engine::BLOCK_STYLE_DEFINITIONS_METADATA).

A style object's declarations and class names.

A preset's slug for a kind ("var:preset|color|base" for color is "base"), or null.

A preset as the custom property the definition names for its kind, or null. @param array<string, string> $vars

A preset's class names for a definition. @param array<string, mixed> $definition @return list<string>

The declarations one definition makes of a value; presets as class names make none. @param array<string, mixed> $definition @param array<string, mixed> $options @return array<string, mixed>

A border side's declarations. @param array<string, mixed> $definition @param array<string, mixed> $options @return array<string, mixed>

A url or a plain value. @param array<string, mixed> $definition @return array<string, mixed>

A name in kebab case, as the reference's _wp_to_kebab_case cuts it ("lineHeight", "Zz Space" become "line-height", "zz-space").

var:preset|spacing|40 becomes var(--wp--preset--spacing--40). A value that could close a declaration or a style element, or carry code, is dropped: these values come from stored block attributes.

A class-name token from an attribute: letters, digits, dashes, underscores; nothing that ends an attribute.

The style attribute's declarations. The reference emits the style groups in a fixed order (border, colour, typography, spacing, dimensions) and most properties in a fixed order within a group, but a spacing box's sides come out as the block stored them.

The preset classes (font size, text alignment, custom class names) a block's attributes declare.

The align class an "align" attribute declares.

The areas' variations beside the parts' ones.

One variation per template part.

A dynamic block's opening tag with its classes in the reference's order.