/* The developer section's picture: a Claude Code session plays in its terminal (user request of
   16 November 2026: "un terminal avec Claude Code qui est animé", after a film of incident.io's
   homepage). One source for the homepage picture and for the `h-api` Stageshow scene
   (product-ui/src/api.tsx), which films the poster this play ends on.

   What plays, once each time the picture is looked at. It opens on a session just started: the
   terminal, two lines of its own at its head, its prompt, its caret. The developer's sentence
   is typed, a few cells at a breath, and sent: it goes up into its band at the head of the
   session. Claude works: its mark and its word stand under the last line written, while the
   seconds count. The session and the cart behind it answer each other, in the order the user
   set on 16 November 2026: "GET /v1/offers : afficher l'offre sur l'app derrière ; puis une
   fois que l'assurance est achetée il faut faire le POST /v1/orders". All of it happens to one
   card under the product. The card's place is there from the first frame, an outline and four
   bars. GET /v1/offers is written, and half a second later the offer comes into the card: an
   empty ring, the cover's name, its price. It is left to be read. Then it is bought, in the
   cart and by no call: the card gives as under a press, the cover's name gives way, the ring
   is ticked, the card takes the accent and reads "Order confirmed". Only then is POST
   /v1/orders written, half a second after the order is whole. Then the result, and what it
   means, in two lines. Claude's word gives way, in one frame, to the time it took. The last
   frame is the filmed poster, and the picture holds it.

   Taken from the reference: the manner (a sentence typed and sent, a word that glints while the
   work goes on, a count of seconds, lines that fade in crisp, the time it took at the end).
   Nothing of incident.io's own.

   How it is built. Every piece that plays carries a class of this sheet:
     .api__input   the prompt: .api__typed the sentence being typed, .api__caret the caret
     .api__hello   the two lines a session opens on, gone once the sentence is sent
     .api__band    the sentence once sent
     .api__call    "Calling Evy API", .api__secs its seconds (one cell, the figures behind it)
     .api__req     a call (--n: 0 or 1)
     .api__slot    the cover's place in the cart, before the first call (it does not move)
     .api__offer   the offer, in its card: what the first call brings
     .api__hint    the offer's second line, which gives way when the offer is bought
     .api__sold    the same card as the order, confirmed: the purchase, which the second call follows
     .api__head    the result
     .api__say     what it means (--n: 0 or 1)
     .api__spin    Claude's mark (.api__spark) and word (.api__verb, and .api__glint, its light)
     .api__done    the time it took
   In the scene they are the picture's own elements. On the page they are cuts of the filmed
   poster (see "The page" below). The root, .api, is marked data-play: "ready" holds the first
   frame, "on" plays, anything else is the poster.

   The terminal is a character grid, and the play is written in its units, each a length:
   --row (a line), --gap (the air between two groups), --band (the sentence's band), --ch (a
   cell). The scene sets them in its own pixels (product-ui/src/api.css); the page sets them
   from the picture's width. --api-chars is the number of cells the sentence takes. */

.api {
  /* The clock, from the moment the play starts */
  --api-type-at: .4s;      /* the first key */
  --api-type-for: 1.3s;    /* the sentence, typed */
  --api-send: 1.95s;       /* sent: the prompt empties and the session's opening lines give way */
  --api-up: 2.1s;          /* the sentence is in its band, and Claude starts */
  --api-t1: 2.6s;          /* the first call */
  --api-lag: .5s;          /* from the first call to the offer in the cart: the call is read first, then its effect seen */
  --api-buy: 5.1s;         /* the offer is bought, in the cart: it has stood whole for a second and a half */
  --api-step: 3.5s;        /* from one call to the next: the second is written half a second after the order is whole */
  --api-t5: 7.4s;          /* the result */
  --api-t6: 8s;            /* what it means, first line */
  --api-line: .5s;         /* from one line to the next */
  --api-done: 9.2s;        /* the time it took */
  --api-end: 10s;
}

