> For the complete documentation index, see [llms.txt](https://overleaf-pro.ayaka.space/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://overleaf-pro.ayaka.space/latex/da/dybtgaende-artikler/36-pandora-s-hbox-using-luatex-to-lift-the-lid-of-tex-boxes.md).

# Pandoras \hbox: Brug af LuaTeX til at løfte låget på TeX-bokse

## Introduktion

Kasser og glue er to nøglebegreber, som udgør grundlaget for TeX's satsmodel og muligheder. Bygger videre på introduktionsmaterialet i et tidligere opslag, [Kasser og glue: En kort, men visuel, introduktion med LuaTeX](/latex/da/dybtgaende-artikler/11-boxes-and-glue-a-brief-but-visual-introduction-using-luatex.md), undersøger denne rigt illustrerede artikel kasser og glue mere detaljeret. Vi præsenterer også et nyt LuaTeX-baseret [Overleaf-projekt](https://www.overleaf.com/latex/examples/exploring-the-structure-of-tex-boxes-with-luatex/pwdrypmtdbgs) der gør det muligt for dig at udforske den dybe indre struktur af TeX-kasser—og giver indsigt, som vil hjælpe dig med virkelig at forstå deres opførsel. Oprettelsen af Overleaf-projektet blev i høj grad lettet af Patrick Gundlachs arbejde, så vi takker [vores tak til ham](#credits-thanks-patrick).

## Hvorfor vælge LuaTeX?

For det første er det værd at gentage forskellen mellem LuaTeX og LuaLaTeX:

* LuaTeX er navnet på en eksekverbar TeX-baseret satsmotor;
* LuaLaTeX henviser til brugen af LaTeX-makropakken med LuaTeX-motoren.

Denne forskel er yderst vigtig, fordi vi i denne artikel udnytter de indbyggede muligheder i selve LuaTeX-motoren, og ikke blot drager nytte af de funktioner/funktionaliteter, som kommandoer fra LaTeX-makropakken tilbyder.

Læsere, der er usikre på forskellen mellem en TeX-motor og LaTeX-makropakken, [Hvad er der i et navn: En guide til de mange smagsvarianter af TeX](/latex/da/dybtgaende-artikler/55-what-s-in-a-name-a-guide-to-the-many-flavours-of-tex.md)som forklarer disse forskelle noget mere detaljeret. Den samme artikel diskuterer også “TeX” som et programmeringssprog og at TeX-baserede satsmotorer (f.eks. pdfTeX, XeTeX og LuaTeX) ikke blot varierer i deres funktioner og funktionalitet, men også har variationer i den “smag” af TeX-sproget, de understøtter. Det bringer os til vores valg af LuaTeX. Ud over at understøtte et TeX-baseret programmeringssprog har LuaTeX også programmeringssproget Lua indlejret i sig—hvilket giver adgang til et enkelt, men meget kraftfuldt, almindeligt programmeringssprog. Gennem Lua og LuaTeX's indbyggede funktionalitet kan du udforske og styre satsaktiviteterne i LuaTeX på måder, som ingen anden TeX-motor tilbyder—og dette inkluderer muligheden for at undersøge TeX-kassers indre strukturer; derfor er LuaTeX det ideelle (eneste) valg til denne artikel og det tilhørende Overleaf-projekt.

### pdfTeX/XeTeX vs. LuaTeX: i billeder

Følgende *diagrammer* er beregnet til at fremhæve en vigtig sammenligning mellem designet af pdfTeX/XeTeX og LuaTeX. Både pdfTeX og XeTeX giver naturligvis brugerne mulighed for at skrive TeX-kode, der kan påvirke satsadfærden; men de dybere interne strukturer, der findes i disse TeX-motorer, og lavniveau-data, der konstrueres under satsprocessen, er for det meste utilgængelige for brugerkommandoer og -makroer. I den forstand er de *relativt* lukkede systemer sammenlignet med LuaTeX.

#### pdfTeX/XeTeX

![{{{alt}}}](/files/c8185456a79ae0ae0d7b2fc8a5904a4b2b890563)

#### LuaTeX

LuaTeX introducerer en ny primitiv kommando kaldet `\directlua{...}` hvorigennem du kan skrive kode, som ikke blot giver fuld adgang til Lua-sproget, men også gør det muligt at udvide LuaTeX's muligheder ved at skrive plug-ins ved hjælp af sprog som C og C++. På Windows kaldes sådanne plugins *dynamiske linkbiblioteker* (.DLL); på Linux er de kendt som *delte objektbiblioteker* (.so). LuaTeX's virkelige kraft stammer fra et stort sæt indbyggede Lua-funktioner, der giver adgang til de interne dele af LuaTeX—og muliggør yderst sofistikeret styring og programmering af TeX-baseret sats. Et sæt sådanne funktioner kaldes et API (Application Programming Interface), og det er gennem LuaTeX's API, at du bruger Lua-programmer til at kommunikere med dens TeX-baserede satsmotor og datastrukturer.

![{{{alt}}}](/files/6979787b290a4652a3617f086241b3c3421df78e)

Med LuaTeX's `\directlua{...}` \directlua{}-kommando kan du for eksempel få adgang til interne TeX-datastrukturer på lavt niveau, som er skjult for andre TeX-motorer. Derudover kan du bruge Lua-scripts til at udføre alle mulige programmeringsberegninger, strengmanipulation osv. og sende resultaterne tilbage til TeX: mulighederne er næsten uendelige. Denne artikel er dog ikke tænkt som en detaljeret gennemgang eller tutorial i LuaTeX—selv om det er fristende at give eksempler, som formidler den utrolige alsidighed hos denne forbløffende kraftfulde TeX-motor.

## Kasser og glue: En kort påmindelse

Som introduceret i artiklen [Kasser og glue: En kort, men visuel, introduktion med LuaTeX](https://www.overleaf.com/blog/511-boxes-and-glue-a-brief-but-visual-introduction-using-luatex) boxes and glue er to nøglebegreber, der understøtter TeX's satsmuligheder. Følgende diagram tilbydes som et meget kort huskekort om opførselen af TeX's horisontale og vertikale kassetyper. Bemærk: Horisontale kasser kan naturligvis indeholde tekst sat i højre-mod-venstre-sprog, såsom arabisk eller hebraisk, hvilket betyder, at retningen for kassens vækst kan være modsat den, der er vist for den horisontale kasse i diagrammet nedenfor.

![{{{alt}}}](/files/c7ba9c8ed57363c2724f7af4825d9c32e562514b)

### TeX-primitiver til konstruktion af kasser

I dag forbereder de fleste deres TeX-dokumenter ved hjælp af LaTeX-makropakken, som er designet til at give kommandoer, der skærmer brugerne fra meget af TeX's lavniveau-sprog—dets såkaldte *primitiver*—de kernekommandoer, der er indbygget i TeX-motorer (se artiklen [Hvad er der i et navn: En guide til de mange smagsvarianter af TeX](/latex/da/dybtgaende-artikler/55-what-s-in-a-name-a-guide-to-the-many-flavours-of-tex.md) for en diskussion af TeX-primitiver). LaTeX-makrosamlingen tilbyder en række makroer til oprettelse og lagring (gemning) af kasser, men hvis du fjerner al makrokoden, vil du opdage, at der kun er 4 lavniveau primitiv-kommandoer til konstruktion af kasser:

Til oprettelse af horisontale lister:

* \hbox{...}

Til oprettelse og stabling af vertikale lister:

* \vbox{...}
* \vtop{...}
* \vcenter{...}

Vi vil ikke forklare, hvordan man bruger alle disse kassekommandoer, fordi der er masser af eksempler og vejledninger andre steder på nettet eller i TeX/LaTeX-bøger—men vi vil se nærmere på, hvordan kasser repræsenteres og lagres inde i TeX-datastrukturer.

### Glue: fleksibel afstand

Glue er i praksis en form for afstand, som TeX bruger til at placere genstande vandret eller lodret. Som TeX-bruger kan vi bede TeX om at indsætte noget glue af en fast størrelse, eller vi kan bruge glue, der er fleksibel—med så meget fleksibilitet, som vi har brug for, enten til at strække eller krympe afhængigt af vores behov. En af TeX's kommandoer til at oprette glue til horisontal afstand kaldes `\hskip` som har formen

`**\hskip** <naturlig bredde> **plus** <mængde til at strække> **minus** <mængde til at krympe>`

`**plus**` og `**minus**` er TeX-nøgleord, men du behøver ikke at bruge dem for al glue. Hvis `**plus**` eller `**minus**` mangler, så antages den tilsvarende `<mængde til at strække>` eller `<mængde til at krympe>` at være nul. For eksempel, `\hskip 3pt` indsætter glue med fast bredde uden nogen stræk- eller krymp-komponent.

For nu kan du tænke på `<mængde til at strække>` og `<mængde til at krympe>` som vores *anbefalinger* til TeX, fordi den præcise mængde strækning eller krympning vil blive beregnet af TeX.

For at hjælpe med disse idéer er her et diagram, der repræsenterer glue som en fjeder. Den `<naturlig bredde>` er fjederens længde, når der ikke er nogen spænding (strækning) eller kompression (sammenpresning). De `<mængde til at strække>` og `<mængde til at krympe>` er vist i forhold til fjederens naturlige længde.

![{{{alt}}}](/files/8631c13641df649afa9df413d8c503e8030e0518)

#### Et \hbox-eksempel

Antag, at vi ønsker at oprette en `\hbox{...}` indeholder blot bogstaverne A, B, C og D, og vi har brug for, at denne kasse er 100pt (100 TeX-punkter) bred. Derudover kan vi roligt antage, at den samlede bredde af disse fire tegn er langt mindre end 100pt, hvilket indikerer, at TeX har brug for en eller anden måde at fylde den resterende plads inde i kassen: vi vil bruge noget glue til det. Men fordi vi ikke kender den præcise mængde glue, der kræves for at fylde kassen, er det klogt at tilføje noget fleksibel glue og lade TeX stå for at beregne den mængde plads, disse glue skal optage. I det følgende kodestykke skal du bemærke brugen af “%” til at undertrykke ordmellemrum, der opstår fra linjeslutningstegnene.

```
\hbox to100pt{%
A\hskip4pt plus3pt minus 2pt B%
\hskip 0pt plus 2fil C%
\hskip 0pt plus 2fill D%
\hskip 0pt plus 3fill}
```

Den resulterende kasse ser således ud (forstørret for klarhed):

![{{{alt}}}](/files/49e4995f053e1f02a4ee6dd87dc0f9a798853f58)

Denne `\hbox` er overlejret med stiplede bokse (i rødt) for at angive tegnenes bredde (som TeX ser dem). `\hbox`bestemmes (beregnes) ved at tage højde for hvert tegns bredde.

Det viser sig, at TeX ikke strakte eller krympede glue mellem A og B (sat til 4pt), og der er ingen glue mellem B og C (sat til 0pt). Men glue mellem C og D og glue mellem D og slutningen af kassen er begge blevet strakt betydeligt, fordi disse glue har den mest fleksible strækkomponent—i praksis absorberede disse glue al den strækning, der var nødvendig for at fylde kassen.

## Tilbage til LuaTeX

Indtil videre har vi udforsket kasser og glue og set, at LuaTeX giver adgang til interne TeX-strukturer, som er skjult for synet i pdfTeX og XeTeX. Det er tid til et eksempel, der gør dette mere eksplicit, men først må vi kort gøre os bekendt med den måde, TeX lagrer kasser i sin hukommelse på—vi begynder med en analogi.

### Hvordan TeX lagrer kasser i hukommelsen: en analogi

Antag, at du af en eller anden grund havde brug for at oprette en datamodel, der beskriver en fysisk kasse. Hvilke data ville du vælge til at give en sådan beskrivelse? En tilgang, du kunne anvende, er at opdele oplysningerne i to dele: data om selve den fysiske kasse og data, der giver en liste over kassens indhold. Så vores enkle model kunne se sådan ud:

1. Data om den fysiske kasse (“metadata”):

* width
* højde
* dybde
* vægt
* farve
* type (træ, plastik, pap)

3. Data om kassens indhold: en eller anden form for liste, der beskriver de genstande, den indeholder—sandsynligvis opført i ingen bestemt rækkefølge.

Og der er en meget tæt analogi med den måde, TeX lagrer kasser på.

### Hvordan TeX lagrer kasser i hukommelsen: hlists og vlists

Internt opretter TeX “beholdere” kaldet *hlists* (horisontale lister) og *vlists* (vertikale lister), som repræsenterer hboxes og vboxes henholdsvis. Disse hlist/vlist-objekter giver en samling af “metadata” om kassen og giver derudover adgang til listen over objekter, som kassen faktisk indeholder—den liste kaldes en *node-liste*. I modsætning til en fysisk kasse, hvor du kan placere genstande i vilkårlig rækkefølge, er rækkefølgen af kassens indhold yderst vigtig for TeX—det er elementer, der skal satses. Hvis du har nogen programmerings- eller datalogibaggrund, vil du ikke blive overrasket over at høre, at objekterne i en TeX-kasse lagres, og at rækkefølgen af deres oprettelse bevares, ved hjælp af en såkaldt [dobbeltkædet liste](https://en.wikipedia.org/wiki/Doubly_linked_list). Vi vil ikke gå yderligere i detaljer om kædede lister, fordi nettet vrimler med vejledninger, eksempler og forklaringer.

Begrebet noder og node-lister er et grundlæggende aspekt af, hvordan TeX virker, men i denne artikels sammenhæng giver vi kun en kort oversigt. Noder er i virkeligheden en slags “mini-beholder”, og (pr. LuaTeX 1.04) findes der omkring 50 forskellige nodetyper: som afspejler de indre datatyper og komponenter, LuaTeX bruger til sats. For eksempel findes der noder til at repræsentere: glyphs (som opstår fra “tegn”), glue, horisontale/vertikale rules, penalties, “whatsits”, kerns og så videre. Alt sat materiale vil i sidste ende blive en del af en enorm node-liste, og LuaTeX giver dig direkte adgang til disse indre datastrukturer. LuaTeX giver dig også mulighed for at tilføje, redigere, ændre eller oprette node-lister, så du for eksempel kan oprette kasser direkte inde i Lua-kode uden overhovedet at skulle bruge TeX-kode. Men det at skrive om det er en sag for en anden dag.

### Et simpelt eksempel på \directlua{...} i praksis

Det følgende eksempel opretter en `\hbox` og gemmer den i kasseregister 0. Vi rapporterer derefter kassens bredde ved hjælp af traditionel TeX-kode og får den samme information ved hjælp af en anden metode via `\directlua{}`. Her kører vi et lille Lua-script, som tilgår TeX's interne kasselagringsområde for at få kassens bredde—naturligvis er de to værdier identiske: 2412092sp (sp=scaled point: 65536sp = 1 TeX-punkt). I sidste ende undersøger både TeX-koden og Lua-koden i dette meget enkle eksempel de samme interne datastrukturer for at få kassens bredde, men det er gennem den direkte adgangsvej, at LuaTeX åbner døren til en rigdom af information og kontrol, som ikke er tilgængelig med andre motorer.

![{{{alt}}}](/files/c239e42baceed0cfff5f69d99e01a709479715b8)

```latex
\documentclass{article}
\begin{document}
\setbox0=\hbox{A\hskip 5pt B\hskip 10pt C}
\fontsize{18}{22}\selectfont
\noindent Ved hjælp af \TeX{}-kode har kasse 0 bredden \number\wd0\relax \space sp\par
\noindent Vi kan også bruge Lua og kalde en af Lua\TeX's funktioner for at få den samme
information.\vskip10mm
\noindent Fra Lua-kode har kasse 0 bredden
\directlua{
local boxwidth = tex.box[0].width
tex.print(boxwidth.." sp")
} hvilket naturligvis er identisk med den værdi, der er opnået fra \TeX{}-kode.
\end{document}
```

## At samle det hele: Et Overleaf-projekt

Vi har bemærket, at TeX internt repræsenterer kasser som “beholdere” kaldet hlists/vlists, som lagrer “metadata” om kassen og giver adgang til listen over komponenter, som kassen er opbygget af. Ved hjælp af LuaTeX kan du få adgang til kassens “metadata” og til listen over elementer, der er indeholdt i en TeX-kasse: glyphs, glue, penalties, andre kasser og så videre. Ved hjælp af Lua-scripts er det muligt at undersøge en kasse, der ligger i TeX's hukommelse, og tegne en detaljeret repræsentation af, hvad den kasse indeholder. En passende repræsentation af en TeX-kasse og dens indhold opnås ved hjælp af *nodegrafer* og vi har forberedt et [Overleaf-projekt](https://www.overleaf.com/latex/examples/exploring-the-structure-of-tex-boxes-with-luatex/pwdrypmtdbgs) som gør det ved at udnytte et fremragende Lua-script skrevet af Patrick Gundlach (se credits). Vi vil ikke beskrive de detaljerede processer, der kræves for at undersøge kasser og generere nodegrafer—bortset fra at bemærke, at ethvert program/script, der behandler TeX-kasser, skal være *rekursiv* fordi kasser kan være indlejrede: dvs. du kan have hboxes inden i vboxes, inden i hboxes… og kombinere alle kassetyper til et meget dybt niveau af indlejring.

![{{{alt}}}](/files/42d45eae2935dd951d716a8a316d3516484ce9b5)

### Hvad giver projektet?

Det implementerer kun 1 kommando kaldet `\dobox{box command}`, for eksempel:

```latex
\dobox{\hbox to100pt{%
A\hskip4pt plus3pt minus 2pt
B\hskip 0pt plus 2fil
C\hskip 0pt plus 2fill
D\hskip 0pt plus 3fill}}
```

Den `\dobox{...}` kommando udfører en række opgaver:

1. i dit dokument sætter den TeX-kode for din kasse ordret;
2. den genererer en SVG-grafik af TeX-kassen—du kan indlejre denne i en webside (som vi har gjort i dette blogindlæg);
3. den genererer en SVG-grafik af node-listen—som du også kan indlejre i websider (som vi har gjort i dette blogindlæg);
4. den outputter en PDF-grafik af node-listen, som derefter importeres i det primære PDF-dokument, som projektet producerer.

Nodegrafer kan meget hurtigt blive ekstremt store på grund af den enorme mængde data, som LuaTeX er nødt til at lagre for at repræsentere komplekse TeX-kasser—såsom den side, der i øjeblikket er ved at blive konstrueret, eller sat matematik. For større node-lister kan den importerede PDF-grafik blive afskåret af dit dokuments sidelayout—hvis du vil se en stor nodegraf, kan du downloade en ZIP-fil af projektet og udpakke den relevante PDF-grafik. Når du downloader projektets ZIP-fil, skal du sørge for at vælge “Input and Output Files” fra rullemenuens valgliste:

![{{{alt}}}](/files/5a76e7c392965ca0739e9a9a0d0f0a3e9ab8fbae)

### Grafik fra Overleaf-projektet: En kort beskrivelse

Før vi viser nogle eksempler, er det værd at gøre et par observationer om den grafik, som Overleaf-projektet producerer—vi bruger det samme `\hbox` eksempel, som blev nævnt tidligere i artiklen. Her er det pakket ind i projektets `\dobox{...}` kommandoen:

```latex
\dobox{\hbox to100pt{%
A\hskip4pt plus3pt minus 2pt
B\hskip 0pt plus 2fil
C\hskip 0pt plus 2fill
D\hskip 0pt plus 3fill}}
```

Her er den `\hbox` produceret af TeX—for klarhedens skyld er kassen blevet skaleret op, men rammen er inkluderet i den grafik, der produceres af Overleaf-projektet.

![{{{alt}}}](/files/69cf0055fb9bd898a8263fabb8b2171cd63a0664)

Her er en *annoteret* SVG-diagram af node-listen, der repræsenterer kassen ovenfor—annotationer blev tilføjet for at fremhæve kassens “metadata” og listen over objekter, den indeholder: disse annotationer er ikke til stede i den grafik, som Overleaf-projektet producerer.

[![{{{alt}}}](/files/9e99d927e59a90cbe595500fbcd60cb5f0b87d07)](https://www.filepicker.io/api/file/ZSwIylUR66eFYPMo0suX)

Hvis du ser på “metadata”-sektionen, vil du måske bemærke nogle ukendte parametre:

* `glue_set`
* `glue_sign`
* `glue_order`

Disse parametre er de indstillinger, som TeX bruger til at beregne, hvor meget glue der skal strækkes eller krympes inden i denne kasse, og er kun ét eksempel på data, som du nemt kan få via LuaTeX, men ikke med andre TeX-motorer. Bemærk, at glue-noder indeholdt i kassens komponenter *bevarer* de oprindelige glue-værdier, som vi skrev ind for at oprette kassen. Dette er essentielt, fordi TeX stiller kommandoerne `\unhbox`, `\unvbox`, `\unhcopy`, `\unvcopy` til rådighed, som “unboxer” kassens indhold og frigiver det tilbage til inputstrømmen, så det igen kan indgå i satsoperationer. Det er først, når TeX endeligt outputter (shipper out) kassen til en PDF- eller DVI-fil, at `glue_set`, `glue_sign` og `glue_order` anvendes på eventuelle glues i kassen—for at beregne den faktiske mængde strækning eller krympning, der kræves for at placere komponenterne inden i kassen, og derefter generere passende PDF-data eller DVI-opkoder.

En anden parameter, der er angivet i “metadata”, er `shift`: dette er værdien af kassens forskydning som følge af anvendelsen af TeX-kommandoerne:

* `\raise`, `\lower` (anvendt på en `\hbox`);
* `\moveleft`, `\moveright` (anvendt på en `\vbox`).

I vores eksempel, `shift` er 0pt, fordi vi ikke forskød `\hbox` fra dens naturlige position.

Den [Overleaf-projekt](https://www.overleaf.com/latex/examples/exploring-the-structure-of-tex-boxes-with-luatex/pwdrypmtdbgs) også nodegrafdiagrammer i PDF-format: her er et link til at downloade en [PDF-filversion](https://www.filepicker.io/api/file/bezigXESC2FSasvjoh8A) af nodegrafen ovenfor.

### Hvordan opretter Overleaf-projektet disse grafik?

Overleaf-projektet udnytter muligheden for at køre softwareværktøjer og hjælpeprogrammer, der er installeret på Overleafs servere—se [dette blogindlæg](/latex/da/dybtgaende-artikler/52-using-luatex-to-run-tools-and-utilities-installed-on-overleaf-s-servers.md) for flere detaljer og et eksempelprojekt. For at producere en SVG-grafik, der repræsenterer en TeX-kasse, skrives kassens TeX-kode ud til en lille fil, som derefter satses med pdfTeX for at generere en DVI-fil—bemærk, at pdfTeX-programmet udføres af LuaTeX via brugen af nogle få linjer Lua-script. Den DVI-fil konverteres on-the-fly til SVG ved hjælp af `dvisvgm` værktøjet—som følger med TeX Live-distributionen installeret på Overleafs servere. `dvisvgm` udføres med kommandolinjeindstillingen `-n` for at sikre, at enhver sat tekst konverteres til linjer/kurver, så korrekt gengivelse af SVG-filen ikke afhænger af, at TeX-fonte er installeret.

For at oprette nodegraferne bruger vi et Lua-script kaldet `hiviznodelist.lua` som er baseret på arbejde af Patrick Gundlach. Det script skriver en såkaldt `.gv` (Graphviz)-fil, som er en tekstfil, der indeholder en nodegraf beskrevet i `dot` sproget.  `.gv` filen behandles af et hjælpeprogram kaldet `dot` som outputterer et nodediagram i både PDF- og SVG-filformater.

### Projekteksempler

Her er nogle yderligere eksempler med SVG-grafik produceret ved hjælp af Overleaf-projektet. Kasser, der indeholder meget tekst (f.eks. i en \vbox), eller kompleks matematik, vil producere enorme nodegrafer—hvis du udforsker Overleaf-projektet, er det tilrådeligt ikke at bruge unødigt komplekse kasser til at demonstrere de funktioner, du er interesseret i.

#### \vbox to 25pt{A}

Dette eksempel demonstrerer effekten af at putte tekst direkte ind i en `\vbox`: bemærk, at nodestrukturen er ganske kompleks, selv for en så enkel kasse. Grunden til denne kompleksitet er, at tekst placeret direkte i en `\vbox` får TeX til at udføre linjebrydning. Du kan se, at `\vbox` er 345pt bred: værdien af `\hsize` på det tidspunkt, hvor denne kasse blev oprettet. Bemærk også, at tegnet “A” er indeholdt i en `hlist` som også er 345 punkter bred, og læg mærke til den store penalty (10000) sammen med `\parfillskip` og `\rightskip` glues i slutningen af kassens indhold. Denne penalty og de to glue-elementer indsættes af TeX's linjebrydningsaktiviteter. Hvis du ser på `glue_set` værdien for linjen i afsnittet (`hlist`) der indeholder bogstavet “A”, vil du se, at den er ekstremt stor (322.500000): hvorfor det? Det er fordi linjen i afsnittet er 345pt bred, men kun indeholder en `\parindent` og bogstavet “A”: den resterende plads skal fyldes af `\parfillskip` glue, som må strække sig en betydelig afstand for at fylde den resterende plads på linjen.

![{{{alt}}}](/files/1d21fd42fc6835a5fdc8d4862bfa77240e4427c7)

[![{{{alt}}}](/files/8dbceb081e228538942aa7bbb022c22ad2cfc853)](https://www.filepicker.io/api/file/pVtHsNGSQ4m09vBZuOpQ)

[Download PDF-fil](https://www.filepicker.io/api/file/nBS0uDs2QjqKCKljAm7r)

#### \vbox to 25pt{\hbox{A}}

Det er meget oplysende at sammenligne dette eksempel med det forrige. Her er ikke blot nodegrafen betydeligt mindre, men bredden af `\vbox` er kun 7.50002pt: den samme bredde som tegnet “A”. Grunden er, at “A” er blevet omsluttet i en `\hbox` som forhindrer `\vbox` i at udløse TeX til at udføre linjebrydning—en vigtig egenskab ved kasser oprettet med `\vbox`.

![{{{alt}}}](/files/3634b7c86bb989c66afd7252e0a8a0dab3e98a30)

[![{{{alt}}}](/files/1cea1a2c00b2975b7642f7a3a9271cca2cbb6543)](https://www.filepicker.io/api/file/LHepknjnRGOVEdghW4qH)

[Download PDF-fil](https://www.filepicker.io/api/file/Yk3uCCQR5ao8Yd3TJCdE)

#### Enkel matematik: \hbox{$$\displaystyle \int f(x) dx$$}, kompleks kasse!

Dette eksempel viser, at selv meget enkel sat matematik skaber en detaljeret kassestruktur: satsning af matematik producerer *ekstremt* komplekse datastrukturer i TeX!

![{{{alt}}}](/files/e9567cb39c8ce34ba4ac3983b0c4b2b9aeb4432b)

[![{{{alt}}}](/files/69a9ad6ea324ec3b6fe00c5100e6f25133c27dee)](https://www.filepicker.io/api/file/oVFNNvCqT0eZP0qS2odk)

[Download PDF-fil](https://www.filepicker.io/api/file/D5TepsdaSdeYZvkuSEJt)

## Credits: tak Patrick!

Vores tak til [Patrick Gundlach](https://twitter.com/patrickgundlach) som har givet Overleaf tilladelse til at bruge og distribuere en modificeret version af hans Lua-script, `viznodelist.lua`, som behandler TeX-kasser og outputterer en fil (i `dot` sproget), som kan behandles for at tegne en nodegraf. Overleaf-projektet indeholder et Lua-script kaldet `hiviznodelist.lua`—en omdøbt og modificeret version af Patricks oprindelige kode, som er tilgængelig på [Github](http://gist.github.com/556247). Patrick har skabt et open-source LuaTeX-baseret satsningssystem kaldet [speedata Publisher](https://speedata.github.io/publisher/index.html) som du kan downloade og bruge gratis—der findes også muligheder for kommerciel support.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://overleaf-pro.ayaka.space/latex/da/dybtgaende-artikler/36-pandora-s-hbox-using-luatex-to-lift-the-lid-of-tex-boxes.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.