Commit Graph
988 Commits
Author SHA1 Message Date
BFlat 56bc5fe7cb Merge pull request #8515 from dotCooCoo/perf/eps-token-search-in-place
EPS import: token and search read a string in place instead of copying it
2026-11-18 13:53:14 +07:00
BFlat e49686185e Merge pull request #8465 from dotCooCoo/feat/scatter-brush-hue-jitter
Brushes: Scatter Brush Options has Hue Jitter, a per-copy hue turn
2026-11-18 13:15:11 +07:00
BFlat 1dad5aeb75 Merge pull request #8472 from dotCooCoo/perf/ai-save-font-record-once
.ai save: resolve each run's font once per font
2026-11-18 13:04:34 +07:00
BFlat fb8e0ab455 Merge pull request #8454 from dotCooCoo/perf/ai-save-style-parse-once
.ai save: parse each art style text once per save
2026-11-18 13:04:25 +07:00
BFlat 01279f1d03 Merge pull request #8379 from dotCooCoo/perf/ai-texts-move-stories
PDF/.ai import: the text document reader moves its stories out instead of copying them
2026-11-18 12:56:39 +07:00
BFlat fbbd55458e Merge pull request #8355 from dotCooCoo/perf/ai-save-images-decode-once
.ai save: read each embedded image's pixels once a save
2026-11-18 12:56:04 +07:00
BFlat 4d3f9cbd08 Merge pull request #7365 from dotCooCoo/fix/ai-scatter-brush-art-upright
.ai import and save: Scatter brush art comes in turned over, as Art brush art does
2026-11-18 12:55:47 +07:00
BFlat 61d3190469 Merge pull request #8181 from dotCooCoo/feat/area-type-first-baseline-em-box
Type: Area Type Options First Baseline offers Em Box Height
2026-11-18 10:22:23 +07:00
dotCooCoo 46dd113eaa EPS import: token and search read a string in place instead of copying it
`token` on a string copied everything left in the string before scanning
one object, and `search` and `anchorsearch` copied both strings before
comparing them. A program that walks a string by what each call leaves
copied the rest of it on every call. All three now read the strings in
place and release the borrow before the scanned object is checked
against the budget and before the results are pushed. Results, errors
and the operations charged against the budget are the same as before.

Walking a 512 KiB string takes 16 ms instead of 518 ms with `token` and
1.0 ms instead of 27 ms with `search` (release build on Linux under load
from other builds, median of 7 alternating runs); on a 4 KiB string the
difference is under 0.1 ms.

Tests in tests_strings.rs compare each operator with the copying code on
the same operands (stack, error and operations left after every call),
check that the results see later writes to the string, and check that
no string is copied.
2026-11-17 18:47:53 -08:00
dotCooCoo ef366997ec .ai save: keep at most 4,096 parsed style texts per save
The writer kept every style text it checked, with its parse, until the
save ended, including texts the reader does not accept. A gradient style
placed on each object's outline is often a different text per object,
so memory grew with the number of objects checked.

The first 4,096 texts, up to 8 MiB of text, are kept parsed. Past that,
only the last text checked is kept, so the brush check that follows an
object's check reuses its parse, and other texts are parsed again when
checked. The written file is unchanged.
2026-11-17 14:51:14 -08:00
dotCooCoo dd810ea4bb .ai save: resolve each run's font once per font
Saving a .ai file resolves the font of every run of type twice: once
for its font record and once to check that the font comes back as
itself. Each resolution looks the face up, reads its axes and name
table, and scans the loaded faces by PostScript name, so a document
with tens of thousands of runs in a few fonts repeated the same
lookups for every run.

The text document now keeps what each style's font fields (family,
style, version and Variable Font settings, each setting by the bits of
its value) resolve to for the whole save, and reuses it while the font
database's generation is unchanged. A font added or loaded during the
save resolves it again. The font set is still searched and filled as
before, so its order, indices and rollback are unchanged. The output
is unchanged.

