[renovate]

This PR contains the following updates:

Package	Change	Age	Confidence
@takumi-rs/core (source)	1.8.5 → 2.18.1

---

Release Notes

kane50613/takumi (@​takumi-rs/core)

v2.18.0

Draw an outline that sets only outline-style

An element with outline-style: solid and no outline-width now draws a medium (3px) outline, as browsers do. It used to draw no outline unless another outline longhand, such as outline-color, was also set.

Apply the dimension limit to each GIF frame

A GIF frame wider or taller than 8192 pixels now fails to decode, as a GIF whose canvas is that large already does.

Copy font and image bytes before a worker thread reads them

registerFont, render, renderSvg, measure, and renderAnimation now copy the Buffer, Uint8Array, or ArrayBuffer they are given before work moves to a worker thread. Rewriting or transferring those bytes while the call runs no longer corrupts its result or reads freed memory.

v2.17.1

Skip an SVG too large to rasterize instead of failing the render

An SVG image or background that would rasterize past the pixel budget, such as background-size: cover on an SVG with an extreme viewBox, is now left undrawn. The whole render used to fail with InvalidPixmapSize.

Clip a repeated background to its box

A repeated background-image whose tiles do not divide the box evenly, such as 15px tiles in a 96px box, now stops at the box's edge. Its last row and column of tiles used to paint past it.

Scale images up faster

A magnified image lerped every source row across the destination width again for each destination row that read it. Each source row is now lerped once and reused, so drawing a small image across a large box takes about 40% less time. The output is unchanged.

Blur what lies past the canvas edge

Since 2.15.0, an element with a pixel-moving filter such as blur() that reached past the canvas's top or left edge lost that part before filtering, so its blur faded toward the edge. The filter layer now takes in what the filter reads past the canvas, as Chrome's compositor does.

v2.17.0

Bound render fonts with fontCacheMaxBytes

Past this cap in decoded font bytes, a renderer releases the least recently used fonts that renders' fonts lists loaded, and a later render loads them again. Fonts from registerFont stay, and a running render keeps the fonts it started with. The wasm Renderer now passes its options, such as cacheMaxBytes, to the native renderer.

Release fonts a renderer no longer needs

unregisterFont({ name }) removes a family with all its unicodeRange subsets, and clearFonts() goes back to the bundled fallback font. A later render that lists a released font registers it again. In Rust, use Fonts::unregister_family.

v2.16.0

Register font subsets with unicodeRange

A font now takes unicodeRange, the codepoint ranges its @font-face declares. It serves only those codepoints, as in Chrome, so each subset of a family registers under the same name:

const fonts = [
  { name: "Inter", data: latin, unicodeRange: [[0x0000, 0x00ff]] },
  { name: "Inter", data: cyrillic, unicodeRange: [[0x0400, 0x045f]] },
];

googleFonts returns its subsets this way. subsetOf and subsetRank are deprecated: subsetOf now only sets the family name, and subsetRank does nothing. In Rust, use FontResource::unicode_range.

v2.15.2

Read node trees off the main thread

render, renderSvg, and measure pass a node tree to the native renderer as JSON when it holds only plain values. The renderer parses it on a worker thread, so a 48-card dashboard blocks the event loop for 0.1 ms instead of 0.7 ms and renders about 10% faster. Trees holding bytes or other values JSON cannot keep are read as before.

v2.13.7

Export the CssInput type from @​takumi-rs/core

The css option referenced CssInput without importing it, so type checking failed on the declaration file when skipLibCheck was off.

v2.13.2

Stop an oversized node from crashing the render

A node far larger than the viewport wrapped its buffer size past u32 and crashed the render. A clip path now rasterizes only the part that reaches the canvas, an oversized shadow is dropped, and a mask too large to rasterize hides its node instead of leaving it unmasked.

v2.13.1

Encode only the changed region of each animated WebP frame

Animated WebP frames after the first now carry just the rectangle that changed since the previous frame, stored with the no-blend flag so it replaces the canvas. Animations with a small moving region over a static background come out much smaller and encode faster. Frames that change everywhere are unaffected, and dispose: true keeps full-canvas frames.

Read premultiplied pixels as straight colour in filter