/* How a piece arrives: one registered number, --api-in, from 0 to 1, from which its opacity is
   computed (and, for the cover's price, its place), so that it is drawn afresh where it stands
   on every frame and lands exactly (claim-play.css says why; do not animate opacity or a place
   directly on a piece that stays in the picture). A line fades in crisp: a first version brought
   each one into focus through a blur, which read as a smear at the size of terminal type. */
@property --api-in { syntax: '<number>'; inherits: false; initial-value: 1; }
/* The caret is in the picture at rest, so its blink is a number too: 1 is the caret, 0 is none */
@property --api-caret { syntax: '<number>'; inherits: false; initial-value: 1; }
/* The numbers the whole session shares, set on the root and read by its pieces. Whole numbers
   step by themselves: the cells typed so far, and the figure of the seconds (0 is "1"). */
@property --api-typed { syntax: '<integer>'; inherits: true; initial-value: 0; }
@property --api-n { syntax: '<integer>'; inherits: true; initial-value: 7; }
/* Whether the sentence has been sent (the session's opening lines are in the picture only before),
   whether Claude is at work (its mark and word are in the picture only then), and whether each
   line under the sentence has been written yet: the mark stands under the last one written. */
@property --api-sent { syntax: '<number>'; inherits: true; initial-value: 1; }
@property --api-work { syntax: '<number>'; inherits: true; initial-value: 0; }
@property --api-f1 { syntax: '<number>'; inherits: true; initial-value: 1; }
@property --api-f2 { syntax: '<number>'; inherits: true; initial-value: 1; }
@property --api-f3 { syntax: '<number>'; inherits: true; initial-value: 1; }
@property --api-f4 { syntax: '<number>'; inherits: true; initial-value: 1; }
@property --api-f5 { syntax: '<number>'; inherits: true; initial-value: 1; }

@keyframes api-in { from { --api-in: 0; visibility: hidden; } }
/* The same number for a thing that gives way: it is in the picture until its time, so nothing hides it */
@keyframes api-out { from { --api-in: 0; } }
/* And one for a thing that is covered: once the offer is whole over its place, and the order whole over the offer,
   what is under goes, unseen, so that nothing is taken away in one frame when the play ends */
@property --api-gone { syntax: '<number>'; inherits: false; initial-value: 0; }
@keyframes api-gone { to { --api-gone: 1; } }
/* A press: the offer gives and comes back, as a card does under a finger or a pointer (none is drawn) */
@property --api-press { syntax: '<number>'; inherits: false; initial-value: 0; }
@keyframes api-press { 45% { --api-press: 1; } }
/* The keys go a few cells at a breath, with three short rests: a hand, not a stream */
@keyframes api-type {
  0% { --api-typed: 0; }
  17%, 22% { --api-typed: calc(var(--api-chars) * .21); }
  42%, 48% { --api-typed: calc(var(--api-chars) * .5); }
  70%, 75% { --api-typed: calc(var(--api-chars) * .78); }
  100% { --api-typed: var(--api-chars); }
}
@keyframes api-empty { from, to { --api-typed: 0; } }
@keyframes api-sent { from { --api-sent: 0; } }
@keyframes api-secs { from { --api-n: 0; } }
@keyframes api-work { from { --api-work: 0; } 3%, to { --api-work: 1; } }
@keyframes api-f1 { from { --api-f1: 0; } }
@keyframes api-f2 { from { --api-f2: 0; } }
@keyframes api-f3 { from { --api-f3: 0; } }
@keyframes api-f4 { from { --api-f4: 0; } }
@keyframes api-f5 { from { --api-f5: 0; } }
@keyframes api-blink { 50% { --api-caret: 0; } }
@keyframes api-solid { from, to { --api-caret: 1; } }
/* A light passes over Claude's word, and its mark breathes. These two are animated in the usual way: Claude's
   mark and word have left the picture before anything rests. */
@keyframes api-glint { from { -webkit-mask-position: 160% 0; mask-position: 160% 0; } to { -webkit-mask-position: -60% 0; mask-position: -60% 0; } }
@keyframes api-spark { 50% { opacity: .45; } }
/* Nothing: its end is the end of the play (api-play.js listens for it) */
@keyframes api-clock { to { visibility: visible; } }