- Tests: a save resolves as many fonts for one row of type as for
  four; the program, header, warnings and private data are the same as
  with every run's font resolved again (many fonts, threaded type,
  envelopes of type, and type taken back when an envelope is written as
  its art); each resolved record and check equals the uncached one for
  static and variable fonts, settings outside the axis range, not a
  number, +0 and -0, and a missing family, and a value resolved before
  the font database changed is resolved again. An ignored test times
  the save of 10,000 point type objects in three runs over four fonts.
2026-11-17 14:30:14 -08:00
dotCooCoo a0228dd460 Brushes: Scatter Brush Options has Hue Jitter, a per-copy hue turn
A scatter brush takes a Hue Jitter amount from 0 to 180 degrees (0 by
default). Each copy turns the hue of its solid fills and strokes, type
included, by its own amount up to that far either way, after the
colorization. The amounts come from the stroke's path and the brush
name, so a stroke draws the same colors on every redraw, after Save and
Open, and in export. Copies keep their places, sizes and rotations.

A color turns in its own model (RGB in the HSB of its values, CMYK over
C, M and Y with K kept, Lab by turning a and b). White, black and grays
stay as they are, and a symbol instance in the art turns only its stain.
A brush at 0 draws its copies in the colors the colorization gives them
and saves no hue_jitter key; a brush without the key reads as 0.

- brush.options takes hue_jitter, and brush.get shows it for every
  scatter brush. Brush Options shows a Hue Jitter field (ui.brushOptions
  field hueJitter) with rows in every catalog.
- The .ai editing data writer does not write the amount, so a jittered
  brush is left out of the Brushes panel there and reported, as other
  brushes that would open with other settings are.

Docs: docs/mcp.md, docs/target-app-parity.md.
2026-11-17 14:24:19 -08:00
dotCooCoo 7142cca3e9 .ai save: parse each art style text once per save
Saving a .ai file checks every art style it writes by reading it back
with the reader's style parser. Each object check parsed its style text
twice (once to read the appearance and once for the outline check), a
brushed style a third time, and a linked object first searched every
written style by name and copied its text. With thousands of objects
on a few styles, the same text was parsed tens of thousands of times.

The writer now keeps each style text's parse for the whole save, a
text the reader does not parse included, and reads it on each object:
the object's own gradient, the outline check, the brush check and the
appearance comparison still run per object. The own gradient is applied
to a copy of the parse, and that copy is the compared appearance; the
outline and brush checks read the kept parse.
Panel styles are found by their place in the written list. The output
is unchanged.

- import: parse_art_style, read_parsed_style and parsed_moves_with
  split the parse from the reading; BrushesRead::style_reads takes the
  parse.
- Tests: the parse count of a save does not grow with the number of
  objects on the same styles; the program, header, warnings and private
  data are the same as with a parse at every check; one parse read on
  two objects gives each its own gradient. An ignored test times the
  save of 40 graphic styles, 20,000 linked rectangles and 5,000 paths
  with their own Outer Glow.
2026-11-17 13:52:24 -08:00
dotCooCoo 8c343ea357 Merge main into perf/ai-texts-move-stories 2026-11-17 13:30:45 -08:00
BFlat b458f8f757 Merge pull request #7254 from dotCooCoo/fix/ai-xa-working-rgb
.ai save: Lab colors and type paints are written in the working RGB space
2026-11-18 03:21:30 +07:00
BFlat aa8ef006da Merge pull request #7446 from dotCooCoo/fix/ai-transform-guide-reach
.ai import: guides past an object's art keep the drawn look under Transform and Free Distort
2026-11-18 03:20:32 +07:00
dotCooCoo 527d97bf7f Merge main into fix/ai-scatter-brush-art-upright 2026-11-17 12:20:28 -08:00
BFlat 3bdc7400a3 Merge pull request #8045 from dotCooCoo/fix/ai-legacy-perceptual-gradient
Legacy .ai: write Perceptual gradients with the stops on their curve
2026-11-18 03:19:43 +07:00
dotCooCoo f3fa4e0a17 PDF/.ai import: the text document reader moves its stories out instead of copying them
Texts::read copied the stories, the default styles, the paragraph
defaults and the frames out of the parsed text document and then
dropped the document. It now looks every required path up first,
reads the styles, Kinsoku sets and fonts from the whole document, and
then moves those four parts out. Every document that read before reads
to equal values, and every one that did not still does not.