A colour filter ran on the canvas's premultiplied pixels as if they held straight colour, so it only landed on the right value where the element was fully opaque. Antialiased edges came out washed out, and opacity() left the colour unscaled, so a faded layer went pale instead of translucent.

v2.13.0

Resolve tw utilities through CSS variables

Utilities now read the CSS variables Tailwind compiles them to, falling back to the built-in value. Define tokens in :root. --color-brand-500 makes bg-brand-500 work, and spacing, fonts, shadows, animations and breakpoints follow the same rule.

Gradients now match Tailwind on two counts. Stops alone no longer paint without bg-linear-*, bg-radial or bg-conic, and a missing to stop fades to transparent.

Let stylesheet rules win over tw utilities

Utilities now sit in the last cascade layer, below unlayered CSS and above rules in a named @layer. Important reverses that order. An important utility beats unlayered important CSS but loses to one in a named layer. Inline important declarations stay on top. A template that relied on tw beating a matching rule needs a fix. Move that rule into a layer, or mark the utility !.

Honor !important in inline styles

An inline !important declaration now outranks important rules and animations. Both the style object and an HTML style attribute read the marker.

Inherit text-fit from a parent

text-fit now inherits. Descendant text uses the inherited value to calculate its scale.

Parse @theme blocks as :root rules

A Tailwind v4 source stylesheet now works in css without compiling it first. @theme declarations land on :root, and @keyframes inside the block register. Modifiers like reference read the same way. The prefix() modifier is not supported.

Wrap box-sizing: content-box text inside its padding

A box with box-sizing: content-box and horizontal padding wrapped its text
against the border box, so the text took fewer lines than it needed and
overflowed the bottom of the box.

Cut allocations in style property parsing

Parsing a string-valued property copied the value before handing it to cssparser. Normalizing a kebab-case or camelCase property name allocated a second string just to trim leading underscores. String values now parse in place, and names normalize in one allocation.

Compose filters and transforms through custom properties

Filter, translate, scale and grid-line utilities now compose through --tw-* variables like Tailwind's compiled CSS. Stacked filters follow Tailwind's fixed chain order instead of class order.

Size auto table columns by their content

An all-auto table shared its free space evenly, so a one-word column took as
much room as a paragraph. Each column now grows in proportion to its
max-content width, the way Blink distributes it, and never below the widest
word it has to hold. A table narrower than its content still approximates.

Escape control characters in serialized CSS strings

A quoted string containing a newline left it unescaped. This produced invalid CSS. CSS strings now use cssparser's escaping.

Write a css entry as an object

A css entry can be a rule, { selector, style, rules }, or an animation, { keyframes, steps }. Takumi checks the selector and every value before the entry reaches the parser, so a token that comes from application data cannot escape the rule it was written for. The keyframes option is deprecated and goes away in v3.

Turn on Preflight through @import "tailwindcss"

The import line at the top of a Tailwind v4 stylesheet now works. Preflight replaces the UA preset. Margins and padding go, lists lose their markers, and h1 through h6 drop their font sizing. It also brings the universal border reset, link and table resets, block-level images, and hidden on any element. Author rules outrank Preflight, apart from hidden, which it marks important. Other @import targets stay unsupported.

Support the disclosure-open and disclosure-closed counter styles

list-style-type now accepts disclosure-open and disclosure-closed, drawing the triangles CSS Counter Styles defines. disclosure-closed points the way the text runs, so it flips under direction: rtl. Font subsetting covers all three characters.

Report text runs for a node that holds text directly

measure returned no text runs for <div>word</div>, the shape an HTML parse
produces most often, while <div><span>word</span></div> reported them. The
render was correct either way; only the measurement was missing its geometry.

Support legacy WebKit box alignment properties

Map -webkit-box-orient to flex-direction, -webkit-box-pack to justify-content, and -webkit-box-align to align-items.

Stop a box narrower than its padding from panicking

A box whose horizontal padding exceeds its own width left the text a negative
width to lay out in, which tripped an assertion inside the text layouter and
crashed the render. The width the text lays out against now stops at zero.

Write a group of css entries as an object