/* Where each piece is written, on the clock */
.api__band { --at: var(--api-up); }
.api__call { --at: var(--api-t1); }
.api__req { --at: calc(var(--api-t1) + var(--n, 0) * var(--api-step)); }
.api__offer { --at: calc(var(--api-t1) + var(--api-lag)); }
.api__hint { --at: calc(var(--api-buy) + .14s); }
.api__sold { --at: calc(var(--api-buy) + .26s); }
.api__head { --at: var(--api-t5); }
.api__say { --at: calc(var(--api-t6) + var(--n, 0) * var(--api-line)); }
.api__done { --at: var(--api-done); }

/* At rest: the prompt is empty, the caret at its first cell; the session's opening lines and Claude's mark and word are not in the picture */
.api__typed { clip-path: inset(0 calc(100% - var(--api-typed) * var(--ch)) 0 0); }
.api__caret { translate: calc((var(--api-typed) - var(--api-chars)) * var(--ch)) 0; }
.api__secs > b { translate: calc(var(--api-n) * var(--ch) * -1) 0; }
.api__hello { opacity: calc(1 - var(--api-sent)); }
.api__spin {
  position: absolute; left: 0; right: 0; opacity: var(--api-work);
  /* Under the last line written, the air of a group away: the band, then each line as it is written (the two
     calls, the result, the two lines) */
  top: calc(var(--band) + var(--gap)
    + var(--api-f1) * (var(--gap) + 2 * var(--row)) + var(--api-f2) * var(--row)
    + (var(--api-f3) + var(--api-f4)) * (var(--gap) + var(--row)) + var(--api-f5) * var(--row));
}
/* The cover's place in the cart before the first call: a card's outline and, in the accent's tint, a ring's
   place (a square with the bars' own corners: the gate reads a disc there as a pill set off centre in a field),
   two lines and a price (the Online picture's placeholder bars are in that tint, for the reason
   online-play.css gives). One drawing for the scene and for the page: lengths are the picture's design pixels,
   --sr and --sx where the ring and the words start, from the card's left side, the same at both sizes. */