Reading a synthetic editing copy with 2,000 point-type stories
(1.8 MB) takes a median of 60 ms of CPU time instead of 109 ms (7
alternating runs each, one process). The gain matters on documents
with a lot of type.
2026-11-17 10:26:17 -08:00
dotCooCoo 57601ec0a4 .ai import: pattern fills in brush art turn over with the art
A Scatter or Art brush's art is read turned over, and the tiles of its
pattern fills now turn over with it, so they keep their place on the
art. The version 7 pattern test reads a Scatter brush's tile moves in
the file's own space (y up), as the art now is.
2026-11-17 09:57:58 -08:00
dotCooCoo 6f12103147 .ai import: Scatter brush art turns over with its unlinked opacity masks
Scatter brush art is read turned over, as Art brush art is. The turn now
goes through the same helper as Art brushes, so the art of opacity masks
that don't move with their objects is turned over too and stays lined up
with the art. Fixes the "Unlinked spray" case of
scatter_and_art_brush_mask_art_round_trips.
2026-11-17 09:45:03 -08:00
dotCooCoo 2733c8c85c Merge main into fix/ai-scatter-brush-art-upright 2026-11-17 09:41:16 -08:00
dotCooCoo a36ab077f6 Merge main into perf/ai-save-images-decode-once 2026-11-17 09:09:11 -08:00
dotCooCoo b4cd6b6fa0 .ai save: read each embedded image's pixels once a save
The .ai writer kept only the image it read last, so a document that
placed two images in turn decoded each again at every placement. The
writer now keeps every image it reads during a save, by the address of
its data and its MIME type, up to 256 MiB of samples and 256 images,
with the image read last kept beside them when they are full. The file
written is unchanged; the tests compare the whole output and warnings
with the old one-image policy.

Two 2048 x 2048 images placed in turn 25 times each, release build,
thread CPU time, median of 7 alternating runs: 3774 ms with 50 decodes
before, 748 ms with 2 decodes after.
2026-11-17 09:03:45 -08:00
BFlat 271a28840c Merge pull request #8246 from dotCooCoo/feat/ai-editing-data-meshes
.ai save: the editing copy keeps gradient meshes
2026-11-17 21:32:35 +07:00
BFlat 0f8040ef59 Merge pull request #8202 from dotCooCoo/perf/legacy-ai-hex-samples
Legacy .ai: image samples are written as hex through a digit table
2026-11-17 19:51:37 +07:00
dotCooCoo 21feb686cf Merge main into feat/ai-editing-data-meshes 2026-11-17 04:04:45 -08:00
dotCooCoo 566d5263b9 Merge main into feat/ai-editing-data-meshes 2026-11-16 23:38:43 -08:00
dotCooCoo c61d429df2 Merge main into fix/ai-brush-mask-art 2026-11-16 23:36:04 -08:00
BFlat 6a2fa16cd1 Merge pull request #8289 from dotCooCoo/feat/ai-blends-in-editing-copy
.ai save: the editing copy keeps live blends
2026-11-17 14:32:25 +07:00
dotCooCoo 3829880993 .ai save: a live blend's steps carry no text wrap; metric distances stay live
- The steps of a live blend are written as drawn art: copies of key
  objects with text wrap options no longer write those options again.
  The keys keep theirs on the hidden lines and the blend keeps its own.
- The record holds Specified Distance as a 32-bit float, which the
  reader reads back as its shortest decimal. The writer now compares the
  blend with that distance, so a distance typed in another unit (10 mm
  is 28.346456... pt) is written live when it lays out as many steps.
- blend_steps_settled has unit tests for each of its cases.
- blends_write_the_same_bytes_again checks that every blend is written
  live both times.