A css entry can be { media, rules }, { supports, rules }, or { layer, rules }. A layer without rules declares its order alone. Takumi reads each prelude with the grammar its rule takes, so it cannot close the rule and open another.

Expand @apply inside stylesheet rules

.card { @apply mt-4 bg-brand-500; } now expands through the tw parser where it is written, ! suffix included. Variants like md: are rejected. A static render has nothing for them to gate on.

Rename the stylesheets render option to css

css takes inline CSS as one string or a list. The old stylesheets name still works everywhere and warns once on takumi-js and takumi-pdf.

Support legacy WebKit display values

Map -webkit-box and -webkit-flex to flex, and -webkit-inline-box and -webkit-inline-flex to inline-flex.

Render <text> elements in SVG image sources

SVG images with <text>, <tspan> and textPath now draw their text using
the registered fonts instead of dropping it. Glyphs render from font outlines;
color emoji glyphs inside SVG text are not supported.

Accept CSS-wide keywords on shorthand properties

margin: inherit, padding: initial and border: unset were rejected. Only longhands took CSS-wide keywords. A shorthand now expands the keyword across the longhands it targets.

Reject trailing content in style values

A style object accepted width: "55px zzz", applied 55px, and ignored the rest. It now rejects the whole value, the way a stylesheet already drops such a declaration. A substituted var() value follows the same rule.

Take an inline-block's baseline from the lines it actually laid out

An inline-block with horizontal padding re-wrapped its content against the
border box to find its baseline, so text beside it aligned with the wrong line.

v2.12.0

Support the legacy page-break-* properties

Print stylesheets written for page-break-before, page-break-after, and page-break-inside had those declarations dropped. They now drive the same pagination as break-before, break-after, and break-inside, and the forced-break keywords always, left, and right are accepted alongside page.

Support table-layout: fixed and border-spacing

border-spacing was a hardcoded 2px gap with no way to change it, and table-layout did nothing. Column widths now come from the first row under table-layout: fixed and the rest of the width is shared evenly, while border-spacing sets both the gap between cells and the inset from the table's own edges. On a three-column table measured against headless Chrome, auto columns land 67px to 136px away and fixed columns land within 2px.

border-spacing starts at 0 as CSS defines it, and the HTML and JSX element presets give <table> the 2px browsers apply, so a display: table box no longer gets a gap it never asked for.

Support border-collapse: collapse

Neighbouring cells each painted their own border either side of the border-spacing gap. A collapsing table now resolves every shared line once: the wider border wins, hidden clears the line, and a row's borders reach its cells the way its background already did.

v2.11.0

Align table cell content with vertical-align

vertical-align: middle on a table cell now centers its content in the cell, and bottom pushes it to the cell's bottom edge. baseline still renders as top.

A row's element children that are not table-cell, such as a <td style="display: flex">, are now laid out in the row instead of dropped. Text sitting directly in a row is still dropped: it has no anonymous cell to go into.

Start backwards-filled step animations on the first step

An animation with animation-fill-mode: backwards or both and a positive delay held the second step during the delay when its timing function was steps(n, jump-start) or steps(n, jump-both). Samples taken before the active phase now land on the step below the jump, as the CSS easing algorithm requires.

steps() also serializes the way the spec asks: steps(4, end) and steps(4, jump-end) both print as steps(4), since an end position is the default.

Store calc() as its non-zero terms

Length shrinks from 84 to 20 bytes, and a computed style from 5.9KB to 2.3KB. A calc() expression mixing more than four distinct units now fails to parse.

Sample background-clip text at pixel centres

Text clipped to a background or mask image sampled that image at pixel corners rather than centres, blending every pixel with its neighbour. The clip is now read exactly where it should be, so a background-clip: text fill is half a pixel sharper, and drawing one is about a third faster.

Animate WebP image sources

An animated WebP used as an image source now plays through its frames, the same way an animated GIF does. Before, decoding one threw WebP encode failed and took the whole render down with it. The still-image paths, which the SVG backend and the size cache go through, fall back to the first frame instead of failing.

ImageSource::Gif is now ImageSource::Animated, and GifSource is now AnimatedSource, since both carry GIF and WebP animations. ImageError::InvalidGif is now ImageError::InvalidAnimation for the same reason.

