%% wrapblock.sty
%% A closed block: an image beside its own text, which wraps under it.
%% Paragraphs, lists and displayed equations are wrapped; the image and the
%% lines beside it stay on one page; pdfLaTeX and LuaLaTeX; tagged PDF.
%%
%% Copyright (C) 2026 Antonin Marchand
%%
%% This work may be distributed and/or modified under the conditions of the
%% LaTeX Project Public License, either version 1.3c of this license or (at
%% your option) any later version. The latest version of this license is in
%% https://www.latex-project.org/lppl.txt
%%
%% This work has the LPPL maintenance status `maintained'.
%% The Current Maintainer of this work is Antonin Marchand.
%
\NeedsTeXFormat{LaTeX2e}[2023-06-01]
\ProvidesExplPackage{wrapblock}{2026-11-18}{0.1.3}
{Closed block with an image beside its text}
%
%
% ---------------------------------------------------------------- state
% All positions are in page coordinates: the value \pagetotal would have
% at that point, from the top of the text area.
\box_new:N \g__wrapblock_img_box
\tl_new:N \g__wrapblock_img_tl % the image, as given
\dim_new:N \g__wrapblock_img_width_dim % its width key (-\maxdimen: natural)
\dim_new:N \l__wrapblock_width_dim
\bool_new:N \g__wrapblock_active_bool % a region is running
\bool_new:N \g__wrapblock_pending_bool % the image is not placed yet
\dim_new:N \g__wrapblock_bottom_dim % bottom of the reserved area
\dim_new:N \g__wrapblock_height_dim % image height + vsep
\dim_new:N \g__wrapblock_shift_dim % room taken by image + hsep
\dim_new:N \g__wrapblock_left_dim % left edge of the block
\dim_new:N \g__wrapblock_width_dim % width of the block
\dim_new:N \g__wrapblock_prevdepth_dim % \prevdepth before the paragraph
\int_new:N \g__wrapblock_ship_int % pages shipped so far
\int_new:N \g__wrapblock_origin_ship_int
\tl_new:N \g__wrapblock_side_tl
\tl_new:N \l__wrapblock_side_tl
\int_new:N \g__wrapblock_save_pre_int
\int_new:N \g__wrapblock_save_post_int
\bool_new:N \g__wrapblock_global_bool
\bool_new:N \l__wrapblock_outer_bool
\bool_set_true:N \l__wrapblock_outer_bool
\int_new:N \g__wrapblock_save_item_int
\int_new:N \g__wrapblock_save_beginpar_int
\int_new:N \g__wrapblock_save_endpar_int
\int_new:N \l__wrapblock_lines_int
\dim_new:N \l__wrapblock_base_dim
\dim_new:N \l__wrapblock_rule_dim
\dim_new:N \l__wrapblock_i_dim
\dim_new:N \l__wrapblock_l_dim
\dim_new:N \l__wrapblock_ni_dim
\dim_new:N \l__wrapblock_nl_dim
\dim_new:N \g__wrapblock_avail_dim % line width left beside the image
\tl_new:N \g__wrapblock_warned_tl % input line of the last box warning
\seq_new:N \g__wrapblock_shapes_seq % signatures of the shapes set
\int_new:N \g__wrapblock_narrowed_int % lines narrowed in the paragraph
\bool_new:N \l__wrapblock_inside_bool % inside a wrapblock environment
\bool_new:N \l__wrapblock_inbox_bool % this block sits in a box
\bool_new:N \l__wrapblock_inimage_bool % inside the image of a block
\bool_new:N \l__wrapblock_alone_bool % the image is too wide: no wrapping
\tl_new:N \l__wrapblock_shape_tl
\tl_new:N \l__wrapblock_pen_tl
%
%
% A deferred image: it did not fit at the bottom of the page, and the text
% is long enough to fill that bottom at full width. It goes to the top of
% the next page, and the lines there are narrowed.
\bool_new:N \g__wrapblock_wait_bool % deferred, the page has not broken yet
\int_new:N \g__wrapblock_full_end_int % last full-width line before the break
\int_new:N \l__wrapblock_full_int
\int_new:N \g__wrapblock_def_int % deferred images so far
\seq_new:N \g__wrapblock_def_seq % deferred images waiting for their page
\int_new:N \g__wrapblock_struct_int % structure that holds the image
\tl_new:N \g__wrapblock_counters_tl
\box_new:N \l__wrapblock_measure_box
\box_new:N \l__wrapblock_labels_box
\box_new:N \g__wrapblock_float_box % a float of the text, while it is measured
\box_new:N \g__wrapblock_mar_box % a \marginpar, likewise
\tl_new:N \l__wrapblock_freelist_tl % the lists of float boxes of LaTeX,
\tl_new:N \l__wrapblock_currlist_tl % kept while the text is measured
\dim_new:N \g__wrapblock_text_dim % height of the text at full width
\int_new:N \g__wrapblock_block_int % blocks so far, to name them in the .aux
\dim_new:N \g__wrapblock_goal_dim % \pagegoal where a deferred block starts
\dim_new:N \g__wrapblock_short_dim % room the footnotes will take there
\prop_new:N \g__wrapblock_short_prop % that room, read from the .aux
\prop_new:N \g__wrapblock_short_new_prop % and as found in this run
\bool_new:N \l__wrapblock_defer_bool
\bool_new:N \l__wrapblock_allow_defer_bool
\bool_new:N \g__wrapblock_breakpar_bool % this paragraph ends the page
\seq_new:N \l__wrapblock_done_seq
\dim_new:N \g__wrapblock_top_dim % height of the floats at the top of the page
%
%
\hook_gput_code:nnn { shipout / after } { wrapblock }
{ \int_gincr:N \g__wrapblock_ship_int }
%
%
% A footnote in the full-width lines of a deferred block shortens the page
% after the lines were counted: the page breaks before the planned break,
% at the end of a column whose \outputpenalty is not -10000. The room the
% footnotes took is then written to the .aux, and the next run counts the
% lines without it. A value found once is kept: the footnote may go below
% the break on the next run.
\cs_new_protected:cpn { wrapblock@short } #1#2
{ \prop_gput:Nnn \g__wrapblock_short_prop {#1} {#2} }
\hook_gput_code:nnn { build / column / before } { wrapblock }
{
\__wrapblock_top_floats:
\bool_lazy_and:nnT
{ \g__wrapblock_wait_bool }
{ \int_compare_p:nNn { \tex_outputpenalty:D } > { -10000 } }
{
\dim_set:Nn \l_tmpa_dim
{
\g__wrapblock_goal_dim - \tex_vsize:D
\box_if_empty:NF \footins
{ + \box_ht:N \footins + \box_dp:N \footins + \tex_skip:D \footins }
}
\dim_compare:nNnF { \l_tmpa_dim } > { 0pt }
{ \dim_set_eq:NN \l_tmpa_dim \baselineskip }
\prop_gput:Nee \g__wrapblock_short_new_prop
{ \int_use:N \g__wrapblock_block_int }
{ \dim_eval:n { \g__wrapblock_short_dim + \l_tmpa_dim } }
}
}
\hook_gput_code:nnn { enddocument / afterlastpage } { wrapblock }
{
\iow_now:Nn \@auxout { \providecommand \wrapblock@short [2] { } }
\prop_map_inline:Nn \g__wrapblock_short_prop
{
\prop_if_in:NnF \g__wrapblock_short_new_prop {#1}
{ \iow_now:Nn \@auxout { \wrapblock@short {#1} {#2} } }
}
\prop_map_inline:Nn \g__wrapblock_short_new_prop
{ \iow_now:Nn \@auxout { \wrapblock@short {#1} {#2} } }
}
%
%
% The floats LaTeX is about to put at the top of the page take room above
% the text: a deferred image is drawn below them. Their height is that of
% the boxes in \@toplist, \floatsep between them and \textfloatsep below.
\cs_new_protected:Npn \__wrapblock_top_floats:
{
\dim_gzero:N \g__wrapblock_top_dim
\tl_if_empty:NF \@toplist
{
\group_begin:
\cs_set:Npn \@elt ##1
{
\dim_gadd:Nn \g__wrapblock_top_dim
{ \box_ht:N ##1 + \box_dp:N ##1 + \floatsep }
}
\@toplist
\group_end:
\dim_gadd:Nn \g__wrapblock_top_dim { \textfloatsep - \floatsep }
}
}
%
%
% Deferred images are set on the page they belong to as it is shipped,
% at the top of the text area: the lines beside them are already narrowed.
% In a tagged PDF the image goes in a structure element made, empty, where
% the block starts, so that it keeps its place in the reading order.
\hook_gput_code:nnn { shipout / foreground } { wrapblock }
{ \seq_if_empty:NF \g__wrapblock_def_seq { \__wrapblock_overlays: } }
\cs_new_protected:Npn \__wrapblock_overlays:
{
\seq_clear:N \l__wrapblock_done_seq
\seq_map_inline:Nn \g__wrapblock_def_seq
{
\exp_last_unbraced:Nv \__wrapblock_overlay:nnnnnnn
{ g__wrapblock_def_ ##1 _data_tl } {##1}
}
\seq_map_inline:Nn \l__wrapblock_done_seq
{ \seq_gremove_all:Nn \g__wrapblock_def_seq {##1} }
}
% #1 page (pages shipped before it), #2 left edge and #3 width of the
% block, #4 width key, #5 side, #6 structure, #7 number of the image
\cs_new_protected:Npn \__wrapblock_overlay:nnnnnnn #1#2#3#4#5#6#7
{
\int_compare:nNnT {#1} = { \g__wrapblock_ship_int }
{
\seq_put_right:Nn \l__wrapblock_done_seq {#7}
\bool_lazy_and:nnT
{ \int_compare_p:nNn {#6} > { 0 } }
{ \cs_if_exist_p:N \tag_struct_begin:n }
{ \tag_struct_begin:n { tag = P , parent = #6 } }
\hbox_set:Nn \l_tmpa_box
{
\cs_if_exist_use:NT \tag_mc_begin:n { { } }
\dim_compare:nNnTF {#4} = { - \c_max_dim }
{ \tl_use:c { g__wrapblock_def_ #7 _tl } }
{ \hbox_to_wd:nn {#4} { \hfil \tl_use:c { g__wrapblock_def_ #7 _tl } \hfil } }
\cs_if_exist_use:N \tag_mc_end:
}
\put
(
\dim_eval:n
{
1in + \hoffset
+ \legacy_if:nTF { @twoside }
{ \int_if_odd:nTF { \c@page } { \oddsidemargin } { \evensidemargin } }
{ \oddsidemargin }
+ #2
+ \str_if_eq:nnTF {#5} { l } { 0pt } { #3 - \box_wd:N \l_tmpa_box }
} ,
\dim_eval:n
{
- 1in - \voffset - \topmargin - \headheight - \headsep
- \g__wrapblock_top_dim
- \topskip + \box_ht:N \strutbox - \box_ht:N \l_tmpa_box
}
)
{ \box_use_drop:N \l_tmpa_box }
\bool_lazy_and:nnT
{ \int_compare_p:nNn {#6} > { 0 } }
{ \cs_if_exist_p:N \tag_struct_begin:n }
{ \tag_struct_end: }
\cs_undefine:c { g__wrapblock_def_ #7 _tl }
\cs_undefine:c { g__wrapblock_def_ #7 _data_tl }
}
}
%
%
% ---------------------------------------------------------------- keys
\keys_define:nn { wrapblock }
{
side .choices:nn = { l , r } { \tl_set:Nn \l__wrapblock_side_tl {#1} } ,
side .initial:n = r ,
l .meta:n = { side = l } ,
r .meta:n = { side = r } ,
% natural: the width of the image itself, kept as -\maxdimen, which no
% length can be; 0pt is a room of no width, like any other length
width .code:n =
{
\str_if_eq:nnTF {#1} { natural }
{ \dim_set:Nn \l__wrapblock_width_dim { - \c_max_dim } }
{ \dim_set:Nn \l__wrapblock_width_dim {#1} }
} ,
width .initial:n = natural ,
width .value_required:n = true ,
hsep .dim_set:N = \l__wrapblock_hsep_dim ,
hsep .initial:n = 1em ,
vsep .dim_set:N = \l__wrapblock_vsep_dim ,
vsep .initial:n = 0.5\baselineskip ,
defer .bool_set:N = \l__wrapblock_allow_defer_bool ,
defer .initial:n = true ,
defer .default:n = true ,
}
\NewDocumentCommand \wrapblockset { m } { \keys_set:nn { wrapblock } {#1} }
%
%
% ---------------------------------------------------------------- helpers
% The messages give the line where the block ends: its text is read as an
% argument, and TeX is on the line of \end{wrapblock} when the code runs.
% Baseline of the first line of the paragraph being started.
\cs_new_protected:Npn \__wrapblock_first_baseline:N #1
{
\dim_compare:nNnTF { \pagegoal } = { \c_max_dim }
{ \dim_set:Nn #1 { \topskip } } % empty page
{
\dim_compare:nNnTF { \g__wrapblock_prevdepth_dim } > { -1000pt }
{ \dim_set:Nn #1 { \pagetotal + \baselineskip - \g__wrapblock_prevdepth_dim } }
{ \dim_set:Nn #1 { \pagetotal + \box_ht:N \strutbox } }
}
}
%
%
% The region moved to a new page while it was running. This happens only
% when insertions (footnotes) shrank the page under it. Assume it now sits
% at the top of the page and say so.
\cs_new_protected:Npn \__wrapblock_check_ship:
{
\int_compare:nNnF { \g__wrapblock_ship_int } = { \g__wrapblock_origin_ship_int }
{
\msg_warning:nn { wrapblock } { moved }
\int_gset_eq:NN \g__wrapblock_origin_ship_int \g__wrapblock_ship_int
\dim_gset:Nn \g__wrapblock_bottom_dim
{ \topskip - \box_ht:N \strutbox + \g__wrapblock_height_dim }
}
}
\msg_new:nnn { wrapblock } { moved }
{ The~block~that~ends~on~input~line~\msg_line_number:\ moved~to~a~new~page~
while~its~text~was~set.~Its~wrapping~may~be~off~by~some~lines. }
\msg_new:nnn { wrapblock } { nested }
{ wrapblock~blocks~cannot~be~nested. }
%
%
\cs_new_protected:Npn \__wrapblock_list_penalties_off:
{
\int_gset:Nn \@itempenalty { 10000 }
\int_gset:Nn \@beginparpenalty { 10000 }
\int_gset:Nn \@endparpenalty { 10000 }
}
\cs_new_protected:Npn \__wrapblock_list_penalties_restore:
{
\int_gset_eq:NN \@itempenalty \g__wrapblock_save_item_int
\int_gset_eq:NN \@beginparpenalty \g__wrapblock_save_beginpar_int
\int_gset_eq:NN \@endparpenalty \g__wrapblock_save_endpar_int
}
\cs_new_protected:Npn \__wrapblock_stop:
{
\bool_gset_false:N \g__wrapblock_active_bool
\__wrapblock_list_penalties_restore:
}
%
%
% Set \parshape so that the lines from index #1 (0 = first line of the
% paragraph) whose top lies above the bottom of the image are narrowed.
% #2 is the baseline of line #1.
\cs_new_protected:Npn \__wrapblock_shape:nn { \__wrapblock_shape:Nnn \prg_do_nothing: }
% #1 is \prg_do_nothing: or \tex_global:D: after a display the paragraph
% may sit inside the group of an environment (amsmath), which would undo
% a local \parshape.
\cs_new_protected:Npn \__wrapblock_shape:Nnn #1#2#3
{ \__wrapblock_shape:Nnnn #1 {#2} { 0 } {#3} }
% With a deferred image, #3 lines keep their full width first, the last of
% them ends the page, and the narrowed lines start at the top of the next
% one; #4 is then the baseline of the first of them on that page.
\cs_new_protected:Npn \__wrapblock_shape:Nnnn #1#2#3#4
{
\int_set:Nn \l__wrapblock_full_int {#3}
\int_set:Nn \l__wrapblock_lines_int
{
\fp_eval:n
{
ceil ( ( \dim_to_fp:n { \g__wrapblock_bottom_dim - #4 + \box_ht:N \strutbox } )
/ \dim_to_fp:n { \baselineskip } )
}
}
\int_compare:nNnF { \l__wrapblock_lines_int } > { 0 }
{ \int_set:Nn \l__wrapblock_lines_int { 0 } }
% base line: what LaTeX gave this paragraph (lists set \parshape)
\int_compare:nNnTF { \parshape } > { 0 }
{
\dim_set:Nn \l__wrapblock_i_dim { \parshapeindent \parshape }
\dim_set:Nn \l__wrapblock_l_dim { \parshapelength \parshape }
}
{
\dim_zero:N \l__wrapblock_i_dim
\dim_set_eq:NN \l__wrapblock_l_dim \hsize
}
\str_if_eq:VnTF \g__wrapblock_side_tl { l }
{
\dim_set:Nn \l__wrapblock_ni_dim { \l__wrapblock_i_dim + \g__wrapblock_shift_dim }
\dim_set:Nn \l__wrapblock_nl_dim { \l__wrapblock_l_dim - \g__wrapblock_shift_dim }
}
{
\dim_set_eq:NN \l__wrapblock_ni_dim \l__wrapblock_i_dim
\dim_set:Nn \l__wrapblock_nl_dim
{
\dim_min:nn { \l__wrapblock_l_dim }
{ \g__wrapblock_left_dim + \g__wrapblock_width_dim
- \g__wrapblock_shift_dim - \l__wrapblock_i_dim }
}
}
\dim_gset_eq:NN \g__wrapblock_avail_dim \l__wrapblock_nl_dim
\tl_clear:N \l__wrapblock_shape_tl
\tl_clear:N \l__wrapblock_pen_tl
\int_step_inline:nn { #2 }
{
\tl_put_right:Nx \l__wrapblock_shape_tl
{ \dim_use:N \l__wrapblock_ni_dim \c_space_tl \dim_use:N \l__wrapblock_nl_dim \c_space_tl }
\tl_put_right:Nn \l__wrapblock_pen_tl { 10000 ~ }
}
\int_step_inline:nn { \l__wrapblock_full_int }
{
\tl_put_right:Nx \l__wrapblock_shape_tl
{ \dim_use:N \l__wrapblock_i_dim \c_space_tl \dim_use:N \l__wrapblock_l_dim \c_space_tl }
% the page breaks after the last full-width line (-10000, as \newpage:
% LaTeX keeps lower values for its floats)
\tl_put_right:Nx \l__wrapblock_pen_tl
{
\int_compare:nNnTF {##1} = { \l__wrapblock_full_int }
{ -10000 } { \int_use:N \interlinepenalty } ~
}
}
\int_step_inline:nn { \l__wrapblock_lines_int }
{
\tl_put_right:Nx \l__wrapblock_shape_tl
{ \dim_use:N \l__wrapblock_ni_dim \c_space_tl \dim_use:N \l__wrapblock_nl_dim \c_space_tl }
\tl_put_right:Nn \l__wrapblock_pen_tl { 10000 ~ }
}
\int_set:Nn \l__wrapblock_lines_int
{ #2 + \l__wrapblock_full_int + \l__wrapblock_lines_int }
\int_gset_eq:NN \g__wrapblock_narrowed_int \l__wrapblock_lines_int
\int_compare:nNnT { \l__wrapblock_lines_int } > { 0 }
{
\seq_gput_right:Ne \g__wrapblock_shapes_seq
{
\int_eval:n { \l__wrapblock_lines_int + 1 } /
\bool_lazy_and:nnTF
{ \int_compare_p:nNn {#2} = { 0 } }
{ \int_compare_p:nNn { \l__wrapblock_full_int } > { 0 } }
{ \dim_use:N \l__wrapblock_i_dim / \dim_use:N \l__wrapblock_l_dim }
{ \dim_use:N \l__wrapblock_ni_dim / \dim_use:N \l__wrapblock_nl_dim }
}
}
#1 \tex_parshape:D
\int_eval:n { \l__wrapblock_lines_int + 1 } \c_space_tl
\l__wrapblock_shape_tl
\dim_use:N \l__wrapblock_i_dim \c_space_tl \dim_use:N \l__wrapblock_l_dim \scan_stop:
#1 \tex_interlinepenalties:D
\int_eval:n { \l__wrapblock_lines_int + 1 } \c_space_tl
\l__wrapblock_pen_tl \int_use:N \interlinepenalty \scan_stop:
}
%
%
% The image is built twice: once to be measured at the start of the
% block, once where it is placed. Built outside a paragraph, a box with
% text in it (\fbox, tabular, \parbox) would open its structure at the
% wrong place in a tagged PDF.
\cs_new_protected:Npn \__wrapblock_build:
{
\hbox_gset:Nn \g__wrapblock_img_box
{
\bool_set_true:N \l__wrapblock_inimage_bool
\dim_compare:nNnTF { \g__wrapblock_img_width_dim } = { - \c_max_dim }
{ \tl_use:N \g__wrapblock_img_tl }
{
\hbox_to_wd:nn { \g__wrapblock_img_width_dim }
{ \hfil \tl_use:N \g__wrapblock_img_tl \hfil }
}
}
}
% The image, flat (no width, height or depth), at the start of line 1.
\cs_new_protected:Npn \__wrapblock_place_image:
{
\__wrapblock_build:
\hbox_set:Nn \l_tmpa_box
{
\tex_kern:D \dim_eval:n
{
\str_if_eq:VnTF \g__wrapblock_side_tl { l }
{ \g__wrapblock_left_dim }
{ \g__wrapblock_left_dim + \g__wrapblock_width_dim - \box_wd:N \g__wrapblock_img_box }
- \l__wrapblock_ni_dim
}
\box_move_down:nn
{ \box_ht:N \g__wrapblock_img_box - \box_ht:N \strutbox }
{ \box_use:N \g__wrapblock_img_box }
}
\box_set_wd:Nn \l_tmpa_box { 0pt }
\box_set_ht:Nn \l_tmpa_box { 0pt }
\box_set_dp:Nn \l_tmpa_box { 0pt }
% Centred or ragged-left text: \leftskip comes before the image and
% would move it. The opposite glue takes it back to the start of the
% line, and the same glue after it puts the text where it was.
\skip_if_eq:nnTF { \leftskip } { 0pt }
{ \box_use_drop:N \l_tmpa_box }
{
\tex_penalty:D 10000 ~
\skip_horizontal:n { - \leftskip }
\box_use_drop:N \l_tmpa_box
\tex_penalty:D 10000 ~
\skip_horizontal:N \leftskip
}
\bool_gset_false:N \g__wrapblock_pending_bool
}
%
%
% A block that comes first in an \item: the labels, which LaTeX sets at the start
% of the first line, would follow the text past a left image and land on
% it. Move them back to their place in the margin.
\cs_new_protected:Npn \__wrapblock_labels_back:
{
\str_if_eq:VnT \g__wrapblock_side_tl { l }
{
\legacy_if:nT { @inlabel }
{
\hbox_gset:Nn \@labels
{
\tex_kern:D - \g__wrapblock_shift_dim
\hbox_unpack:N \@labels
\tex_kern:D \g__wrapblock_shift_dim
}
}
}
}
%
%
% A \parbox, minipage or p cell is not wrapped: its text keeps the width
% it was given. Say so when that width does not fit beside the image.
\cs_new_protected:Npn \__wrapblock_box_check:
{
\bool_lazy_and:nnT { \l__wrapblock_outer_bool } { \g__wrapblock_active_bool }
{
% group 11: a footnote, set apart at the foot of the page;
% \@captype: a float, which goes elsewhere on the page
\bool_lazy_all:nT
{
{ ! \g__wrapblock_pending_bool }
{ ! \g__wrapblock_wait_bool }
{ \int_compare_p:n { \tex_currentgrouptype:D != 11 } }
{ ! \cs_if_exist_p:N \@captype }
{ \dim_compare_p:nNn { \pagetotal } < { \g__wrapblock_bottom_dim } }
}
{
\bool_lazy_and:nnT
{ \dim_compare_p:nNn { \hsize } > { \g__wrapblock_avail_dim + 0.5pt } }
{ ! \str_if_eq_p:ee { \msg_line_number: } { \g__wrapblock_warned_tl } }
{
\tl_gset:Ne \g__wrapblock_warned_tl { \msg_line_number: }
\msg_warning:nnxx { wrapblock } { box }
{ \dim_use:N \hsize } { \dim_use:N \g__wrapblock_avail_dim }
}
}
}
}
\msg_new:nnn { wrapblock } { box }
{ A~box~of~width~#1,~in~the~block~that~ends~on~input~line~
\msg_line_number:,~sits~beside~the~image,~where~only~#2~is~left.~
The~text~of~a~box~is~not~wrapped. }
%
%
% ---------------------------------------------------------------- hooks
\hook_gput_code:nnn { para / before } { wrapblock }
{
\bool_if:NT \g__wrapblock_active_bool
{ \bool_if:NT \l__wrapblock_outer_bool
{ \dim_gset:Nn \g__wrapblock_prevdepth_dim { \prevdepth } } }
}
\hook_gput_code:nnn { para / begin } { wrapblock }
{
\bool_if:NT \l__wrapblock_outer_bool
{
\bool_if:NT \l__wrapblock_inside_bool { \__wrapblock_unstale: }
\__wrapblock_para_begin:
}
}
%
%
% TeX clears \parshape at the end of a paragraph, but locally. A paragraph
% ended inside a deeper group (an item that opens a nested list) leaves
% its narrowed shape behind, and the next paragraph gets it back. It is
% recognised among the shapes set in the block; its last entry is what
% LaTeX had given.
\cs_new_protected:Npn \__wrapblock_unstale:
{
\int_compare:nNnT { \parshape } > { 1 }
{
\seq_if_in:NeT \g__wrapblock_shapes_seq
{
\int_eval:n { \parshape } /
\dim_eval:n { \parshapeindent 1 } / \dim_eval:n { \parshapelength 1 }
}
{
\tex_parshape:D 1 ~
\dim_eval:n { \parshapeindent \parshape } \c_space_tl
\dim_eval:n { \parshapelength \parshape } \scan_stop:
\tex_interlinepenalties:D 0 ~
}
}
}
%
%
\cs_new_protected:Npn \__wrapblock_para_begin:
{
\bool_if:NT \g__wrapblock_active_bool
{
\__wrapblock_first_baseline:N \l__wrapblock_base_dim
\bool_if:NTF \g__wrapblock_wait_bool
{ \__wrapblock_defer_para:N \prg_do_nothing: }
{ \__wrapblock_para_begin_aux: }
}
}
\cs_new_protected:Npn \__wrapblock_para_begin_aux:
{
\bool_if:NTF \g__wrapblock_pending_bool
{
\dim_gset:Nn \g__wrapblock_bottom_dim
{ \l__wrapblock_base_dim - \box_ht:N \strutbox + \g__wrapblock_height_dim }
\int_gset_eq:NN \g__wrapblock_origin_ship_int \g__wrapblock_ship_int
}
{ \__wrapblock_check_ship: }
\__wrapblock_shape:nn { 0 } { \l__wrapblock_base_dim }
\int_compare:nNnTF { \l__wrapblock_lines_int } > { 0 }
{
\int_set:Nn \predisplaypenalty { 10000 }
\int_set:Nn \postdisplaypenalty { 10000 }
\bool_if:NT \g__wrapblock_pending_bool
{
\__wrapblock_labels_back:
\__wrapblock_place_image:
}
}
% past the image: the shape is the one LaTeX gave, keep it
{ \__wrapblock_stop: }
}
%
%
% A deferred image, before the page break. #1 is \prg_do_nothing: at the
% start of a paragraph, \tex_global:D after a display. The baseline of the
% next line is in \l__wrapblock_base_dim, and \prevgraf lines are set.
% Count the full-width lines that still fit on the page: none, and the
% page breaks before the next line; some, and it breaks after the last.
\cs_new_protected:Npn \__wrapblock_defer_para:N #1
{
\int_compare:nNnTF { \g__wrapblock_ship_int } = { \g__wrapblock_origin_ship_int }
{
% the footnotes to come, as the last run found them
\dim_set:Nn \l_tmpa_dim
{ \g__wrapblock_short_dim - \g__wrapblock_goal_dim + \pagegoal }
\dim_compare:nNnT { \l_tmpa_dim } < { 0pt } { \dim_zero:N \l_tmpa_dim }
\dim_set:Nn \l_tmpa_dim { \pagegoal - \l_tmpa_dim }
\dim_compare:nNnTF
{ \l__wrapblock_base_dim + \box_dp:N \strutbox } > { \l_tmpa_dim }
{ \int_zero:N \l__wrapblock_full_int }
{
\int_set:Nn \l__wrapblock_full_int
{
\fp_eval:n
{
floor ( \dim_to_fp:n { \l_tmpa_dim - \l__wrapblock_base_dim - \box_dp:N \strutbox }
/ \dim_to_fp:n { \baselineskip } ) + 1
}
}
}
\int_compare:nNnT { \l__wrapblock_full_int } = { 0 }
{ \tex_vadjust:D pre { \tex_penalty:D -10000 ~ } }
}
% the page already broke before this paragraph
{ \int_zero:N \l__wrapblock_full_int }
\int_compare:nNnTF { \l__wrapblock_full_int } = { 0 }
{
% the image goes to the page after the coming break, or to the
% page being built if the page already broke
\__wrapblock_commit:n
{
\g__wrapblock_ship_int
\int_compare:nNnT { \g__wrapblock_ship_int } = { \g__wrapblock_origin_ship_int } { + 1 }
}
\__wrapblock_shape:Nnnn #1 { \tex_prevgraf:D } { 0 } { \topskip }
}
{
\int_gset:Nn \g__wrapblock_full_end_int
{ \tex_prevgraf:D + \l__wrapblock_full_int }
\bool_gset_true:N \g__wrapblock_breakpar_bool
\__wrapblock_shape:Nnnn #1 { \tex_prevgraf:D } { \l__wrapblock_full_int } { \topskip }
}
\int_set:Nn \predisplaypenalty { 10000 }
\int_set:Nn \postdisplaypenalty { 10000 }
}
%
%
% The image goes to the top of the page shipped after #1 pages.
\cs_new_protected:Npn \__wrapblock_commit:n #1
{
\bool_gset_false:N \g__wrapblock_wait_bool
\int_gset:Nn \g__wrapblock_origin_ship_int {#1}
\int_gincr:N \g__wrapblock_def_int
\tl_gset_eq:cN { g__wrapblock_def_ \int_use:N \g__wrapblock_def_int _tl }
\g__wrapblock_img_tl
\tl_gset:ce { g__wrapblock_def_ \int_use:N \g__wrapblock_def_int _data_tl }
{
{ \int_use:N \g__wrapblock_origin_ship_int }
{ \dim_use:N \g__wrapblock_left_dim }
{ \dim_use:N \g__wrapblock_width_dim }
{ \dim_use:N \g__wrapblock_img_width_dim }
{ \g__wrapblock_side_tl }
{ \int_use:N \g__wrapblock_struct_int }
}
\seq_gput_right:Ne \g__wrapblock_def_seq { \int_use:N \g__wrapblock_def_int }
}
%
%
% After a displayed equation the paragraph goes on; its remaining lines
% are re-measured from where the display actually ended.
\cs_new_protected:Npn \__wrapblock_after_display:
{
\bool_if:NT \g__wrapblock_active_bool
{
\dim_set:Nn \l__wrapblock_base_dim
{ \pagetotal + \baselineskip - \box_dp:N \strutbox }
\bool_if:NTF \g__wrapblock_wait_bool
{ \__wrapblock_defer_para:N \tex_global:D }
{
\__wrapblock_check_ship:
\__wrapblock_shape:Nnn \tex_global:D { \prevgraf } { \l__wrapblock_base_dim }
}
\bool_gset_true:N \g__wrapblock_global_bool
}
}
\cs_new_protected:Npn \__wrapblock_display_hook:
{
\bool_if:NT \g__wrapblock_active_bool
{ \bool_if:NT \l__wrapblock_outer_bool
{ \group_insert_after:N \__wrapblock_after_display: } }
}
\hook_gput_code:nnn { begindocument } { wrapblock }
{
\tex_everydisplay:D \exp_after:wN
{ \tex_the:D \tex_everydisplay:D \__wrapblock_display_hook: }
}
%
%
% TeX adds the club, widow and broken penalties to the -10000 that ends
% the page, which then no longer forces the break. They are cleared at the
% end of the paragraph, just before it is broken into lines: at its start,
% the \everypar of LaTeX would set \clubpenalty again after the hook.
\hook_gput_code:nnn { para / end } { wrapblock }
{
\bool_lazy_and:nnT { \l__wrapblock_outer_bool } { \g__wrapblock_breakpar_bool }
{
\bool_gset_false:N \g__wrapblock_breakpar_bool
\int_set:Nn \clubpenalty { 0 }
\int_set:Nn \widowpenalty { 0 }
\int_set:Nn \brokenpenalty { 0 }
\tex_clubpenalties:D 0 ~
\tex_widowpenalties:D 0 ~
}
}
%
%
\hook_gput_code:nnn { para / after } { wrapblock }
{
\bool_if:NT \g__wrapblock_active_bool
{ \bool_if:NT \l__wrapblock_outer_bool { \__wrapblock_para_after: } }
}
\cs_new_protected:Npn \__wrapblock_para_after:
{
\tex_interlinepenalties:D 0 ~
\bool_if:NT \g__wrapblock_global_bool
{
\tex_global:D \tex_parshape:D 0 ~
\tex_global:D \tex_interlinepenalties:D 0 ~
\bool_gset_false:N \g__wrapblock_global_bool
}
\int_set_eq:NN \predisplaypenalty \g__wrapblock_save_pre_int
\int_set_eq:NN \postdisplaypenalty \g__wrapblock_save_post_int
% A deferred image waits until a paragraph goes past its last
% full-width line, which ends the page.
\bool_if:NTF \g__wrapblock_wait_bool
{
\int_compare:nNnT { \tex_prevgraf:D } > { \g__wrapblock_full_end_int }
{
% The \par that ended the paragraph ran the page builder, which
% met the forced break: the page is shipped, and the image goes
% to the page being built. It may come later than planned: a
% footnote in the full-width lines shortens the page, which then
% breaks twice.
\int_compare:nNnT
{ \g__wrapblock_ship_int } > { \g__wrapblock_origin_ship_int + 1 }
{ \msg_warning:nn { wrapblock } { early } }
\__wrapblock_commit:n { \g__wrapblock_ship_int }
\__wrapblock_zone_after:
}
}
{ \__wrapblock_zone_after: }
}
\cs_new_protected:Npn \__wrapblock_zone_after:
{
% A paragraph with more lines than were narrowed went on below the
% image: the zone is over, whatever page it ended on. Otherwise the
% zone may go on; it cannot break, so a new page means it moved.
\int_compare:nNnTF { \tex_prevgraf:D } > { \g__wrapblock_narrowed_int }
{ \__wrapblock_stop: }
{
\__wrapblock_check_ship:
\dim_compare:nNnTF { \pagetotal + \pagedepth } < { \g__wrapblock_bottom_dim }
{ \nobreak \__wrapblock_list_penalties_off: }
{ \__wrapblock_stop: }
}
}
%
%
% In a box (minipage, \parbox, tcolorbox) \pagetotal says nothing of the
% position, and no page can break anyway: the text goes in a minipage and
% the image beside it, aligned on the first line.
\cs_new_protected:Npn \__wrapblock_inbox_image:
{
\__wrapblock_build:
\box_move_down:nn
{ \box_ht:N \g__wrapblock_img_box - \box_ht:N \strutbox }
{ \box_use:N \g__wrapblock_img_box }
}
\cs_new_protected:Npn \__wrapblock_inbox_begin:
{
\msg_info:nn { wrapblock } { inbox }
\noindent
\str_if_eq:VnT \l__wrapblock_side_tl { l }
{ \__wrapblock_inbox_image: \hfill }
\begin{minipage}[t]{ \dim_eval:n { \linewidth - \g__wrapblock_shift_dim } }
}
\cs_new_protected:Npn \__wrapblock_inbox_end:
{
\end{minipage}
\str_if_eq:VnT \l__wrapblock_side_tl { r }
{ \hfill \__wrapblock_inbox_image: }
\par
}
\msg_new:nnn { wrapblock } { inbox }
{ The~block~that~ends~on~input~line~\msg_line_number:\ is~inside~a~box:~its~text~
is~set~beside~the~image,~without~wrapping~under~it. }
%
%
% The room left on the page. Right after a heading, the space below it is
% not on the page yet: \pagetotal counts it only when the next paragraph
% starts. It is the last item of the list, and \lastskip gives it. When
% the page itself ends with glue, it is subtracted twice: the error only
% makes the image less likely to fit.
\cs_new:Npn \__wrapblock_room: { ( \pagegoal - \pagetotal - \lastskip ) }
%
%
% Not enough room left for the image, or the page already holds more than
% it can (TeX cuts it only at the next legal break). An invisible rule as
% tall as the image makes the page overflow, and a breakpoint after it,
% which TeX cannot take on a full page, makes TeX cut now at its best
% earlier break: before a heading, which forbids a break after itself,
% or before the previous paragraph. The rule is taller than the image by
% the shrink of the page: otherwise, when the image is only a little too
% tall, the page still fits by shrinking its glue, TeX takes the
% breakpoint after the rule, and a heading is left alone at the bottom.
% A negative skip then gives the room back, and \pagetotal measures the
% page the block starts on.
\cs_new_protected:Npn \__wrapblock_need_space:
{
% An image taller than the page fits nowhere: the rule below would
% leave an empty page. A plain page break, and the image overflows.
\dim_compare:nNnTF
{ \g__wrapblock_height_dim + \baselineskip } > { \tex_vsize:D }
{ \newpage }
{ \__wrapblock_need_space_aux: }
}
\cs_new_protected:Npn \__wrapblock_need_space_aux:
{
\dim_set_eq:NN \l__wrapblock_base_dim \prevdepth
\legacy_if:nF { @nobreak } { \tex_penalty:D 0 ~ }
\dim_set:Nn \l__wrapblock_rule_dim
{ \g__wrapblock_height_dim + \baselineskip + \tex_pageshrink:D + 1sp }
\tex_hrule:D height \l__wrapblock_rule_dim depth 0pt width 0pt \scan_stop:
\tex_penalty:D 9999 ~
% in a group: the primitive \par clears \parshape, which a list needs
\group_begin: \tex_par:D \group_end:
\tex_penalty:D 10000 ~
\skip_vertical:n { - \l__wrapblock_rule_dim }
% An \item, a list or a heading that starts the block calls \addvspace,
% which would cancel a negative skip it finds last: hide it.
\tex_penalty:D 10000 ~
\tex_prevdepth:D \l__wrapblock_base_dim
}
%
%
% The image does not fit at the bottom of the page. With the text long
% enough to fill that bottom at full width and run on to the next page,
% the image is deferred to the top of that page. With a shorter text, the
% image would end up alone: the whole block moves to the next page.
% Columns (twocolumn, multicols) are not handled: the block moves.
\cs_new_protected:Npn \__wrapblock_decide:n #1
{
\bool_set_false:N \l__wrapblock_defer_bool
\bool_lazy_or:nnTF
{ \legacy_if_p:n { @twocolumn } }
{
\bool_lazy_and_p:nn
{ \cs_if_exist_p:N \col@number }
{ \int_compare_p:nNn { \col@number } > { 1 } }
}
{ \__wrapblock_need_space: }
{
% defer=false: the body is not measured, the whole block moves
\bool_lazy_or:nnTF
{ ! \l__wrapblock_allow_defer_bool }
{ \dim_compare_p:nNn { \__wrapblock_room: } < { 2 \baselineskip } }
{ \__wrapblock_need_space: }
{
\__wrapblock_measure:n {#1}
\dim_compare:nNnTF
{ \g__wrapblock_text_dim } < { \__wrapblock_room: + 2 \baselineskip }
{
\msg_warning:nn { wrapblock } { short }
\__wrapblock_need_space:
}
{ \bool_set_true:N \l__wrapblock_defer_bool }
}
}
}
\msg_new:nnn { wrapblock } { short }
{ The~image~of~the~block~that~ends~on~input~line~\msg_line_number:\ does~not~fit~
at~the~bottom~of~the~page,~and~its~text~is~too~short~to~run~on~to~
the~next~page:~the~whole~block~moves~to~the~next~page,~and~leaves~
room~at~the~bottom~of~this~one. }
%
%
% The text of the block, set at full width in a box that is thrown away.
% Counters are put back; labels, footnotes and index entries vanish with
% the box. A block that comes first in an \item sets its label in the box too: the
% label and the state of the list are put back as well.
\cs_new_protected:Npn \__wrapblock_counters_save:
{
\tl_gclear:N \g__wrapblock_counters_tl
\group_begin:
\cs_set:Npn \@elt ##1
{
\tl_gput_right:Ne \g__wrapblock_counters_tl
{ \int_gset:Nn \exp_not:c { c@##1 } { \int_use:c { c@##1 } } }
}
\cl@@ckpt
\group_end:
}
\cs_new_protected:Npn \__wrapblock_measure:n #1
{
\__wrapblock_counters_save:
\hbox_set:Nn \l__wrapblock_labels_box { \box_use:N \@labels }
\hbox_gset:Nn \@labels { \box_use:N \l__wrapblock_labels_box }
\clist_map_inline:nn { @inlabel , @newlist , @noparitem , @minipage , @nobreak }
{
\tl_gput_right:Ne \g__wrapblock_counters_tl
{ \legacy_if:nTF {##1} { \exp_not:c { ##1true } } { \exp_not:c { ##1false } } }
}
\tl_set_eq:NN \l__wrapblock_freelist_tl \@freelist
\tl_set_eq:NN \l__wrapblock_currlist_tl \@currlist
\group_begin:
\cs_if_exist_use:NT \tag_suspend:n { { wrapblock } }
\vbox_set:Nn \l__wrapblock_measure_box
{
\bool_set_false:N \l__wrapblock_outer_bool
% A float or a \marginpar cannot leave a box. Between two
% paragraphs, LaTeX sees the box and gives an error: here they are
% set in boxes of the package, without the error. Inside a
% paragraph, LaTeX does not see it and takes a float box: the
% lists of float boxes are put back after the measure.
\cs_set_eq:NN \@parmoderr \prg_do_nothing:
\cs_set_eq:NN \@currbox \g__wrapblock_float_box
\cs_set_eq:NN \@marbox \g__wrapblock_mar_box
\dim_set_eq:NN \hsize \linewidth
\dim_zero:N \@totalleftmargin
\tex_parshape:D 0 ~
\int_set:Nn \hbadness { 10000 }
\int_set:Nn \vbadness { 10000 }
\dim_set_eq:NN \hfuzz \c_max_dim
#1
\par
}
\dim_gset:Nn \g__wrapblock_text_dim
{ \box_ht:N \l__wrapblock_measure_box + \box_dp:N \l__wrapblock_measure_box }
\cs_if_exist_use:NT \tag_resume:n { { wrapblock } }
\group_end:
\tl_use:N \g__wrapblock_counters_tl
\hbox_gset:Nn \@labels { \box_use:N \l__wrapblock_labels_box }
\tl_gset_eq:NN \@freelist \l__wrapblock_freelist_tl
\tl_gset_eq:NN \@currlist \l__wrapblock_currlist_tl
}
%
%
% An empty structure element where the block starts: a deferred image is
% put in it when its page is shipped.
\cs_new_protected:Npn \__wrapblock_placeholder:
{
\int_gzero:N \g__wrapblock_struct_int
\cs_if_exist:NT \tag_if_active:T
{
\tag_if_active:T
{
\tag_struct_begin:n { tag = NonStruct }
\int_gset:Nn \g__wrapblock_struct_int { \tag_get:n { struct_num } }
\tag_struct_end:
}
}
}
%
%
\msg_new:nnn { wrapblock } { early }
{ The~page~broke~too~early~in~the~text~of~the~block~that~ends~on~
input~line~\msg_line_number:,~before~its~image~was~set:~a~footnote~in~the~
full-width~lines~shortened~the~page,~and~a~page~with~a~few~lines~is~
left~before~the~image.~Rerun~LaTeX~to~get~it~right. }
\msg_new:nnn { wrapblock } { alone }
{ The~text~of~the~block~that~ends~on~input~line~\msg_line_number:\ ended~before~
the~bottom~of~the~page:~its~image~is~set~after~it. }
%
%
% ---------------------------------------------------------------- user
\NewDocumentEnvironment { wrapblock } { O{} +m +b }
{
\par
\bool_if:NT \l__wrapblock_inimage_bool { \msg_error:nn { wrapblock } { nested } }
\int_gincr:N \g__wrapblock_block_int
\keys_set:nn { wrapblock } {#1}
\tl_gset:Nn \g__wrapblock_img_tl {#2}
\dim_gset_eq:NN \g__wrapblock_img_width_dim \l__wrapblock_width_dim
% measured here, with tagging suspended; built for good where it is
% placed, inside the first paragraph (see \__wrapblock_build:)
% the counters it steps (an equation, a caption) are put back
\cs_if_exist_use:NT \tag_suspend:n { { wrapblock } }
\__wrapblock_counters_save:
\__wrapblock_build:
\tl_use:N \g__wrapblock_counters_tl
\cs_if_exist_use:NT \tag_resume:n { { wrapblock } }
\dim_gset:Nn \g__wrapblock_height_dim
{ \box_ht:N \g__wrapblock_img_box + \box_dp:N \g__wrapblock_img_box
+ \l__wrapblock_vsep_dim }
\dim_gset:Nn \g__wrapblock_shift_dim
{ \box_wd:N \g__wrapblock_img_box + \l__wrapblock_hsep_dim }
\dim_compare:nNnT { \g__wrapblock_height_dim } > { \textheight }
{ \msg_warning:nn { wrapblock } { tall } }
% less than 3em left beside the image: no wrapping, the image is set
% on a line of its own, above the text
\dim_compare:nNnTF { \linewidth - \g__wrapblock_shift_dim } < { 3em }
{
\msg_warning:nne { wrapblock } { wide }
{ \dim_eval:n { \linewidth - \g__wrapblock_shift_dim } }
\bool_set_true:N \l__wrapblock_alone_bool
\noindent \__wrapblock_build: \box_use:N \g__wrapblock_img_box
\par \nobreak
}
{
\mode_if_inner:TF
{
\bool_set_true:N \l__wrapblock_inbox_bool
\__wrapblock_inbox_begin:
}
{ \__wrapblock_begin:n {#3} }
}
#3
}
{
\bool_if:NTF \l__wrapblock_alone_bool
{ \par }
{
\bool_if:NTF \l__wrapblock_inbox_bool
{ \__wrapblock_inbox_end: }
{ \__wrapblock_end: }
}
}
\msg_new:nnn { wrapblock } { wide }
{ The~image~of~the~block~that~ends~on~input~line~\msg_line_number:\
leaves~only~#1~for~the~text~beside~it:~it~is~set~above~the~text,~
which~is~not~wrapped. }
\msg_new:nnn { wrapblock } { tall }
{ The~image~of~the~block~that~ends~on~input~line~\msg_line_number:\
is~taller~than~the~page. }
%
%
\cs_new_protected:Npn \__wrapblock_begin:n #1
{
\bool_if:NT \g__wrapblock_active_bool { \msg_error:nn { wrapblock } { nested } }
\dim_gset_eq:NN \g__wrapblock_left_dim \@totalleftmargin
\dim_gset_eq:NN \g__wrapblock_width_dim \linewidth
\bool_set_false:N \l__wrapblock_defer_bool
\dim_compare:nNnF { \pagegoal } = { \c_max_dim }
{
\dim_compare:nNnT { \__wrapblock_room: }
< { \g__wrapblock_height_dim + \baselineskip }
{ \__wrapblock_decide:n {#1} }
}
\tl_gset_eq:NN \g__wrapblock_side_tl \l__wrapblock_side_tl
\int_gset_eq:NN \g__wrapblock_save_pre_int \predisplaypenalty
\int_gset_eq:NN \g__wrapblock_save_post_int \postdisplaypenalty
\int_gset_eq:NN \g__wrapblock_save_item_int \@itempenalty
\int_gset_eq:NN \g__wrapblock_save_beginpar_int \@beginparpenalty
\int_gset_eq:NN \g__wrapblock_save_endpar_int \@endparpenalty
\tl_put_left:Nn \@arrayparboxrestore
{ \__wrapblock_box_check: \bool_set_false:N \l__wrapblock_outer_bool }
\bool_set_true:N \l__wrapblock_inside_bool
\seq_gclear:N \g__wrapblock_shapes_seq
\bool_if:NTF \l__wrapblock_defer_bool
{
\bool_gset_false:N \g__wrapblock_pending_bool
\bool_gset_true:N \g__wrapblock_wait_bool
\int_gset_eq:NN \g__wrapblock_origin_ship_int \g__wrapblock_ship_int
\dim_gset:Nn \g__wrapblock_bottom_dim
{ \topskip - \box_ht:N \strutbox + \g__wrapblock_height_dim }
\dim_gset_eq:NN \g__wrapblock_goal_dim \pagegoal
\prop_get:NeNTF \g__wrapblock_short_prop { \int_use:N \g__wrapblock_block_int } \l_tmpa_tl
{ \dim_gset:Nn \g__wrapblock_short_dim { \l_tmpa_tl } }
{ \dim_gzero:N \g__wrapblock_short_dim }
\__wrapblock_placeholder:
}
{
\bool_gset_true:N \g__wrapblock_pending_bool
\bool_gset_false:N \g__wrapblock_wait_bool
}
\bool_gset_true:N \g__wrapblock_active_bool
}
%
%
\cs_new_protected:Npn \__wrapblock_end:
{
\par
% the measure was wrong: the text ended on the page it started on
\bool_if:NT \g__wrapblock_wait_bool
{
\msg_warning:nn { wrapblock } { alone }
\bool_gset_false:N \g__wrapblock_wait_bool
\bool_gset_true:N \g__wrapblock_pending_bool
\dim_compare:nNnT { \__wrapblock_room: }
< { \g__wrapblock_height_dim + \baselineskip }
{ \__wrapblock_need_space: }
}
\bool_if:NT \g__wrapblock_pending_bool { \noindent \strut \par }
\bool_if:NT \g__wrapblock_active_bool
{
\__wrapblock_check_ship:
\dim_compare:nNnT { \pagetotal + \pagedepth } < { \g__wrapblock_bottom_dim }
{
\nobreak
\skip_vertical:n { \g__wrapblock_bottom_dim - \pagetotal - \pagedepth }
}
\__wrapblock_stop:
}
}
%