- Comments name the blend plugin's XP line by its constant.
- docs/target-app-parity.md lists live blends in the .ai editing copy;
  a line in docs/file-format-parity.md is wrapped like the rest.

Tests: a_live_blends_steps_carry_no_text_wrap_options,
a_blend_spaced_in_millimeters_is_written_live,
steps_settle_unless_rounding_can_change_their_count.
2026-11-16 21:19:00 -08:00
BFlat f1f17409af Merge pull request #8243 from dotCooCoo/fix/ai-blend-record-orientation
.ai import: a live blend keeps its record's orientation and no spine
2026-11-17 11:44:48 +07:00
BFlat 932d4d151f Merge pull request #8262 from dotCooCoo/perf/ai-native-parse-once
.ai import: a file opened without its PDF part reads its text document once
2026-11-17 11:44:40 +07:00
dotCooCoo 4b2868bd07 .ai save: the editing copy keeps live blends
The editing copy of a PDF-compatible .ai wrote every blend as its steps.
Blends the .ai reader opens live are now written live:

- The blend's key objects and, when it has a spine of its own, its
  spine are written as a group on hidden lines, each key's dictionary
  naming it a key and its id and the spine's naming it the spine. Its
  steps follow as a group, then the Path Blends record of its spacing
  (Smooth Color, Specified Steps, Specified Distance with its distance),
  orientation (Align to Page, Align to Path) and keys, then its
  dictionary (name, text wrap options, variables) and its opacity and
  blending mode as a group's after its end. A spine edited on the canvas
  is written with each key's anchor on the key. A replaced spine is
  written with an anchor where each key sits, so it opens with those
  anchors and lays out the same steps.
- Each blend is checked with the reader's own reading before it is
  written, and the blends together against the objects the reader lays
  out in one file. Written as their steps with a warning: blends with
  easing, a color shift or start points; with effects, an appearance or
  an opacity mask of their own; of objects other than paths, compound
  paths and groups, of clipping groups, of more than 62 key objects, of
  hidden keys or keys holding a blend; of keys with geometry or
  Pathfinder effects or a group's own fills and strokes, which the
  editing copy writes as their result; of keys the editing copy would
  change otherwise (empty paths or subpaths, paths and compound path
  members of several subpaths, several fills or strokes, strokes a plain
  line can't draw, dashes of more than 64 lengths, hidden fills or strokes, fills or strokes other than
  a color, in a Lab color or with transparency or effects of their own,
  effects, opacity masks); blends where one key has a fill or stroke of
  no paint or a stroke of no width and another has one that draws;
  blends whose spine has more than one part;
  blends whose step count is close to where rounding the written
  coordinates and colors changes it; blends the reader would open with
  other settings or not as drawn; blends inside objects with geometry or
  Pathfinder effects or a group's own fills and strokes; blends in
  opacity masks, pattern tiles, symbols and art cut to a clipping object
  or nested eight levels deep in art written in place of other objects;
  blends whose art would pass the most objects the reader reads; and
  every blend on a large canvas.
- The steps set their own transparency and lock and hidden state after
  the hidden lines, for readers of the printed form.

Each construct is written in the form the .ai reader reads (blend.rs,
read/document.rs blend roles, read/containers.rs end_blend, read/ops.rs
XP and transparency), and every object written counts toward the
reader's object limit as the reader counts it. The record's orientation
word and a blend with no spine part are read as #8243 reads them.

Blend Options, key objects and spines:
https://helpx.adobe.com/illustrator/desktop/manage-colors/apply-transparency-and-blending/blend-options-overview.html
https://help.adobe.com/archive/en_US/illustrator/cs5/illustrator_cs5_help.pdf#page=260