An animated source keeps only its encoded bytes and a frame timing table. It used to hold a decoded full-size copy of the first frame as well, which also meant the first frame ignored the draw box it was scaled into.

Reuse layout styles across sizing passes

Layout runs several sizing passes over each node, and each pass rebuilt that node's layout style from scratch. Only container query units (cqw, cqh, cqmin, cqmax) can change between passes, so a style using none of them is now built once and reused. A deeply nested flex tree lays out about 36% faster.

Support the full steps() step position syntax

steps() now accepts jump-start, jump-end, jump-none, and jump-both, and the position argument is optional, so steps(4) means steps(4, jump-end). Only start and end parsed before, so a declaration like steps(4, jump-none) was dropped as invalid and the animation fell back to ease, drawing a smooth curve instead of a staircase.

Undo premultiplication in integers

Converting the finished canvas back to straight alpha now divides in integers rather than f64. Rendering any image is a few percent faster, and pixels land on the same value on every target instead of depending on the platform's float division. Semi-transparent pixels can differ by one from previous output, which is where the float landed a hair under a rounding step.

Share inherited font lists across nodes

font-family, font-variation-settings, and font-feature-settings lists are now Arc-shared, so inheriting them no longer copies the list per node.

Keep direction: ltr blocks left-to-right

Blocks with direction: ltr now keep an LTR layout when text starts with an RTL script. The bidi base direction follows direction, matching browsers.

Composite opaque effect layers without resampling them

A blur, shadow or opacity group that is fully opaque and composites normally is copied onto its parent row by row instead of going through the sampling pipeline. Such a drop shadow is about 40% faster to render, such a blur about 30%. A group with partial opacity or a blend mode is unaffected.

Keep degenerate CSS values out of layout

aspect-ratio with a zero, negative, or non-finite ratio (such as 1/0) now behaves as auto, and an infinite percentage length is clamped instead of feeding infinity into layout.

Draw animated frames without replaying the ones before them

A frame that covers the whole canvas and replaces what is under it does not depend on the frames before it, so it is now decoded on its own. Reaching the last frame of a 300-frame animation drops from 16.6ms to 0.13ms for GIF, 158ms to 0.39ms for APNG, and 97ms to 0.05ms for WebP. Frames that do blend onto their predecessors still replay, as they must.

Render list markers on the right under direction: rtl

A direction: rtl list item now places its marker at the right edge and mirrors the counter suffix, matching Chrome. RTL blocks also force the right-to-left base direction instead of inferring it from the first strong character, so their text aligns to the right regardless of content.

Draw whole-pixel images without resampling them

An image placed at a whole-pixel offset is copied row by row instead of going through the sampling pipeline. Drawing one into a node is about three times faster; clips, shadows and blurs that composite an image get a few percent.

Share custom property maps across nodes

ComputedStyle::custom_properties and registered_custom_properties are now Arc-shared, so inheriting them no longer copies the maps per node.

Animate APNG image sources

An animated PNG used as an image source now plays through its frames, the same way an animated GIF or WebP does. Before, only the default image was decoded and the render held that one frame for the whole animation, with nothing to signal the rest had been dropped. Subframes composite through the fcTL dispose and blend operations, and a default image that no fcTL claims stays out of the timeline.

Match selectors against the rules that could apply

Stylesheet rules are grouped by what their rightmost selector requires, so a node only runs the matcher against rules naming one of its classes, its id or its tag. Rendering 800 nodes against 800 rules drops from 67ms to 2.5ms; the cost now grows with the rules that could match rather than with the whole stylesheet.

v2.10.0

Update the font stack

parley 0.11.1, skrifa 0.44, and write-fonts 0.50, with the hinting-gate fork rebased so a single fontations version serves layout and subsetting.

Lay out tables on the grid algorithm

A <table> used to fall back to block layout, so cells stacked instead of forming columns. Table boxes now lower onto a grid whose column tracks are shared by every row. Header groups render first, footer groups last. colspan and rowspan span tracks, captions render on the side caption-side picks, and a row's background lands on its cells. HTML and JSX gain element presets for table, thead, tbody, tfoot, tr, td, th, and caption.

Count the pages a repeated box prints on