.api__slot { --sr: 10; --sx: 36; position: absolute; box-sizing: border-box; border: calc(1 * var(--u, 1px)) solid #e9e5ef; border-radius: calc(10 * var(--u, 1px)); background: #fff; }
.api__slot > i { position: absolute; height: calc(8 * var(--u, 1px)); border-radius: calc(4 * var(--u, 1px)); background: #f1edfd; }
.api__slot > i:nth-child(1) { left: calc(var(--sr) * var(--u, 1px)); top: calc(18 * var(--u, 1px)); width: calc(16 * var(--u, 1px)); height: calc(16 * var(--u, 1px)); border-radius: calc(5 * var(--u, 1px)); }
.api__slot > i:nth-child(2) { left: calc(var(--sx) * var(--u, 1px)); top: calc(12 * var(--u, 1px)); width: calc(72 * var(--u, 1px)); }
.api__slot > i:nth-child(3) { left: calc(var(--sx) * var(--u, 1px)); top: calc(31 * var(--u, 1px)); width: calc(96 * var(--u, 1px)); }
.api__slot > i:nth-child(4) { right: calc(10 * var(--u, 1px)); top: calc(21 * var(--u, 1px)); width: calc(84 * var(--u, 1px)); }
.api__glint {
  -webkit-mask: linear-gradient(90deg, #0000, #000 50%, #0000) 160% 0 / 55% 100% no-repeat;
  mask: linear-gradient(90deg, #0000, #000 50%, #0000) 160% 0 / 55% 100% no-repeat;
}

@media (prefers-reduced-motion: no-preference) {
  .api:is([data-play='ready'], [data-play='on']) {
    animation:
      api-clock var(--api-end) linear both,
      api-type var(--api-type-for) linear var(--api-type-at) both,
      api-empty 1ms linear var(--api-send) forwards,
      api-sent .15s linear var(--api-send) both,
      api-work calc(var(--api-done) - var(--api-up)) linear var(--api-up),
      api-secs calc(var(--api-t5) - var(--api-t1)) steps(7, jump-end) var(--api-t1) both,
      api-f1 1ms linear var(--api-t1) both,
      api-f2 1ms linear calc(var(--api-t1) + var(--api-step)) both,
      api-f3 1ms linear var(--api-t5) both,
      api-f4 1ms linear var(--api-t6) both,
      api-f5 1ms linear calc(var(--api-t6) + var(--api-line)) both;
  }
  /* A line fades in where it is written */
  .api:is([data-play='ready'], [data-play='on']) :is(.api__band, .api__call, .api__req, .api__head, .api__say) {
    opacity: var(--api-in);
    animation: api-in .28s ease-out var(--at) both;
  }
  /* The time it took takes the place of Claude's word in one frame, as a terminal rewrites a line: its mark stays
     where it was and only changes colour. (A first version crossed the two through a blur, and for a tenth of a
     second the line read as neither.) */
  .api:is([data-play='ready'], [data-play='on']) .api__done { opacity: var(--api-in); animation: api-in 1ms linear var(--at) both; }
  /* The cart, one card that stays where it is. The offer comes into its place, over the bars that held it. It
     is bought there: it gives 2% and comes back, a press (0.26s), its second line gives way while it is down
     (two lines of words never cross), and the card as the order is laid over the card as the offer, whose edge,
     ground and ring change colour as it comes. In the scene the second line is the offer's own words, which go;
     on the page it is a patch of the card's white, which comes over them. */
  .api:is([data-play='ready'], [data-play='on']) .api__offer { opacity: calc(var(--api-in) * (1 - var(--api-gone))); scale: calc(1 - .02 * var(--api-press)); animation: api-in .4s ease-out var(--at) both, api-press .26s ease-out var(--api-buy) both, api-gone .2s linear calc(var(--api-buy) + .7s) both; }
  .api:is([data-play='ready'], [data-play='on']) .api__slot { opacity: calc(1 - var(--api-gone)); animation: api-gone .2s linear calc(var(--api-t1) + var(--api-lag) + .45s) both; }
  .api:is([data-play='ready'], [data-play='on']) .api__sold { opacity: var(--api-in); animation: api-in .3s ease-out var(--at) both; }
  .api:is([data-play='ready'], [data-play='on']) .api__hint { opacity: calc(1 - var(--api-in)); animation: api-out .1s linear var(--at) both; }
  .api--page:is([data-play='ready'], [data-play='on']) .api__hint { opacity: var(--api-in); }
  /* The caret blinks while nothing is typed, and holds while the keys go */
  .api:is([data-play='ready'], [data-play='on']) .api__caret {
    opacity: var(--api-caret);
    animation: api-blink 1.06s step-end infinite, api-solid calc(var(--api-type-for) + .5s) linear var(--api-type-at);
  }
  .api:is([data-play='ready'], [data-play='on']) .api__glint { animation: api-glint 1.5s linear infinite; }
  .api:is([data-play='ready'], [data-play='on']) .api__spark { animation: api-spark 1s ease-in-out infinite; }
  /* The first frame, held until the picture is looked at. The rules above set `animation` whole,
     which would start each piece again: this one has to win over them. */
  .api[data-play='ready'], .api[data-play='ready'] * { animation-play-state: paused !important; }
}

/* ---- The page ----
   The homepage shows the filmed poster (product-ui/renders/h-api-<language>-<size>.webp, and
   its 3x). api-play.js lays this layer over it: the terminal's opening session over the full
   one, and over that sheet the poster again, cut into the lines named above. Each cut shows its
   own part of the poster, in register, so at rest the layer and the poster are one picture; the
   cuts are what the play brings in. In the cart, the card as the order is cut from the
   poster the same way; the card as the offer is cut from the second picture, which holds it
   in register; and the card's place before the first call is drawn here, as the scene draws it.
   Some things are in the play and not in the poster: the session's two opening lines, the
   sentence in the prompt, Claude's mark and word, their light, and the figures of the seconds.
   They are a second picture, the poster's size: the terminal as a session opens, those things
   in it, and plain ink round it (renders/h-api-parts-<language>-<size>.webp, made by
   product-ui/export-api.py), cut the same way. It is also what covers the poster's session
   until each line is written.

   The picture's own numbers, in its design pixels (640 x 600 wide, 358 x 496 compact), the same
   in every language, since the session is laid out alike in all seven:
     --lx --ly --lw --lh   the session's box, under the terminal's bar and over its prompt
     --rw --gp --bd --c --pd   a row, the air between groups, the band, a cell, the text's inset
     --iy --ih             the prompt's band
     --dg                  where the figures of the seconds start in the second picture
     --rh                  how much of the terminal the picture shows, from its top
     --ox --oy --ow --oh   the cover's card, in the cart, and 4 of the page's white round it
     --hx --hy --hw --hh   the offer's second line in that card, the cover's name: from just left of its
                           first letter to short of the price, in every language
                           (the card's place before the first call is drawn in that box less its 4 of white)
   export-api.py reads them from here to cut the second picture, and
   product-ui/scripts/api-cuts.mjs proves all of it against the poster and against the scene:
   run it after any change to the picture or to a number. */
[data-api-play] { position: relative; }
.api--page { position: absolute; inset: 0; container: api / size; pointer-events: none; }
/* Shown once the two pictures it is cut from have arrived, and never where it cannot be placed */
.api--page:not([data-play]) { display: none; }
.api--page {
  --stage: 640; --lx: 200; --ly: 264; --lw: 400; --lh: 220; --rw: 20; --gp: 10; --bd: 30; --c: 7.2; --pd: 20; --iy: 491; --ih: 34; --dg: 36; --rh: 334; --ox: 50; --oy: 156; --ow: 400; --oh: 60; --hx: 86; --hy: 187; --hw: 236; --hh: 18;
  --u: calc(100cqw / var(--stage));
  --row: calc(var(--rw) * var(--u)); --gap: calc(var(--gp) * var(--u)); --band: calc(var(--bd) * var(--u)); --ch: calc(var(--c) * var(--u)); --pad: calc(var(--pd) * var(--u));
  /* Where the text starts (after the two cells of a mark), and the rows the second picture keeps its pieces on:
     where the result and its lines will be written */
  --tx: calc(var(--lx) + var(--pd) + 2 * var(--c));
  --pa: calc(var(--ly) + var(--bd) + 2 * var(--gp) + 3 * var(--rw)); --pb: calc(var(--pa) + 2 * var(--rw)); --pn: calc(var(--pa) + 4 * var(--rw));
}
.api--page[data-size='compact'] { --stage: 358; --lx: 16; --ly: 227; --lw: 326; --lh: 209; --rw: 19; --gp: 10; --bd: 28; --c: 6.9; --pd: 16; --iy: 443; --ih: 34; --dg: 30; --rh: 307; --ox: 22; --oy: 116; --ow: 314; --oh: 60; --hx: 58; --hy: 147; --hw: 168; --hh: 18; }
/* The cells the sentence takes, in each language (the scene counts them; api-cuts.mjs holds these to it) */
.api--page { --api-chars: 30; }
.api--page[data-lang='fr'] { --api-chars: 39; }
.api--page[data-lang='de'] { --api-chars: 35; }
.api--page[data-lang='it'] { --api-chars: 38; }
.api--page[data-lang='es'] { --api-chars: 39; }
.api--page[data-lang='nl'] { --api-chars: 38; }
.api--page[data-lang='pl'] { --api-chars: 36; }

/* What has to be in the window before the play starts: the terminal, as much of it as the picture shows */
.api--page .api__room { position: absolute; left: calc(var(--lx) * var(--u)); top: calc((var(--ly) - 38) * var(--u)); width: calc(var(--lw) * var(--u)); height: calc(var(--rh) * var(--u)); }
/* The session: the box its lines are placed in */
.api--page .api__log { position: absolute; left: calc(var(--lx) * var(--u)); top: calc(var(--ly) * var(--u)); width: calc(var(--lw) * var(--u)); height: calc(var(--lh) * var(--u)); }
/* The opening session over the poster's full one: the second picture again, in register, which holds the terminal
   with nothing written in it but its two opening lines, its two side hairlines and its rules included. So wherever
   the browser sets this sheet's edges, to the pixel above or below, what shows there is what the poster shows: at
   a scale that is not whole, a sheet of plain ink can leave a line of the sentence's band beside it. Two patches of
   plain ink lie on it, each with all its edges in ink: one over the opening lines once the sentence is sent, one
   over the rows where that picture keeps its own pieces. */
.api--page .api__cover { position: absolute; inset: 0; overflow: hidden; }
.api--page .api__cover > b { position: absolute; left: calc(var(--lx) * var(--u) * -1); top: calc(var(--ly) * var(--u) * -1); width: 100cqw; height: 100cqh; background: var(--api-parts) 0 0 / 100% 100% no-repeat; }
.api--page :is(.api__hush, .api__patch) { position: absolute; left: calc(4 * var(--u)); right: calc(4 * var(--u)); background: #1c1531; }
.api--page .api__hush { top: calc(2 * var(--u)); height: calc((2 * var(--rw) + 10) * var(--u)); opacity: var(--api-sent); }
.api--page .api__patch { top: calc((var(--bd) + 2 * var(--gp) + 3 * var(--rw) - 3) * var(--u)); height: calc((5 * var(--rw) + 6) * var(--u)); }
/* A cut is a window onto a picture. The picture inside it is the poster's own size and stands
   exactly where the poster stands, so the browser sets it on the same pixels (claim-play.css
   says why). A line is a row of the session, as wide as the terminal: --y is its top in the
   session, in design pixels. */
.api--page .api__cut { position: absolute; left: 0; top: calc(var(--y) * var(--u)); width: 100%; height: var(--row); overflow: hidden; }
.api--page .api__cut > b { position: absolute; left: calc(var(--lx) * var(--u) * -1); top: calc((var(--ly) + var(--y)) * var(--u) * -1); width: 100cqw; height: 100cqh; background: var(--api-poster) 0 0 / 100% 100% no-repeat; }
/* The band's window reaches into the ink above and under it, so that its own edges are never the band's */
.api--page .api__band { --y: -3; height: calc(var(--band) + 6 * var(--u)); }
.api--page .api__call { --y: calc(var(--bd) + var(--gp)); }
.api--page .api__req { --y: calc(var(--bd) + var(--gp) + (1 + var(--n)) * var(--rw)); }
.api--page .api__head { --y: calc(var(--bd) + 2 * var(--gp) + 3 * var(--rw)); }
.api--page .api__say { --y: calc(var(--bd) + 3 * var(--gp) + (4 + var(--n)) * var(--rw)); }
.api--page .api__done { --y: calc(var(--bd) + 4 * var(--gp) + 6 * var(--rw)); }
/* A piece of the second picture: a window (--l, --w in the box that holds it) onto the place it has there
   (--px, --py). Claude's mark and word stand in the window at the cells they have in that picture, a whole
   number of rows higher or lower, so the picture inside is still set on its own pixels. */
.api--page .api__part { position: absolute; left: calc(var(--l) * var(--u)); top: 0; width: calc(var(--w) * var(--u)); height: 100%; overflow: hidden; }
.api--page .api__part > b { position: absolute; left: calc(var(--px) * var(--u) * -1); top: calc(var(--py) * var(--u) * -1); width: 100cqw; height: 100cqh; background: var(--api-parts) 0 0 / 100% 100% no-repeat; }
/* The seconds: the cell after "Calling Evy API · ", over the poster's own figure. In the second
   picture the figures stand 10 apart, the first --dg from the terminal's left side, each on a whole pixel as the
   cell is (it is the line's twentieth: keep it on a whole pixel if the line's words change, or the figure the page
   shows sits a fraction of a pixel beside the poster's). They are a strip no wider than the eight of them, which the count brings past the cell one figure at a
   time (the whole picture, moved the same way, reached past the page's right side). */
.api--page .api__secs { --l: calc(var(--pd) + 20 * var(--c)); --w: var(--c); --px: calc(var(--lx) + var(--dg)); --py: var(--pn); }
.api--page .api__secs > b { left: 0; top: 0; width: calc(90 * var(--u)); height: 100%; background-position: calc(var(--px) * var(--u) * -1) calc(var(--py) * var(--u) * -1); background-size: 100cqw 100cqh; translate: calc(var(--api-n) * 10 * var(--u) * -1) 0; }
/* Claude's mark and word, and the word's light: a row that stands under the last line written */
.api--page .api__spin { height: var(--row); }
.api--page .api__spark { --l: var(--pd); --w: calc(2 * var(--c)); --px: calc(var(--lx) + var(--pd)); --py: var(--pa); }
.api--page .api__verb { --l: calc(var(--pd) + 2 * var(--c)); --w: calc(12 * var(--c)); --px: var(--tx); --py: var(--pa); }
.api--page .api__glint { --py: var(--pb); }
/* The prompt. The band's own colour over the poster's caret; the sentence, in register in the
   second picture, as wide as its cells; and the caret, drawn here. */
.api--page .api__blank { position: absolute; left: calc((var(--tx) - 2) * var(--u)); top: calc((var(--iy) + 2) * var(--u)); width: calc(4 * var(--c) * var(--u)); height: calc((var(--ih) - 4) * var(--u)); background: #2e2649; }
.api--page .api__typed { position: absolute; left: calc(var(--tx) * var(--u)); top: calc(var(--iy) * var(--u)); width: calc(var(--api-chars) * var(--ch)); height: calc(var(--ih) * var(--u)); overflow: hidden; }
.api--page .api__typed > b { position: absolute; left: calc(var(--tx) * var(--u) * -1); top: calc(var(--iy) * var(--u) * -1); width: 100cqw; height: 100cqh; background: var(--api-parts) 0 0 / 100% 100% no-repeat; }
.api--page .api__caret { position: absolute; left: calc(var(--tx) * var(--u) + var(--api-chars) * var(--ch)); top: calc((var(--iy) + 9) * var(--u)); width: var(--ch); height: calc(15 * var(--u)); background: #f4997d; }
/* The cart. The page's white over the poster's card, which is the order; on it, the card's place before the first
   call, drawn as the scene draws it; then the card as the offer, cut from the second picture; a patch of the
   card's white over the offer's second line; and the card as the order, cut from the poster. The white and the
   two cuts have one box, the card's and 4 round it, whose edges all fall in the page's white, clear of the
   product's picture above and of the terminal under it; the patch's edges all fall in the card's white. */
.api--page :is(.api__bare, .api__offer, .api__sold) { position: absolute; left: calc(var(--ox) * var(--u)); top: calc(var(--oy) * var(--u)); width: calc(var(--ow) * var(--u)); height: calc(var(--oh) * var(--u)); }
.api--page .api__bare { background: #fff; }
.api--page .api__slot { left: calc((var(--ox) + 4) * var(--u)); top: calc((var(--oy) + 4) * var(--u)); width: calc((var(--ow) - 8) * var(--u)); height: calc((var(--oh) - 8) * var(--u)); }
.api--page :is(.api__offer, .api__sold) { overflow: hidden; }
.api--page :is(.api__offer, .api__sold) > b { left: calc(var(--ox) * var(--u) * -1); top: calc(var(--oy) * var(--u) * -1); }
.api--page .api__offer > b { background: var(--api-parts) 0 0 / 100% 100% no-repeat; }
.api--page .api__hint { position: absolute; left: calc(var(--hx) * var(--u)); top: calc(var(--hy) * var(--u)); width: calc(var(--hw) * var(--u)); height: calc(var(--hh) * var(--u)); background: #fff; opacity: 0; }