Tests: the round trip of blends of each spacing and orientation, with
no spine of their own, an edited spine and replaced curved spines,
named, at half opacity, hidden and locked, with text wrap options, of
compound paths, of groups and of 62 keys, each laying out the same steps
as the document's blend; the record's words (Align to Path's angle
included) and the dictionaries; the steps' own state after the hidden
lines; the same bytes on a second write; each case written as its
steps, with as many steps as are drawn, where they are drawn (among
them Specified Distance 0.03 pt from where its count changes, on a
spine of 200 segments, which comes back live on a spine of two); blends in
pattern tiles, opacity masks, symbols, art cut to a clipping object and
eight levels down; the object limit; the reader's blend limit; a large
canvas; fuzz cases for damaged written blends.

Docs: docs/file-format-parity.md.
2026-11-16 17:31:04 -08:00
BFlat 3e1a6f7e51 Merge pull request #8072 from dotCooCoo/fix/ai-editing-perceptual-stops
AI editing data: a Perceptual gradient is written with the stops on its curve
2026-11-17 08:20:18 +07:00
dotCooCoo 937ca6a457 .ai import: a blend whose record's orientation fails the check takes the one drawn
When the orientation the record names didn't lay the steps out turned
as drawn, the import took the orientation whose steps sit closest to
the drawn ones by their centers alone. A half turn leaves the centers
in place, so a blend drawn Align to Path whose record named Align to
Page came in as Align to Page, with each step turned from its drawing.
The import now takes the closest of the orientations that pass the
check, and the closest of them all only when neither passes.

Test: grouped red and blue squares drawn turned on a spine running
right to left come in as Align to Path with a record naming either
orientation.
2026-11-16 16:51:46 -08:00
dotCooCoo 5007ea458b .ai import: a blend's outline check compares each member in its own fill
The check that the record's orientation lays the steps out as drawn
compared a step's outline as one set of lines. A half turn of a group
of a red square beside a blue one keeps that outline and trades the
squares' places, so such a blend passed as Align to Path. Each subpath
is now compared with the other's subpaths of a matching fill; a compound
path's members take its fill, and gradient or pattern fills are compared
with each other by their outline.

The check also tries the laid steps nearest first when it compares
outlines. Before, every step in place was compared, so a hundred steps
crowded within the tolerance used up the outline comparisons on the
first one and the check failed.

Tests: grouped red and blue squares on a spine running right to left,
drawn unturned, keep Align to Page with a record naming either
orientation, and keep Align to Path when drawn turned; a group of a
gradient-filled triangle turned a half turn doesn't match; a hundred
crowded steps match their drawn copies; 998 crowded steps keep Align to
Page.
2026-11-16 16:39:04 -08:00
dotCooCoo 1a1bb1fc28 .ai import: a blend's outline check reaches its last steps
With more than 16 drawn steps, the check compared the outlines of the
first 16 it tried and took the rest by their sizes, so a last step drawn
turned the other way still matched. It now compares the outlines of 16
steps spread evenly from the first to the last. A step that would take
more than 64 outline comparisons matches none, so the record's
orientation is not taken on an outline that was not compared.
2026-11-16 16:13:19 -08:00
dotCooCoo bfd6294b72 .ai import: a blend's outline check compares points along each side
The check that keeps a record's orientation compared two outlines by
their anchors alone. A square with its top side bent inward has the same
corners as its half turn, so the two matched. The check now also
compares the points a quarter, half and three quarters along each
segment, in both directions.
2026-11-16 16:01:19 -08:00
dotCooCoo 40ceb9258a .ai import: a file opened without its PDF part reads its text document once
Opening a .ai from its editing data alone checked whether the text
document makes all of its type, then built the document, and each step
decoded and parsed the text document and scanned the text objects'
frames again. A file with envelopes of type, which waits on its PDF
part, did this up to four times.

The check and the builds now share one read of the frames and of the
text document. It is kept with the decoded editing data for the build
with the PDF part and for the build without it that can follow, also
when the check failed. The build applies its own pattern paints to the
shared text document, as before.