A page counter filled only inside a header or footer band. A footer written into the document itself, as a fixed box, printed empty hooks, so the numbers had to come from a render option standing beside the document. A repeated box now lays out again for every page it draws on, with that page's numbers, so a component can carry its own footer.

Match Blink's spacing between a bullet marker and its item

An outside bullet keeps Blink's fixed 7px gap on top of its suffix space, an inside bullet separates with 1em, and the square style draws ▪, approximating Blink's painted size.

Drop reversed, gradient marker images, and menu/dir list counting

An <ol reversed> now counts up, a gradient list-style-image falls back to the counter style, and only ul/ol scope a list's count.

v2.9.2

Treat the synthetic HTML root as a block container

Markup written in a template literal carries whitespace either side, which parsed into text roots. The synthetic root that holds them was inline, so the leading one kept a line box and pushed the content down the page. It is a block container now, the way <body> is, and fromHtml drops the whitespace roots the way the Rust crate already did.

v2.9.1

Close the gap between two boxes on a fractional parent

A box's position snapped to the pixel grid against its parent while its size snapped against the page. A parent sitting on a fraction, such as a container padded in points, pushed the two apart and left a hairline of background between boxes that should meet.

v2.7.0

Restore JPEG, WebP and GIF decoding

takumi disables takumi-core's default features and never re-enables image decoding, so every build decoded PNG and ICO only. A WebP source failed with The image format could not be determined. image-decoding is now a takumi feature as well, on by default, and it splits into jpeg, webp and gif for a build that wants one format and not the others. The napi and wasm bindings turn it on too.

v2.6.0

Route shared codepoints to the subset that declares them

A Google Fonts subset encodes more than the unicode-range it was cut for, and the Cyrillic and Greek ones also carry the ASCII space and the Latin capitals. Selection took the first subset whose glyphs covered a character, in family-name order, so those codepoints left the Latin subset and every word split into separate runs. Subsets now rank by the range they declare, lowest first.

v2.5.5

Type render output as backed by ArrayBuffer

render and renderAnimation declared their output as Buffer / Uint8Array over ArrayBufferLike, so passing the bytes straight to new Response(...) failed to typecheck. They now declare Buffer<ArrayBuffer> / Uint8Array<ArrayBuffer>, which BodyInit accepts.

v2.5.0

Add setGlyphCacheMaxBytes

The resolved-glyph and glyph-mask caches share an 8 MiB budget that no binding exposed. cacheMaxBytes looks like the knob for it but covers a different set of caches: decoded images, SVG rasters, and parsed stylesheets.

setGlyphCacheMaxBytes sets the glyph budget. It is a module-level function rather than a Renderer option because those caches live in the module and are shared by every renderer, and the budget is read the first time a cache is used, so the call has to come before the first render.

The default suits Latin text. A CJK outline runs a few kilobytes, so 8 MiB holds on the order of a thousand of them and a page of Chinese re-rasterizes glyphs it evicted a moment earlier.

takumi-js forwards it too. That one records the budget and hands it to the backend as it loads, so it stays synchronous and cannot race the resolution.

v2.4.2

Stop copying Uint8Array font and image inputs on the native binding

Buffer inputs were already passed to render tasks as ref-counted views, but Uint8Array inputs went through a full to_vec copy first. Both now cross into the async tasks zero-copy; only bare ArrayBuffer inputs still copy.

v2.4.0

Unify decoded resources behind one budgeted cache

Decoded images had a byte budget, but each SVG kept up to 32 rasterized pixmaps outside it, and every render re-parsed its stylesheets from scratch. ImageCache is now ResourceCache: SVG sources, their rasterized pixmaps, and parsed stylesheets all weigh against the same budget as decoded images. The default budget drops from 64 MiB to 16 MiB and becomes configurable — new Renderer({ cacheMaxBytes }) in the bindings, ResourceCache::new(max_bytes) in Rust, with 0 disabling caching. SVG rasters and parsed stylesheets now also survive across renders, so a server re-rendering the same template stops re-rasterizing and re-parsing per request. Rust callers: RenderOptions.stylesheet is now Arc<StyleSheet>; pass sheet.into().

Return an error for viewports too large to allocate