The document and notes are unchanged: new tests compare them against
the same opens with every check and build reading the text afresh, and
count one read and one scan on each route.
2026-11-16 14:59:11 -08:00
dotCooCoo 94f4a63270 .ai save: a mesh patch folded at one corner is written as its drawn look
The writer measured which way each patch turns only at its first corner,
along the straight lines to the next corners. A patch whose point is
dragged across it, or whose handles cross at a corner, passed as a
plain patch and was written as a mesh. Each corner of each patch is now
measured along the straight lines and along its handles, and a mesh
whose corners turn different ways is written as its drawn look with the
warning.

- Tests: a patch folded at a corner by a moved point and by crossed
  handles; a reflected mesh read back draws the same points and opacity
  across each patch; an envelope in a symbol's art with its grid and
  contents in the symbol's own space opens as the art it draws, and one
  in a file without a template box is left unread.
- The fuzz case for written meshes moves next to the other editing-data
  cases in import_fuzz.rs.
- Docs: file-format-parity.md says a reflected mesh opens with each
  row's points in reverse order, and how envelopes in symbols open;
  target-app-parity.md links the help page on mesh point opacity.
2026-11-16 14:27:47 -08:00
dotCooCoo de367486c0 .ai save: the editing copy keeps gradient meshes
The editing copy of a PDF-compatible .ai wrote every gradient mesh as
its drawn look. Meshes the .ai reader reads back as they are are now
written as meshes:

- Each mesh is a /Mesh record: 2 /Version, its type and grid size,
  /Data, then each patch row by row with its place, the color space
  where it changes (gray, RGB or CMYK) and its four corners: color,
  opacity, point, and the handles towards the next corner and the one
  before it. Its opacity, blending mode and knockout shape are set
  before the record, and its name and opacity mask follow it.
- A reflected mesh, whose patches all turn the other way, is written
  with its columns in reverse order, which draws the same mesh.
- In a symbol's art the corners are written about the canvas point of
  the ruler origin, y up, as an image's matrix there is. An envelope's
  grid in a symbol's art is now written in the same space, and the
  envelope's contents in its dictionary in the canvas's space, y down.
- Each mesh is checked with the reader's own reading before it is
  written. Written as their drawn look with a warning: meshes with a
  point in a Lab color, with more than 128 rows or columns, folded
  meshes (patches that turn different ways), meshes the reader would
  read with other points, handles or colors, meshes in pattern tiles
  and in art cut to a clipping object, and every mesh on a large
  canvas. A mesh's drawn look is written at any depth of nested
  symbols and live objects.

Each construct is written in the form the .ai reader at e142c5fcee
reads: /CS, /Type, /Size, /P, /N and /E in mesh.rs:180-234, corners
with or without an opacity by their count of values in read_corners
(mesh.rs:239), the patches joined into one mesh in one_mesh
(mesh.rs:298); /Mesh X!, X# and /End X! in read/ops.rs:219-232; the
transparency after the record in read/art.rs:281 (end_mesh) and
read/ops.rs:344. /Version and /Data are passed over by that reader
(mesh.rs:234). Corners in a symbol's art rest on a reader change in
this commit.

The reader changes how any .ai opens:

- Mesh records and envelope grids in a symbol's art are read in canvas
  space (read/document.rs:947 image_space), and an envelope's contents
  in its dictionary in the canvas's space, y down. In a file without a
  template box such a mesh is left unread, its symbol is not read
  whole, as with an image there (read/art.rs:634), and its instances
  open as the page draws them. Envelopes in symbols in .ai files saved
  by earlier VectorCraft builds open differently.
- A point of a patch whose corners differ in color model keeps its own
  color when the patches are joined into one mesh.

Gradient meshes, mesh points and their opacity:
https://help.adobe.com/archive/en_US/illustrator/cs5/illustrator_cs5_help.pdf#page=200
Patch meshes (corners joined by cubic edges with control points):
https://opensource.adobe.com/dc-acrobat-sdk-docs/pdfstandards/pdfreference1.7old.pdf#page=321

Tests: the round trip of meshes with RGB, CMYK and gray points, a moved
point with handles of its own, part-transparent points, a name,
opacity, blending mode and knockout shape, hidden and locked, with an
inverted, unlinked opacity mask, in groups, opacity masks, symbols,
opacity masks in symbols, a document of two artboards and eight levels
down, compared point by point, handle by handle and channel by channel
at the 4 decimals written; reflected meshes, mirrored across and
along; the record's form, including corners in a symbol's art and an
envelope's grid and contents there; an envelope in a symbol read back
with its contents and their gradient in place; the same bytes on a
second write; each case written as its drawn look, with its paths read
back over the mesh's box; reading a mesh in a symbol's art with and
without a template box; /Version and /Data passed over; the color
model rule; fuzz cases for damaged written meshes, a symbol's
included.

Docs: docs/file-format-parity.md, docs/target-app-parity.md.
2026-11-16 13:44:56 -08:00
dotCooCoo d9895e3831 .ai import: a live blend keeps its record's orientation and no spine
Two settings of a blend read from the editing data came from rounding
instead of from the file:

- The orientation was whichever of Align to Page and Align to Path laid
  the steps out closer to where they are drawn. The check compares the
  steps' centers, which turning the steps along the spine leaves in
  place, so on a straight spine both fit and the rounding of the drawn
  steps decided. The reader now reads the record's word 5 (0 is Align to
  Page; a 32-bit float of 8 or more is Align to Path) and keeps that
  orientation when it lays the steps out as drawn: in place, at their
  drawn sizes and with each one's outline where it is drawn, which
  turning a step moves. Otherwise it takes the closest, as before.
- A blend with no spine part opened with a straight spine and an anchor
  at each key. When its record names the keys in their order, it now
  opens with no spine of its own, which lays out the same straight
  lines between the keys' centers. A record that names them in another
  order still gets the straight spine in the record's order.

Blend Options, orientation and spines:
https://helpx.adobe.com/illustrator/desktop/manage-colors/apply-transparency-and-blending/blend-options-overview.html

Tests: the record's word 5 (0, 8, 8 plus an angle, and values that name
no orientation); the record's orientation kept where both lay out alike,
and not taken where it would turn the drawn steps (rectangles on a
vertical spine, triangles on a spine running right to left); outlines
that match whatever anchor a path starts at, with another anchor on a
side, with contours in another order and with a lone anchor, and live
art compared by its size; a blend with no spine part in record order
and in the other order.
2026-11-16 13:30:18 -08:00
Dylan M. Taylor 9c61c0b66e Merge pull request #8103 from storytold/refactor/eps-shared-write
refactor(eps): delegate PostScript write primitives to craft-ps
2026-11-16 15:55:40 -05:00
BFlat 62371152f3 Merge pull request #8175 from dotCooCoo/perf/legacy-ai-gradient-names
Legacy .ai: gradient and spot color names are numbered with a set and a counter per name
2026-11-17 02:49:52 +07:00
dotCooCoo b20f0325a8 Merge main into fix/ai-editing-perceptual-stops 2026-11-16 10:47:13 -08:00
dotCooCoo 4af7100959 Merge main into fix/ai-legacy-perceptual-gradient 2026-11-16 10:41:13 -08:00
dotCooCoo 27295b0530 Merge main into feat/area-type-first-baseline-em-box 2026-11-16 09:55:33 -08:00
dotCooCoo ff7064219b Merge main into perf/legacy-ai-hex-samples 2026-11-16 09:53:19 -08:00
dotCooCoo 8d94673fae Legacy .ai: image samples are written as hex through a digit table
Writer::raster formatted every sample byte with write!("{:02X}") into a
separate String and then copied that String into the file body. The new
Writer::push_hex looks each nibble up in a 16-digit table and appends the
comment lines straight to the body, so a large image no longer holds a
second copy of its hex text. The written bytes are unchanged: upper-case
digits, 60 per `%` line, a newline after the last line and no line for
an empty image.

On the 36 MB of samples of a 12 MP RGB image, the hex step took a median
of 735.5 ms before and 90.8 ms after (7 runs each, both versions in one
release process). The gain matters on documents with large images.
2026-11-16 09:47:07 -08:00