A viewport whose pixel buffer overflowed the backing allocation used to fall back to a 1x1 canvas, so the render produced a valid-looking but wrong tiny image with no error. The root canvas is now built through a fallible path that surfaces the allocation failure as an InvalidViewport error instead. Internal offscreen canvases keep their bounded sizes and are unaffected.

Blend animated WebP frames by default on the native binding

AnimatedWebpOptions::builder() left blend and dispose unset, so they fell back to false while the type's Default and the wasm backend use blend: true. Native animated WebP now alpha-blends frames over prior content like wasm does, so animations with partially transparent later frames render the same on both backends. The builder defaults are pinned to the Default values.

Convert native panics into catchable errors instead of aborting the process

The published napi artifacts are now built with unwind panics, so a Rust panic reached through malformed input surfaces as a JS error rather than killing the host process. Wasm keeps abort panics by design.

v2.3.0

Accept raw RGBA pixels as an image source

An image node's src takes { width, height, data, premultiplied? } and renders the pixels without decoding; the Bitmap JSX helper wraps it as an <img>.

v2.2.0

Extend the built-in Geist to weight 300

The embedded last-resort font covers wght 300..800 and trims unused stylistic sets, ending up slightly smaller than before.

Claim generic font families from the JS font API

Font descriptors accept generic (e.g. "monospace"), so stacks like Tailwind's font-mono resolve to registered fonts without naming the family.

v2.0.2

Accept a promise in the fonts option

fonts now takes Promise<FontLoader[]> as well as the plain list, so
googleFonts results pass straight through without await.

Extend the embedded font weight axis to 800

The embedded last-resort Geist subset now covers weights 400 to 800.

v2.0.0

Make the embedded font a true last resort

Both bindings now embed one font: a Latin Geist subset with a 400 to 700
weight axis (Geist Mono and Manrope are gone). It no longer claims the
sans-serif generic family and always sorts after registered fonts in
fallback selection, so generic families and unstyled text resolve to the fonts
you load. The new FontResource::last_resort marks a font's families to sort
after every normal registration.

Cap animation frame rate per format

Browsers clamp any animation frame of 10ms or less to 100ms, so a high frame
rate stalls instead of playing fast. write_animation now rejects a frame rate
above AnimationFormat::max_fps with the new AnimationFrameRateTooHigh error:
90 fps for WebP and APNG, 50 fps for GIF (centisecond delays). The napi and WASM
renderAnimation bindings surface the error.

Apply structured keyframes in renderAnimation

renderAnimation accepted a keyframes option but never registered it, so
structured keyframes animated with render yet stayed static in animations. It
now extends the stylesheet with them like the other entry points.

Fix buffer pool bucket capacity invariant

Release now buckets a buffer by the floor power of two its capacity guarantees,
and acquire_dirty reserves before set_len. A pooled buffer can no longer be
lengthened past its allocation.

Skip mask copies and per-pixel mask lookups in canvas fast paths

Borrow the combined constraint mask directly when it already matches the
canvas viewport instead of copying it per draw, and hoist mask lookups out of
the per-pixel blit loops. Output is unchanged.

Make subset-group font selection deterministic

Subsets registered under one logical family (via FontResource::subset_of) were kept
in registration order. Callers commonly register fonts concurrently, so that order — and
therefore which subset won for a codepoint covered by more than one (e.g. overlapping
weight subsets, where the loser is faux-bolded) — varied per process. Identical input
could render to different bytes run to run.

Subsets are now held in a BTreeSet, ordered by their family name, so expansion and
selection no longer depend on registration timing. Same input renders identically.

Shrink the published binaries

Size-optimize the layout and shaping crates that never run per pixel, cutting
the published WASM and native binary size.

Share the renderer facade between the napi and wasm bindings

The napi and wasm Renderer wrappers now build on a shared prepareRenderInput
helper in @takumi-rs/helpers/renderer, so their option types and render bodies
live in one place. Both backends check signal before and after resolving
fonts and images: on native, an already-aborted signal now throws before any
resource fetch.

Fix gradient stop snapping panic for oversized stop lists

Gradients with more color stops than the LUT can hold no longer panic. The
sample-index clamp and normalization passes stay within LUT bounds.

Reuse per-scene state across animation frames

Compute each scene's font snapshot once and share its image and stylesheet
handles across frames instead of re-snapshotting and deep-cloning the whole
option tree per frame. Frame output is unchanged.

Remove encodeFrames

Renderer.encodeFrames and its EncodeFramesOptions / AnimationFrameSource
types are gone. renderAnimation covers scene-based animation; pre-rendered
frame encoding had no callers.

Replace fetchResources/extractResourceUrls with prepareImages

@takumi-rs/helpers exports prepareImages({ node, sources?, fetchCache?, fetch?, timeout? }),
which collects a node tree's remote images and fetches the ones not already supplied. Pass a
fetchCache (a Map<string, Promise<ArrayBuffer>>, or any Map-like store) to coalesce
concurrent fetches of the same URL and reuse the bytes across renders; a failed fetch is
evicted so a later call retries.

The extractResourceUrls and fetchResources helpers are removed. The images render option
takes the same group form: { sources, fetchCache, fetch, timeout }.

Stream animation frames straight into the encoder

Add write_animation, which renders a timeline and feeds each frame to the
encoder as it arrives, holding one raw frame at a time instead of the whole
sequence. Both the napi and WASM renderAnimation bindings use it, so a high
frame rate or a long duration no longer exhausts memory. On native the WebP
encoder still runs frames in parallel, now over bounded chunks. The WASM WebP
encoder now merges runs of identical frames like the native one, so a static or
slow animation encodes and stores far less. The eager render_animation +
write_animated_* path stays for callers that want every frame at once.

Guard shadow and blur buffer sizing against overflow

Extreme blur radii could overflow the u32 shadow-buffer area and panic or
over-allocate. Sizing now uses saturating math and skips shadows above a 256
Mi-pixel budget.

Type keyframe declarations with csstype instead of DOM's CSSStyleDeclaration

KeyframesMap and KeyframeRule typed each keyframe's declarations as
Record<string, CSSStyleDeclaration>, requiring every CSS property on a single
offset and needing the DOM lib. Declarations are now typed with csstype's
Properties, an optional peer dependency, so a single offset only needs the
properties it sets and consumers without the DOM lib still typecheck.

Accept a bare URL string in fonts

fonts entries can now be a URL string, e.g. fonts: ["https://example.com/Inter.woff2"].
The bytes are fetched on demand and keyed by the URL; family name, weight, and style come
from the font file. The object form stays for overriding those. Adds fontFromUrl to
@takumi-rs/helpers.

Cap image decode dimensions and GIF frame volume

Decoders reject images beyond 8192x8192 (via image::Limits for PNG and JPEG,
dimension checks for WebP) and GIFs beyond a total-frame pixel budget, stopping
decode-bomb OOM.

v1.8.7

Compare Source

Patch Changes

• 81c3678: Removed the seperate .d.ts file and updated tsdown to v0.22.3
• 9604fd7: Split package export types per import/require condition so CJS consumers resolve .d.cts
• Updated dependencies [9604fd7]
  • @​takumi-rs/helpers@1.8.7

v1.8.6

Compare Source

Patch Changes

• @​takumi-rs/helpers@1.8.6

---

Configuration

📅 Schedule: (UTC)

• Branch creation
  • "on the 2nd through 5th day of the month"
• Automerge
  • At any time (no schedule defined)

🚦 Automerge: Enabled.

♻ Rebasing: Whenever PR is behind base branch, or you tick the rebase/retry checkbox.

🔕 Ignore: Close this PR and you won't be reminded about this update again.

---

• If you want to rebase/retry this PR, check this box

---

This PR was generated by Mend Renovate. View the repository job log.

[netlify]

❌ Deploy Preview for nuxt-storybook failed. Why did it fail? →

Name	Link
🔨 Latest commit	eaee9cf
🔍 Latest deploy log	https://app.netlify.com/projects/nuxt-storybook/deploys/6adfb816970c5a6a040eecaf

[pkg-pr-new]

Open in StackBlitz

npm i https://pkg.pr.new/@nuxtjs/storybook@1087

npm i https://pkg.pr.new/@storybook-vue/nuxt@1087

commit: eaee9cf