A text attribute list that stores an empty FontStyle is written with the style of its AppliedFont family's Regular font, or of the family's first font if it has no Regular one. compare.py --exclude own/, trustworthy pairs: ParagraphStyle FontStyle 4,017 -> 4,080/4,086, CharacterStyle 1,310 -> 1,334/1,345, TextDefault 1,240 -> 1,250/1,251, text ranges 76,473 -> 76,619/76,652. No value that matched before changes; no extra values.
65 KiB
Attribute lists
Formatting is stored as attribute lists (on page items: chunk 0x6E03).
Decoded in src/model/attrs.rs. The IDML name and value kind of each ID
are in the tables of src/idml/attrs.rs; src/idml/kind.rs converts
each kind.
Layout
u32 count, then for each attribute:
| Size | Field |
|---|---|
| 4 | Attribute ID |
| 2 | Payload size n |
| n | Payload: u16 value count, then values |
Each value: u32 type, u16 length, data. The first value is the attribute's value. Every attribute in the samples has a second value of type 0x6E63 with 6 bytes, meaning unknown.
| Type | Length | Value |
|---|---|---|
| 0x6E68 | 8 | f64 |
| 0x6E67 | 4 | i32 |
| 0x6E65 | 2 | u16 (enumeration or boolean) |
| 0x6E69 | 16 | two f64 (a point) |
| 0x117 | 4 | UID reference |
All 2,730 page item chunks of this layout in the samples parse exactly.
Page item attributes
The list holds the item's local values. IDML writes an attribute only when it differs from the applied object style, so a value can be in the INDD list and absent from the IDML.
| ID | IDML attribute | Evidence: IDML value equals INDD value |
|---|---|---|
| 0x6E68 | FillColor (swatch UID) |
1,190 of 1,194 |
| 0x6E69 | FillTint |
10 of 10 |
| 0x6E64 | StrokeColor (swatch UID) |
78 of 82 |
| 0x6E65 | StrokeWeight |
171 of 171 |
| 0x6E6D | MiterLimit |
778 of 778 |
| 0x6E6F | CornerOption: code 0 = None, 0x5A15 = RoundedCorner, 0x5A16 = InverseRoundedCorner (the codes of object styles, objects.md) |
20 of 23 for 0x5A15; with all three codes, 1,876 of 1,995 rectangles, 504 of 520 text frames and 489 of 489 page item defaults in the trustworthy pairs |
| 0x6E70 | CornerRadius |
213 of 216 |
| 0x6E70, 0x6E94, 0x6E92, 0x6E93 | TopLeftCornerRadius, TopRightCornerRadius, BottomLeftCornerRadius, BottomRightCornerRadius (below) |
each radius ID against its own corner 4,357, 3,200, 3,276 and 3,325 matches, no mismatch |
| 0x6E6F, 0x6E91, 0x6E8F, 0x6E90 | TopLeftCornerOption, TopRightCornerOption, BottomLeftCornerOption, BottomRightCornerOption: codes as CornerOption (below) |
11,211 of 11,211 |
| 0x551F | GradientFillLength |
all non-zero (30) |
| 0x5520 | GradientFillStart (point) |
all non-zero (30) |
| 0x5525 | GradientStrokeLength (assumed; equal to fill in all samples) |
30 |
| 0x5526 | GradientStrokeStart (assumed; equal to fill in all samples) |
30 |
| 0x6E6E | StrokeType (built-in stroke style code, below) |
51 of 51 items, 576 of 576 object styles; strokes, below |
| 0x6E8C | StrokeAlignment: 0 CenterAlignment, 1 InsideAlignment, 2 OutsideAlignment (below) |
strokes, below |
| 0x6E66, 0x6E89, 0x6E8A, 0x6E6B, 0x6E6C, 0x6E71, 0x6E72, 0x6E84 | StrokeTint, GapColor, GapTint, EndCap, EndJoin, LeftLineEnd, RightLineEnd, ArrowHeadAlignment |
strokes, below |
Corners. The top-left corner uses the same IDs as CornerRadius
and CornerOption. The corner option codes are 0 None, 0x5A15
RoundedCorner, 0x5A16 InverseRoundedCorner, 0x5A17 InsetCorner,
0x5A18 BevelCorner and 0x5A19 FancyCorner; all six occur. The
evidence is over the items of the trustworthy pairs whose corners
differ: each radius ID matches its own corner with no mismatch, and has
16 to 71 mismatches against each other corner. The same IDs hold the
corners of object styles (chunk 0x1B92B) and of the page item defaults
(class 0x6E07): all four radii and options of PageItemDefault match in
495 of 495 documents.
Values equal to the object style. The style's effective value is
its own (chunk 0x1B92B), else that of the style it is based on, else the
root [None]'s (StrokeWeight="0", FillTint="-1", FillColor and
StrokeColor Swatch/None, CornerRadius="12", MiterLimit="4",
CornerOption="None"; idml-values.md). Over the 489 trustworthy pairs,
the converter wrote these values where the IDML has none, and every one
of them equals the style's effective value (the stroke attributes of
the strokes section follow the same rule):
| Attribute | Written though the IDML has none | IDML writes it though equal |
|---|---|---|
StrokeWeight |
27,989 | 5 |
CornerRadius |
1,608 | 0 |
FillTint |
1,423 | 0 |
StrokeColor |
1,336 | 0 |
FillColor |
312 | 0 |
CornerOption |
87 | 0 |
MiterLimit |
26 | 0 |
Of the StrokeWeight values, the 26,969 on items whose IDML element has
the same tag all equal the style (17,501 text frames, 7,070 rectangles,
2,074 polygons, 297 ovals, 27 lines); the others are on shapes written
as another element type. The converter leaves out these attributes, and
the four corner radii and options, when they equal the style's value
(numbers to 6 significant digits).
Values an item does not store
Every document has one object of class 0x6E02 (606 of 606 trustworthy pairs). Its chunk 0x6E03 is a page item attribute list with every fill, stroke and corner attribute. An item whose own list lacks an attribute has the value of this base list, not that of its object style. IDML writes that value where it differs from the object style's effective value, the same rule as for stored values.
The base lists differ in two ways across the trustworthy pairs, always
together: 481 documents have StrokeWeight 1 and corner radii 12, 125
have 0.2835 (0.1 mm) and 14.1732 (5 mm). All have StrokeColor and
FillColor naming the swatch None, FillTint −1, MiterLimit 4,
StrokeType Solid, StrokeAlignment CenterAlignment and corner
options None.
Evidence: an analysis script looked for the field that tells the
documents whose items have StrokeWeight="0.2834645669291339" apart
from those whose items have 1, by testing every f64 of every object
whose class occurs once per document; the StrokeWeight of this list
matched 294 of 295 documents. With the base values and the rule above,
the converter reproduces, over the rectangles, ovals, polygons, graphic
lines and text frames of the trustworthy pairs (anchored ones
included), 8,790 of 8,794 StrokeColor values, 54,694 of 54,694
StrokeWeight, 42,500 of 42,504 MiterLimit and 6,383 of 6,387
CornerRadius, with no extra value. The values not reproduced in that
measurement were on 4 text frames without an object style (no object
style, below) and on items with stored values not decoded then (77
FillTint, stored fills such as pasted smooth shades, the stroke
alignment OutsideAlignment and stroke types; strokes, below). Over all pairs, 4 extra StrokeWeight values appear,
in 3 stale pairs.
Groups are left out: their fill and stroke attributes in IDML were not
studied (1,844 groups of the trustworthy pairs have a StrokeWeight
that the converter does not write). IDML writes no corner attributes
for EPS text (class 0x660B; none in 634 elements), so only its other
attributes follow the rule.
Category turned off. When the item's object style (other than the
root [None]) turns a category off, IDML writes the item's values of
that category even where they equal the style's, stored or from the
base list:
| Category (ID in chunk 0x1B92E) | Attributes |
|---|---|
EnableFill (0x1B933) |
FillColor, FillTint |
EnableStroke (0x1B934) |
StrokeColor |
EnableStrokeAndCornerOptions (0x1B935, 0x1B936) |
StrokeWeight, MiterLimit, StrokeAlignment, EndCap, EndJoin, the line ends, ArrowHeadAlignment, corner radii and options |
| both stroke categories | StrokeType, StrokeTint, GapColor, GapTint |
Evidence over the trustworthy pairs: 66 items with styles that turn all
three off and 2 with styles that turn off both stroke categories have
every such attribute in IDML, with the stored or base value; 12 items
whose style turns off only EnableStrokeAndCornerOptions have
StrokeWeight, MiterLimit, StrokeAlignment and the corners, but
no StrokeColor or StrokeType. No sample turns off only
EnableStroke, so the category of StrokeType is not shown; the
converter writes it when both are off. The 68 items also have
StrokeTint, EndCap, EndJoin, GapColor and GapTint, and the 12
items EndCap and EndJoin but not StrokeTint, GapColor or
GapTint, which gives the categories of the table (the line ends and
ArrowHeadAlignment follow the 12 items in the corpus after 2026-10).
No object style. An item without an applied object style has
AppliedObjectStyle="n" in IDML, and IDML writes every fill, stroke
and corner attribute of the item, stored or from the base list: 60 of
60 such items (35 rectangles, 25 text frames) of the trustworthy pairs
after 2026-10, every attribute equal.
Transparency attributes (IDs 0x108xx and 0x1EBxx) are described in
transparency.md.
Strokes
Object styles (class 0x1B901) hold a full page item attribute list in
chunk 0x1B92B, with the same record layout as chunk 0x6E03 but a u16
count. The converter reads them (object style lists in indd audit)
and writes them with the page item table. They also add evidence: the
corpus pairs have 576 object styles whose name matches an IDML
ObjectStyle.
Stroke type (0x6E6E). The record has three values: a reference (type
0x117), a code (type 0x6E64, 4 bytes) and the usual 6-byte value. With
reference 0 the code names a built-in stroke style. IDML writes
StrokeType as StrokeStyle/$ID/<name>.
| Code | IDML stroke style | Evidence |
|---|---|---|
| 0x5A29 | Solid |
574 object styles in 135 files |
| 0x5A2A | Dashed |
2,326 items in 40 files |
| 0x5A37 | Canned Dashed 4x4 |
52 items in 20 files |
| 0x5A38 | Canned Dashed 3x2 |
160 items in 45 files |
| 0x5A39 | Canned Dotted |
345 items in 30 files |
| 0x5A3A | Wavy |
4 items in 1 file |
| 0x5A3B | Straight Hash |
109 items in 43 files |
| 0x5A3C | Right Slant Hash |
2 items in 1 file |
| 0x5A3E | White Diamond |
33 items in 18 files |
| 0x5A3F | Japanese Dots |
913 items in 29 files; cells (tables.md) |
| 0xB004 | ThinThin |
31 items in 3 files |
| 0xB005 | ThinThick |
10 items in 3 files |
| 0xB006 | ThickThin |
44 items in 12 files; object styles |
| 0xB007 | ThickThick |
35 items in 13 files; cells |
| 0xB009 | ThickThinThick |
1 item |
| 0xB01A | Triple_Stroke |
5 items in 3 files |
Item counts are over the items of the 1,251 trustworthy pairs of the
corpus after 2026-10 with reference 0, IDML value against stored code.
No code has two IDML values. The codes are the same in every list that
names a stroke style (items, object styles, cells, tables, paragraph
rules, underlines and strike-throughs), so the converter uses one table.
Custom stroke styles (a non-zero reference, 17 items in 2 files, for
example DashedStrokeStyle/Rounded) are left out. Codes 0x5A3D and
0xB008 occur only in files without a trustworthy IDML.
Stroke alignment (0x6E8C). 0 CenterAlignment, 1 InsideAlignment
(3,238 items in 44 files), 2 OutsideAlignment (196 items in 50 files).
Object styles use 0x1BB8 with the same codes.
More stroke attributes. Object styles other than [None] were
matched by Self with their IDML style over the 1,251 trustworthy
pairs (4,305 styles; every one has the IDs below except 0x6E84), and
page items by Self with their IDML element:
| ID | IDML attribute | Values | Object styles |
|---|---|---|---|
| 0x6E66 | StrokeTint |
f64; 100 is written as −1 | 4,305 of 4,305; 69 styles other than −1 (25 to 75) |
| 0x6E89 | GapColor |
swatch UID | 4,305 of 4,305; 23 Color/Paper |
| 0x6E8A | GapTint |
f64; 100 is written as −1 | two styles with 100 have −1 in IDML |
| 0x6E6B | EndCap |
0 ButtEndCap, 1 RoundEndCap, 2 ProjectingEndCap |
4,305 of 4,305; 3 round |
| 0x6E6C | EndJoin |
0 MiterEndJoin, 1 RoundEndJoin, 2 BevelEndJoin |
4,305 of 4,305; 5 round |
| 0x6E71 | LeftLineEnd |
line end code (below) | 4,305 of 4,305; 9 other than None |
| 0x6E72 | RightLineEnd |
line end code | 4,305 of 4,305; 14 other than None |
| 0x6E84 | ArrowHeadAlignment |
0 InsidePath, 1 OutsidePath |
in the 3,349 styles whose IDML has the attribute, 3,349 of 3,349; one style has 1 |
Line end codes (u32): 0 None, 0x5A03 SimpleArrowHead (1 item),
0x5A04 SimpleWideArrowHead (110 items in 5 files), 0x5A05
TriangleArrowHead (44 in 8), 0x5A06 TriangleWideArrowHead, 0x5A07
BarbedArrowHead (64 in 6), 0x5A08 CurvedArrowHead, 0x5A09
CircleArrowHead, 0x5A0A CircleSolidArrowHead, 0x5A0C
SquareSolidArrowHead (the page item defaults of 5 files) and 0x5A0D
BarArrowHead. EndCap 2 occurs on 4 items in 3 files, EndJoin 2 on
6 items in 1 file. One line in the pairs before 2026-10 has 0x6E71 =
0x5A08 and 0x6E72 = 0x5A0D with LeftLineEnd="CurvedArrowHead" and
RightLineEnd="BarArrowHead", which gives 0x5A0D. ArrowHeadAlignment
code 1 rests on one style; that style's line ends are mapped by their
own IDs, which leaves 0x6E84.
On page items IDML writes these attributes, the stroke type and the
stroke alignment by the rule of the fill and stroke colour: the value
the item stores (or that of the base list) where it differs from the
applied object style's effective value, every value where the style
turns the category off, and every value without a style (above). Groups
never store these IDs, and IDML writes values on groups whose source is
not shown (664 groups with StrokeTint, 40 with LeftLineEnd), so the
converter writes none on groups.
A tint is compared as stored: an item that stores 100 differs from a
style value of −1, and IDML writes it as −1. 4,508 items in 192 files
store StrokeTint 100 and have StrokeTint="-1" in IDML; no IDML item
has StrokeTint="100". Items that store −1, or the style's own value,
have no attribute; one polygon that stores 100 has none either.
GapTint behaves the same (11 items in 2 files store 100).
Over the rectangles, ovals, polygons, graphic lines and text frames of
the trustworthy pairs the converter reproduces these values; the one
extra value is a polygon of a 19.0 document that stores StrokeTint
100 and has no attribute in IDML:
| Attribute | Values |
|---|---|
StrokeTint |
5,874 of 5,874 |
EndCap |
8,538 of 8,538 |
EndJoin |
8,220 of 8,220 |
GapColor |
435 of 435 |
GapTint |
181 of 181 |
LeftLineEnd |
453 of 453 |
RightLineEnd |
435 of 435 |
ArrowHeadAlignment |
139 of 139 |
StrokeType |
4,230 of 4,235 (5 custom stroke styles) |
StrokeAlignment |
3,572 of 3,572 |
The values of PageItemDefault come from the page item defaults list
with the same table (preferences.md).
Not identified. LeftArrowHeadScale and RightArrowHeadScale are
100 in every object style and in every PageItemDefault but one, as are
0x6E95 and 0x6E96, so the two IDs cannot be told apart. The converter
writes them from the value files on object styles, and from the IDs in
their order on PageItemDefault, where the values are equal in every
file (preferences.md, page item defaults). 0x6E78 is 0 in every style,
0x6E73 in all but 2; 0x6E78 is Nonprinting of PageItemDefault. 0x6E67, 0x6E6A and 0x6E8B are the
overprint flags (objects.md, object style settings).
StrokeCornerAdjustment and StrokeDashAndGap do not occur in the
corpus IDML files.
Text attribute lists
Text formatting uses the same record layout with a u16 count. It appears in:
- Styles: chunk 0x23F of a style object (u16 count, records).
- Story runs: each paragraph-style or character-style run record
(chunk 0x262, see
objects.md) continues after the style UID with a u16 count and records. These are the run's local overrides.
Value types are specific to each attribute (for example 0x1B05 for swatch
references, 0x1B28 for point size), so the converter decodes a text value
by the layout of its attribute. The attributes whose value is not a
single number have their layout listed in text_layout
(src/model/attrs.rs): string values (FontStyle) are a flag byte
followed by an in-object string; tab lists, nested, GREP and line
styles, bullet characters, points, ruby text and cell edge stroke types
are described below. Other values are numbers, decoded by length: 8 bytes f64, 4 bytes
u32, 2 bytes u16. A value that does not fit its attribute's layout is
kept undecoded and not written.
Mapping and evidence
Found by aligning IDML ParagraphStyleRange and CharacterStyleRange
elements with INDD runs at the same text offset (1,562 ranges), and IDML
styles with INDD styles of the same name (486 styles), then checked with
tools/compare.py. Counts are matches/total in the current comparison
(ranges + paragraph styles + character styles where present).
| ID | IDML attribute | Encoding | Evidence |
|---|---|---|---|
| 0x1B01 | FillColor |
swatch UID | 354/354 ranges, 226/226 styles |
| 0x1B02 | FontStyle |
flag + string; empty: below | 474/474 ranges, 202/202 styles |
| 0x1B03 | PointSize |
f64 | 1,090/1,090 ranges |
| 0x1B06 | HorizontalScale |
fraction ×100 | 2/2 ranges, 75/75 styles |
| 0x1B07 | KerningMethod |
code: 15972 Metrics, 79875 Optical, 0x3E65 $ID/Metrics - Roman Only (27 styles) |
20/20 ranges, 81/81 styles |
| 0x1B08 | Ligatures |
1 = true | 201/201 ranges |
| 0x1B0A | StrokeWeight |
f64 | 241/241 ranges |
| 0x1B0B | Tracking |
thousandths of an em ×1000 | 49/49 ranges, 94/94 styles |
| 0x1B0C | Composer |
code: 0x2001 HL Single, 0x2002 HL Composer, 0x2078 HL Composer Optyca, 0x2079 HL Single Optyca, 0x2010 HL Composer J, 0x2011 HL Single J (runs/styles: 47/14, 0/30, 7/15) | 4/4 ranges, 114/114 styles |
| 0x1B0D | DropCapCharacters |
u16 | 79/79 styles; see below |
| 0x1B0E | DropCapLines |
u16 | 79/79 styles; see below |
| 0x1B10 | BaselineShift |
f64 | 79/79 styles; see below |
| 0x1B11 | Capitalization |
0 Normal, 1 SmallCaps, 2 AllCaps, 3 CapToSmallCap | 77/77 styles; codes 1 and 3 below |
| 0x1B12 | StrokeColor |
swatch UID | 75/75 styles |
| 0x1B13 | KerningValue |
ems ×1000; 1e8 = none | 8/8 ranges; scale from a sample and its print PDF, see below |
| 0x1B15 | VerticalScale |
fraction ×100 | 79/79 styles; see below |
| 0x1B16 | LeftIndent |
f64 | 22/22 ranges |
| 0x1B17 | RightIndent |
f64 | 86/86 styles |
| 0x1B18 | FirstLineIndent |
f64 | 12/12 ranges |
| 0x1B1A | AutoLeading |
fraction ×100 | 75/75 styles |
| 0x1B1B | Leading (Properties) |
f64; negative = Auto | 43/43 ranges, 137/137 styles |
| 0x1B1D | AppliedLanguage |
language UID; see below | 88/88 styles |
| 0x1B1F | Hyphenation |
3 = true, 0 = false | 204/204 ranges |
| 0x1B24 | NoBreak |
1 = true | 78/78 styles |
| 0x1B25 | HyphenationZone |
f64 | 155/155 ranges |
| 0x1B26 | SpaceBefore |
f64 | 13/13 ranges |
| 0x1B27 | SpaceAfter |
f64 | 42/42 ranges |
| 0x1B29 | TabList (Properties) |
list; see below | 110/110 styles |
| 0x1B2A | Underline |
1 = true | 81/81 ranges |
| 0x1B2B | AppliedFont (Properties) |
font family UID; a composite font as an object (below) | 1,071/1,071 ranges, 236/247 styles |
| 0x1B2C | OTFFigureStyle |
0 TabularLining (23 runs, 5 styles), 1 ProportionalOldstyle, 2 ProportionalLining, 4 Default | 4/4 ranges, 138/138 styles |
| 0x1B2E | MaximumWordSpacing |
fraction ×100 | 77/77 styles |
| 0x1B2F | MinimumWordSpacing |
fraction ×100 | 77/77 styles |
| 0x1B31 | MaximumLetterSpacing |
fraction ×100 | 78/78 styles; see below |
| 0x1B32 | MinimumLetterSpacing |
fraction ×100 | 78/78 styles; see below |
| 0x1B33 | DesiredGlyphScaling |
fraction ×100 | 22/22 ParagraphStyleRange elements in 10 documents (96 to 99), 1,251 trustworthy pairs; 1.0 in the root style and text defaults of every pair, as IDML's 100. No other text list of the pairs has it |
| 0x1B37 | StartParagraph |
0 Anywhere, 1 NextColumn, 2 NextPage, 3 NextFrame, 4 NextOddPage | 78/78 styles; codes below |
| 0x1B3C | Position |
0 Normal, 1 Superscript, 2 Subscript, 3 OTSuperscript, 4 OTSubscript, 5 OTNumerator, 6 OTDenominator (runs/styles: 107/23, 4/7, 1/0, 3/0, 21/0 for 1, 2, 3, 4, 6) | 20/20 ranges, 78/78 styles |
| 0x1B40 | KeepLinesTogether |
1 = true | 78/78 styles; see below |
| 0x1B42 | FillTint |
f64 | 24/24 ranges |
| 0x1B46 | GradientFillAngle |
f64 | 81/81 styles |
| 0x1B48 | GradientFillLength |
f64 | 2/2 ranges, 81/81 styles |
| 0x1B4A | GradientFillStart |
two f64 | 2/2 ranges, 81/81 styles |
| 0x1B4D | RuleAboveLineWeight |
f64 | 155/155 ranges |
| 0x1B4F | RuleAboveOffset |
f64 | 78/78 styles |
| 0x1B50 | RuleAboveLeftIndent |
f64 | 91/91 styles |
| 0x1B51 | RuleAboveRightIndent |
f64 | 91/91 styles |
| 0x1B52 | RuleAboveWidth |
1 ColumnWidth, 2 TextWidth | 91/91 styles |
| 0x1B53 | RuleBelowColor (Properties) |
swatch UID, 0 = "Text Color" | 6/6 ranges, 114/114 styles |
| 0x1B54 | RuleBelowLineWeight |
f64 | 155/155 ranges |
| 0x1B55 | RuleBelowTint |
f64 | 78/78 styles |
| 0x1B56 | RuleBelowOffset |
f64 | 78/78 styles |
| 0x1B5D | RuleBelow |
1 = true | 83/83 styles |
| 0x1B6A | ParagraphBreakType |
0 Anywhere, 1 NextColumn, 2 NextPage, 3 NextFrame, 4 NextOddPage (below) | 11/11 ranges, 78/78 styles |
| 0x1B6B | SingleWordJustification |
0 LeftAlign, 3 FullyJustified | 80/80 styles |
| 0x1B75 | AllNestedStyles (Properties) |
list; see below | 124/124 paragraph styles, 10/10 text defaults (1,251 trustworthy pairs) |
| 0x1B7E | Justification |
0 LeftAlign, 1 CenterAlign, 2 RightAlign, 3 FullyJustified, 4 LeftJustified, 5 CenterJustified, 6 RightJustified, 8 ToBindingSide, 9 AwayFromBindingSide (runs/styles for 3, 6, 8, 9: 34/1, 3/0, 2/1, 7/14) | 70/70 ranges |
| 0x1B80 | DropcapDetail |
u32 | 5/5 ranges, 103/103 styles |
| 0x1B8C | OTFContextualAlternate |
1 = true | 220/220 ranges |
| 0x1B8D | UnderlineColor (Properties) |
swatch UID, 0 = "Text Color" | 81/81 ranges |
| 0x1B91 | UnderlineOffset |
f64 | 81/81 ranges |
| 0x1B94 | UnderlineWeight |
f64 | 81/81 ranges |
| 0x1BB7 | MiterLimit |
f64 | 161/161 ranges |
| 0x1BB9 | EndJoin |
0 MiterEndJoin, 1 RoundEndJoin | 86/86 styles |
| 0x1BBA | AllGREPStyles (Properties) |
list; see below | 152/152 paragraph styles, 48/48 text defaults, 320/320 text ranges (1,251 trustworthy pairs) |
| 0x1BBB | AllLineStyles (Properties) |
list; see below | 6/6 paragraph styles, 9/9 text ranges (1,251 trustworthy pairs) |
| 0x1BBD | SpanColumnType |
0 SingleColumn, 1 SpanColumns, 2 SplitColumns (69 runs, 10 styles) | 41/41 ranges, 94/94 styles |
| 0x1BBE | SpanSplitColumnCount (Properties) |
u16; 1 = All | 12/12 ranges, 78/78 styles |
| 0x1BBF | SplitColumnInsideGutter |
f64 | 155/155 ranges |
| 0x1BC4 | SpanColumnMinSpaceAfter |
f64 | 84/84 styles |
| 0x1BD2 | ParagraphShadingColor (Properties) |
swatch UID | 25/25 ranges |
| 0x1BD3 | ParagraphShadingTint |
f64 | 79/79 styles |
| 0x1BD6 | ParagraphShadingOn |
1 = true | 88/88 styles |
| 0x1BDB | ParagraphShadingTopOffset |
f64 | 91/91 styles |
| 0x1BDC | ParagraphShadingBottomOffset |
f64 | 90/90 styles |
| 0x1BF6 | ParagraphBorderColor (Properties) |
swatch UID | 72/72 styles |
| 0x1BFA | ParagraphBorderGapColor (Properties) |
swatch UID; 0 is Swatch/None |
present exactly when the list has the ID (344 of 344 styles of the corpus of 2026-10); trustworthy pairs after 2026-10: 1,147 of 1,147 paragraph styles, 918 of 918 text defaults, 2,745 of 2,745 text ranges, 642 + 84 story and cell paragraph ranges |
| 0x1BF9 | ParagraphBorderOn |
1 = true | 77/77 styles |
| 0x1DF03 | ParagraphBorderTopOffset |
f64 | 83/83 styles |
| 0x1DF04 | ParagraphBorderBottomOffset |
f64 | 83/83 styles |
| 0x1DF21 | SameParaStyleSpacing (Properties) |
f64; −1 = SetIgnore | 15/15 ranges, 100/100 styles |
| 0x4265 | GridAlignFirstLineOnly |
1 = true | 81/81 styles |
| 0x4266 | GridAlignment |
0 None, 1 AlignBaseline | 86/86 styles |
| 0x425E | Tatechuyoko |
1 = true | root styles; 1 from a sample typeset vertically and its print PDF, see below |
| 0x4279 | ShataiDegreeAngle |
degrees, written ×100 | root styles; see below |
| 0x427A | ShataiAdjustTsume |
1 = true | root styles; see below |
| 0x427B | ShataiAdjustRotation |
1 = true | root styles and a sample typeset vertically; see below |
| 0x422D | RubyFlag |
number; written when not 0 | a sample and its print PDF; see below |
| 0x422E | RubyString |
u32 length, text segments; written when not empty | a sample and its print PDF; see below |
| 0x1A401 | BulletsAndNumberingListType |
0 NoList, 1 BulletList, 2 NumberedList (8 runs, 20 styles) | 10/12 ranges |
| 0x1A406 | BulletChar (Properties) |
u32 type, u32 value; see below | 1/1 ranges, 84/84 styles |
| 0x1A413 | BulletsFont (Properties) |
font family UID, 0 = $ID/ |
1/1 ranges, 84/84 styles |
| 0x1A414 | BulletsFontStyle (Properties) |
flag + string; empty = Nothing |
1/1 ranges, 84/84 styles |
| 0x1A417 | AppliedNumberingList (Properties) |
numbering list UID (objects.md, numbering lists) |
519/519 styles |
| 0x1A419 | NumberingContinue |
1 = true | 2/2 ranges, 78/78 styles |
| 0x1A41F | BulletsCharacterStyle (Properties) |
character style UID | 84/84 styles |
| 0x1A420 | NumberingCharacterStyle (Properties) |
character style UID | 79/79 styles |
| 0x1A423 | NumberingExpression |
flag + string | 79/79 styles |
| 0x4221 | Mojikumi (Properties) |
table UID; see below | 936/1,019 styles |
| 0x4224 | KinsokuSet (Properties) |
table UID; see below | 987/987 styles |
| 0x42C0 | TreatIdeographicSpaceAsSpace |
1 = true | 1,082/1,083 styles |
| 0x50F18 | DiacriticPosition |
4 OpentypePosition, 5 OpentypePositionFromBaseline | 1,007/1,010 styles |
The counts of these four are paragraph and character styles of all 654
pairs whose IDML style has the attribute and the same name (the root
paragraph style of every pair among them); they also reproduce the
TextDefault values of the preferences (preferences.md). The kinsoku
and mojikumi value is a UID: 0 is Nothing; a built-in table
(kinsoku and mojikumi tables in objects.md) is written as an
enumeration: kHardKinsokuName HardKinsoku (51 styles),
kSoftKinsokuName SoftKinsoku (11), kKoreanKinsokuName
KoreanKinsoku (12), kSimpChineseKinsokuName
SimplifiedChineseKinsoku (1), kMojikumiDefaultName1
LineEndAllOneHalfEmEnum (55) and kMojikumiDefaultName16
SimpChineseDefault (1); a custom kinsoku table (class 0x4204) as the
object KinsokuTable/<name> (38). Other built-in tables are not written.
A custom mojikumi table (class 0x4203, objects.md) is the object
MojikumiTable/<name>. In the trustworthy pairs of the corpus of
2026-10 this gives the IDML value for 576 paragraph ranges, 105
paragraph styles, 94 ranges in table cells, 19 story ranges and 11 text
defaults, with no value that differs from the IDML.
Paragraph style counts include the 78 root styles [No paragraph style]
of the compared pairs. For many attributes above the root holds the only
value that is the same in every pair (for example RightIndent="0"), so
the evidence that tells the attribute apart is in the other styles:
| Attribute | Other styles or ranges with the attribute |
|---|---|
BaselineShift |
1 style with 0; 1 range with −16 in a story that compare.py does not align |
RightIndent |
8 styles in one pair, two different values |
AppliedLanguage |
10 styles in 2 pairs |
NoBreak |
1 style with 1 (true), in a pair whose IDML is from an older version |
TabList |
33 styles in 5 pairs, left and right stops, with and without leaders |
OTFFigureStyle |
60 styles in one pair (codes 1 and 2), 4 ranges in another (code 4) |
Position |
20 ranges in one pair |
GradientFill* |
3 styles in one pair (angle −90, distinct length and start), 2 ranges in another |
RuleAbove*Indent, RuleAboveWidth |
13 styles in one pair (left −1.13, right −2.83) |
RuleBelowColor |
36 styles in 2 pairs, four colours |
RuleBelow |
5 styles in one pair (4 true, 1 false) |
ParagraphBreakType |
19 ranges in one pair |
SingleWordJustification |
2 styles in one pair with code 0 |
EndJoin |
8 styles in one pair |
SpanColumnType |
16 styles in 2 pairs, 46 ranges in one pair, both codes |
SpanSplitColumnCount |
13 ranges in one pair with 2 |
SpanColumnMinSpaceAfter |
6 styles in one pair |
ParagraphShading*, ParagraphBorder* |
2 to 14 styles in one pair, several different offsets |
SameParaStyleSpacing |
30 styles and 16 ranges, each in 2 pairs |
GridAlignment, GridAlignFirstLineOnly |
8 and 3 styles in 3 pairs |
BulletChar, BulletsFont, BulletsFontStyle, BulletsCharacterStyle |
6 styles in 2 pairs, 1 range in another |
NumberingExpression, NumberingCharacterStyle |
1 style |
NumberingContinue |
2 ranges in 2 pairs |
VerticalScale |
1 style; see below |
For codes, the root style gives the default: for example every root style
has 0x1B6B = 3 and IDML SingleWordJustification="FullyJustified", and
0x1BBE = 1 with SpanSplitColumnCount All.
VerticalScale (0x1B15). The value is 1 (100%) wherever it appears,
like HorizontalScale (0x1B06), so values do not tell them apart. Over
all pairs, including those with an IDML from another version, 0x1B15 is
present in exactly the 5 styles where IDML writes VerticalScale; 0x1B06
is identified separately by values other than 100%.
Languages (0x1B1D). The value is the UID of an object of class
0x2D07. Its chunk 0x2D0F is a flag byte, then the language name as an
in-object string (English: USA), followed by other strings. IDML writes
$ID/ and that name. Over all pairs, all 62 styles (root styles
included) and 4 ranges with the attribute match, with 5 different
languages.
Tab stops (0x1B29). u16 count, then for each stop: f64 position, u16
alignment (0 LeftAlign, 1 CenterAlign, 2 RightAlign, 3
CharacterAlign), for code 3 the alignment character as one UTF-16
unit, u16 leader length and the leader in UTF-16 code units. IDML writes
each stop as a ListItem with Alignment, AlignmentCharacter,
Leader and Position. A stop with another code stores no character,
and IDML writes . for it in every sample. An empty list is a count of
0. The converter leaves out a list with another alignment code.
Evidence, corpus of 2026-10, the stops of paragraph styles matched by
Self and of story paragraph ranges: 79 CenterAlign stops (59 in
trustworthy pairs) and 36 CharacterAlign stops (34; 27 with ,, 9
with .) match in alignment, character, leader and position. Before
code 3 was read, a list with such a stop was not read at all: the
character made the record longer than the stops.
Nested styles (0x1B75). u32 count, then for each item: u32 character
style UID, u32 length, and a delimiter code of that many characters
stored as text segments (see objects.md). The code gives Delimiter,
Inclusive and Repetition:
| Code | IDML | Evidence |
|---|---|---|
[c] |
Delimiter string c, Inclusive="false" |
13 items in one pair (. and :) |
(c) |
Delimiter string c, Inclusive="true" |
1 item in the same pair |
^c |
Dropcap, Inclusive="true" |
1 item in the same pair |
digits after ) or ] |
Repetition; no digits = 1 |
a sample and its print PDF |
(^w) |
AnyWord |
a sample and its print PDF |
(^?) |
AnyCharacter |
a sample and its print PDF |
(^c) |
Dropcap |
54 Dropcap records in 18 pairs (with ^c) |
^t in brackets |
Tabs |
9 records in 5 pairs ([^t], (^t), (^t)2 seen) |
^L in brackets |
Repeat; the digits are Repetition |
41 records in 33 pairs ((^L)2, (^L)4 seen) |
^p in brackets |
EndNestedStyle |
2 records in 1 pair |
^9 in brackets |
Digits |
2 records in 1 pair ([^9], (^9)) |
^S in brackets |
Sentence |
1 record in 1 pair |
The public pair has only single-character literals and repetition 1. The last three rows rest on a sample and its print PDF:
- A sample has nested items with
(^?)and with(^w)followed by a number, the latter applying a character style with Capitalization code 3 (CapToSmallCap, see below). - In the PDF, capitals in the first words of paragraphs in those styles
are set at small-cap height (ink height measured on the rendered
page), and capitals later in the same lines at full height. Small
capitals reach at most one word past the number, and capitals a few
words further on are at full height, so the number is the repetition.
Of the counting delimiters in the IDML schema, only
AnyWordgives a stretch of several words:AnyCharacter,LettersandDigitswould end within the first word, andSentencewould run past sentence ends, which the PDF does not show. - A paragraph-level override has
(^?)followed by a number n, then(^w). In the PDF the first capital after the first n characters of that paragraph is a small cap. With a word delimiter, the first n words would keep full capitals, and that capital lies within them. So^?counts characters:AnyCharacter.
The last six rows come from the 1,251 trustworthy pairs of the corpus
after 2026-10. Their reference IDMLs have 265 nested style records in
72 documents (styles, text defaults and text ranges; the record counts
above are these). The stored items map one to one onto the IDML
records, with the bracket giving Inclusive and the digits
Repetition as above: the converter reproduces AllNestedStyles of
124 of 124 paragraph styles, 10 of 10 text defaults, 274 of 274 text
ranges and 7 of 7 Story/ParagraphStyleRange elements. Without these
codes it reproduced 54 paragraph styles and 4 text defaults.
The converter leaves out a list that has any other code.
GREP styles (0x1BBA). The layout of nested styles, with a GREP
expression in place of the delimiter code: u32 count, then for each item
u32 character style UID (0 for none), u32 length n and the expression
as n UTF-16 code units in text segments. IDML writes
AllGREPStyles (type="list"), one ListItem type="record" per item in
stored order, with AppliedCharacterStyle (object) and GrepExpression
(string). Evidence over the 1,251 trustworthy pairs: every 0x1BBA value
of the paragraph styles parses and ends exactly after its last item; the
reference IDMLs have 494 such lists with 1,064 items, all of these two
fields. The converter reproduces 152 of 152 paragraph styles, 48 of 48
text defaults, 320 of 320 text ranges (Story/ParagraphStyleRange 110,
Cell/ParagraphStyleRange 94), with no extra value. A style's list is
its own value; IDML does not write an inherited one.
Line styles (0x1BBB). u32 count, then 8 bytes per item: u32
character style UID and u32 line count. IDML writes AllLineStyles,
one record per item: AppliedCharacterStyle (object), LineCount
(long) and RepeatLast (long). RepeatLast is −1 in all 9 list items of
the trustworthy reference IDMLs (3 documents) and no stored field holds
it, so the converter writes −1. Reproduced: 6 of 6 paragraph styles and
9 of 9 text ranges.
Empty lists. None of the 1,251 trustworthy reference IDMLs has an
AllGREPStyles, AllLineStyles or AllNestedStyles element without
items. The converter writes no GREP or line style list without items.
Bullet character (0x1A406). Two u32: the character type (0
UnicodeOnly, 1 UnicodeWithFont, 2 GlyphWithFont) and the character
value. IDML writes an empty BulletChar element with
BulletCharacterType and BulletCharacterValue attributes. In the
pairs, type 0 occurs in the root styles with value 8226 (•), type 1 in
one range and type 2 in 6 styles, each with its value and a
BulletsFont.
KeepLinesTogether (0x1B40). In every pair the root style has 0, and
IDML writes KeepLinesTogether="false", KeepAllLinesTogether="false",
KeepFirstLines="2" and KeepLastLines="2". No public style sets
another value. The rest of the evidence is a sample and its print PDF:
- Some paragraph styles of the sample set 0x1B40 to 1. Apart from attributes identified above, they set nothing else.
- In the PDF, paragraphs in those styles that break across pages always leave at least two lines on each page. A paragraph of n lines broken at a random line leaves a single line on one side with probability 2/(n − 1), so this pattern does not come from chance.
- Such paragraphs do break across pages, so the attribute is not
KeepAllLinesTogether. A boolean that keeps at least two lines together at both ends, with the defaults above, isKeepLinesTogether.
Capitalization codes 1 and 3.
- Code 1 is
SmallCaps. In one pair (InDesign 20.2, IDML from the same version), 8 of 8 paragraph styles with code 1 haveCapitalization="SmallCaps". The same pair confirms code 2 (4 of 4 styles) and code 0. - Code 3 is
CapToSmallCap. No pair has it. The evidence is a sample and its print PDF. In the PDF, words set in a style with code 3 that start with a capital letter show that capital at the height of the letter after it, about two thirds of the height of word-initial capitals in ordinary text. Heights were measured on the rendered pages. So code 3 sets capital letters as small capitals too. Of the values in the IDML schema (Normal,SmallCaps,AllCaps,CapToSmallCap,LowerCase), onlyCapToSmallCapdoes that.
The converter leaves out other codes.
Drop caps (0x1B0D, 0x1B0E). In every pair, the root style
[No paragraph style] has 0 for both and IDML writes
DropCapCharacters="0" and DropCapLines="0". One pair (InDesign 20.2,
IDML from the same version) also has a style with 0x1B0D = 1 and
0x1B0E = 3; its IDML has DropCapCharacters="1" and DropCapLines="3".
The different values tell the two attributes apart.
Letter spacing (0x1B31, 0x1B32). In every pair both are 0 in the root
style, as are MaximumLetterSpacing and MinimumLetterSpacing in the
IDML. That does not tell them apart from other attributes that are 0
there. The rest of the evidence is a sample and its print PDF:
- A paragraph style of the sample sets 0x1B31 to a positive fraction and 0x1B32 to a negative one. The style sets no tracking, and its other unidentified attributes are not fractions.
- In the PDF, justified lines in that style have a character spacing
(
Tcoperator) that changes from line to line, both positive and negative. So the style lets letter spacing vary in both directions, which needs a negative minimum and a positive maximum. - The values are stored as fractions, like word spacing (0x1B2E, 0x1B2F), so they are written ×100. The positive one is the maximum.
A layout of the converted sample with these two attributes reproduces noticeably more of the PDF's line breaks than one without them.
Ruby (0x422D, 0x422E). IDML writes neither attribute on the root style. In every pair the root style stores 0 for 0x422D and a 4-byte 0 for 0x422E. The first evidence was a sample typeset vertically and its print PDF:
- Character runs of the sample set 0x422D to 1 together with 0x422E,
whose value is a u32 length in characters followed by text segments
(as story text,
objects.md). The text is a short reading of the run's characters. - In the PDF, each such text appears in small type in a narrow column right beside the run's characters and centred on them, as ruby is set beside vertical text.
- The converter decodes the value of 0x422E by this layout, whatever its length.
The converter writes RubyString and writes RubyFlag with the stored
number (1 in every such run; the schema type is an integer). Pairs
with ruby were added later: in the corpus of 2026-10 the converter
reproduces RubyFlag and RubyString in 185 of 185 IDML ruby ranges
(15 distinct documents). Per-character ruby stores the readings of the
base characters separated by U+3000, and IDML writes the same string.
The other ruby settings are in "Ruby, kenten and warichu" below.
Tatechuyoko (0x425E). Every public style that stores it has 0,
and IDML writes Tatechuyoko="false" on all 240 root paragraph styles
of the corpus IDML files; no public range has the attribute. The
evidence for 1 is a sample typeset vertically and its print PDF:
- Runs of a few Latin characters (letters or punctuation) set 0x425E to 1. Elsewhere in the same vertical stories, Latin text without it is drawn turned sideways: the PDF text matrix is a quarter turn, and the letters follow each other down the column.
- The glyphs of each run with 1 are drawn upright (identity text matrix), side by side on one baseline, and the group is centred on the column's centre line to 0.01 pt. That is horizontal-in-vertical setting.
Shatai (0x4278 to 0x427B). In every public file the root paragraph
style stores 0x4278 = 0, 0x4279 = 45, 0x427A = 1 and 0x427B = 0, and
IDML writes ShataiMagnification="0", ShataiDegreeAngle="4500",
ShataiAdjustTsume="true" and ShataiAdjustRotation="false" on all 240
root styles; no other public style or range sets them. Only 45 and 4500
are not 0 or a boolean, so 0x4279 is the angle, written ×100. The rest
of the evidence is a sample typeset vertically and its print PDF:
- Runs set 0x4278 = 20, 0x4279 = 60 and 0x427A = 0. Their glyphs have the text matrix (0.850, 0.0866, 0.0866, 0.950) × point size. That matrix scales by 1 along the direction at 60° and by 0.80 across it: a distortion of 20 % at 60°. So 0x4278 is the magnification in percent and 0x4279 the angle in degrees.
- A character style sets 0x4278 = 10, 0x4279 = 60 and 0x427B = 1. Its
glyphs have the matrix (0.9222, 0.0843, 0, 0.9759) × point size. This
is the 10 % distortion at 60°, turned so that the glyph's vertical
axis stays vertical (the third value is 0). The runs above, with
0x427B = 0, are not turned. So 0x427B is
ShataiAdjustRotation. - That leaves 0x427A for
ShataiAdjustTsume, which also matches the root values (1 andtrue; 0x427B 0 andfalse). With 0 the glyphs keep an advance of one em; no sample has 1 outside root styles.
The converter writes the angle and the two booleans. It leaves out
ShataiMagnification: the sample stores the percentage, but the root
value 0 does not show the unit IDML uses, and the angle shows that it
need not be the stored number.
KerningValue (0x1B13). Every root paragraph style stores 1e8, and
IDML writes no KerningValue on root styles; the converter leaves 1e8
out. In one pair, 8 ranges store 0 and IDML writes KerningValue="0"
on the same 8 ranges; no other range in the pairs has the attribute. So
the field is located, but 0 does not show its scale. The scale rests on
a sample and its print PDF:
- Runs of one character set 0x1B13 to −0.1, −0.06, −0.12 and 0. In the PDF, the gap between that character and the next (start of the next glyph minus the end of the first glyph's advance width) is −0.1, −0.06, −0.12 and 0 times the point size, to 0.01 pt, once the letter spacing that every other gap in the same line shows is subtracted.
- The same letter pairs elsewhere, without the attribute, have other gaps, which come from the font's kerning. So the stored value replaces the font's kerning after that character.
- The value is in ems. The IDML schema types
KerningValueas a plain number.Tracking(0x1B0B) is also stored in ems, and IDML writes it ×1000 (thousandths of an em, from the pairs); the converter writesKerningValuethe same way. No sample shows this scale directly. - The schema allows
KerningValueon character styles and ranges, not on paragraph styles, so the converter leaves it out of paragraph styles (public samples without IDML have it there).
StartParagraph (0x1B37). In every pair the root style has 0 and
IDML writes StartParagraph="Anywhere"; no pair has another value. Code
2 rests on a sample and its print PDF:
- Every paragraph whose style has code 2 is the first text on its page in the PDF, and the page before it often ends with room for more lines. Those styles set no other attribute that is unidentified.
- Such paragraphs start on both odd and even pages, so code 2 is not
NextOddPageorNextEvenPage. - In the sample,
NextColumn,NextFrameandNextPagewould give the same layout, so the PDF does not tell them apart. The converter writesNextPage.
Later samples show the other codes in pairs: 1 NextColumn (1 style),
3 NextFrame (1 run) and 4 NextOddPage (1 style), with no run or
style that contradicts them.
The new codes of the table were found by aligning INDD runs with IDML
ranges at the same offset over 17,914 trustworthy stories and styles by
name over all 654 pairs; no run or style contradicts them, and every
value converted with a new code equals the IDML. (KerningMethod 79875
is $ID/Manual in IDML for 19 runs of 3 documents; that is not
decoded.)
Percentages. IDML writes a fraction attribute (HorizontalScale,
VerticalScale, AutoLeading, the word and letter spacing and glyph
scaling attributes, RubyXScale, KentenXScale) as the stored f64
times 100 with every digit of the product, binary noise included:
112.99999999999999 for a stored 1.13. Over the paragraph and character
styles and story ranges of the trustworthy pairs, 24,055 reference
values of these attributes have more than 9 decimals; the full product
gives 23,910 of them exactly (rounding to 9 decimals gave none), and
the 140,887 exact matches among the 142,524 shorter values stay the
same.
More paragraph and character attributes
Found by aligning styles by name over all pairs and runs with IDML ranges at the same offset (17,914 trustworthy stories). On styles other than the root styles, each ID is present exactly when the IDML style has the attribute, and every value matches. "Styles" counts the styles that have both, other than the root styles in brackets.
Encodings: bool = u16, 1 true; pct = f64 fraction, written × 100; num
= f64 or u32 as is; swatch = u32 swatch UID, 0 = Text Color; stroke
type = 8 bytes, u32 0 (a built-in style) then the stroke style code
(StrokeStyle/$ID/ and the name of the code, as for page items). A code
not listed leaves the attribute out.
| ID | IDML | Encoding | Styles |
|---|---|---|---|
| 0x1B14 | HyphenateLadderLimit |
num | 780 (285) |
| 0x1B68 | HyphenateLastWord |
bool | 760 (265) |
| 0x1B85 | HyphenateAcrossColumns |
bool | 751 (256) |
| 0x1B22 | HyphenateCapitalizedWords |
bool | 709 (214) |
| 0x1B34 | MaximumGlyphScaling |
pct | 709 (214) |
| 0x1B35 | MinimumGlyphScaling |
pct | 709 (214) |
| 0x1B20 | HyphenateAfterFirst |
num | 651 (156) |
| 0x1B23 | HyphenateWordsLongerThan |
num | 636 (141) |
| 0x1B39 | KeepWithNext |
num | 619 (124) |
| 0x1B2D | DesiredWordSpacing |
pct | 587 (92) |
| 0x1B21 | HyphenateBeforeLast |
num | 580 (85) |
| 0x1B30 | DesiredLetterSpacing |
pct | 559 (64) |
| 0x1B38 | KeepAllLinesTogether |
bool | 556 (61) |
| 0x1B3E | CharacterAlignment |
0 AlignBaseline, 1 AlignEmCenter, 2 AlignEmBottom |
551 (56) |
| 0x1B4C | RuleAboveColor (Properties) |
swatch | 546 (51) |
| 0x1B5C | RuleAbove |
bool | 541 (46) |
| 0x1B83 | HyphenWeight |
num | 541 (46) |
| 0x1B71 | RuleAboveType (Properties) |
stroke type | 520 (25) |
| 0x1B95 | UnderlineType (Properties) |
stroke type | 541 (46) |
| 0x1B72 | RuleBelowType (Properties) |
stroke type | 505 (10) |
| 0x1B9D | StrikeThroughType (Properties) |
stroke type | 499 (4) |
| 0x1A40B | NumberingFormat (Properties, string) |
u32: 0x1A477 1, 2, 3, 4..., 0x1A479 i, ii, iii, iv..., 0x1A47A A, B, C, D..., 0x1A47B a, b, c, d..., 0x1A497 01,02,03..., 0 None |
531 (36) |
| 0x1B73 | BalanceRaggedLines (Properties, enumeration) |
0 NoBalancing, 1 VeeShape |
528 (33) |
| 0x1A422 | NumberingAlignment |
0 LeftAlign, 2 RightAlign |
527 (32) |
| 0x1A421 | BulletsAlignment |
0 LeftAlign, 1 CenterAlign, 2 RightAlign |
505 (10) |
| 0x1B4E | RuleAboveTint |
num (−1 kept) | 526 (31) |
| 0x50F29 | ParagraphDirection |
0 LeftToRightDirection, 1 RightToLeftDirection |
526 (31) |
| 0x50F2A | ParagraphJustification |
0 DefaultJustification, 6 NaskhKashidaJustificationFrac |
495 roots (4 with 6) |
| 0x50F1F | CharacterDirection |
0 DefaultDirection, 1 LeftToRightDirection, 2 RightToLeftDirection |
518 (23) |
| 0x50F11 | DigitsType |
0 DefaultDigits, 2 HindiDigits |
499 (4) |
| 0x1A418 | NumberingLevel |
num | 525 (30) |
| 0x1A424 | BulletsTextAfter |
flagged string (as NumberingExpression) |
512 (17) |
| 0x1A41D | NumberingApplyRestartPolicy |
bool | 497 (2) |
| 0x1BB8 | StrokeAlignment |
0 CenterAlignment, 2 OutsideAlignment |
523 (28) |
| 0x4297 | LeadingModel |
0 LeadingModelRoman, 1 LeadingModelAkiBelow, 2 LeadingModelAkiAbove, 3 LeadingModelCenter |
523 (28) |
| 0x1BC1 | KeepWithPrevious |
bool | 522 (27) |
| 0x1B93 | UnderlineTint |
num | 519 (24) |
| 0x1B8E | UnderlineGapColor (Properties) |
swatch | 518 (23) |
| 0x1B77 | RuleAboveGapColor (Properties) |
swatch | 506 (11) |
| 0x1B96 | StrikeThroughColor (Properties) |
swatch | 502 (7) |
| 0x426C | Rensuuji |
bool | 518 (23) |
| 0x4295 | OTFProportionalMetrics |
bool | 516 (21) |
| 0x1B57 | RuleBelowLeftIndent |
num | 513 (18) |
| 0x1B58 | RuleBelowRightIndent |
num | 504 (9) |
| 0x1B59 | RuleBelowWidth |
1 ColumnWidth, 2 TextWidth |
507 (12) |
| 0x1B86 | KeepRuleAboveInFrame |
bool | 512 (17) |
| 0x1B6F | OTFTitling |
bool | 508 (13) |
| 0x1B6E | OTFDiscretionaryLigature |
bool | 501 (6) |
| 0x1BCA | OTFSwash |
bool | 501 (6) |
| 0x1B89 | OTFStylisticSets |
num | 501 (6) |
| 0x1B44 | OverprintFill |
bool | 506 (11) |
| 0x1B92 | UnderlineOverprint |
bool | 506 (11) |
| 0x1B8F | UnderlineGapOverprint |
bool | 500 (5) |
| 0x1B3D | StrikeThru |
bool | 505 (10) |
| 0x1B9A | StrikeThroughOffset |
num (−9999 kept) | 501 (6) |
| 0x1B9E | StrikeThroughWeight |
num (−9999 kept) | 499 (4) |
| 0x1B9C | StrikeThroughTint |
num | 497 (2) |
| 0x1B78 | RuleAboveGapTint |
num | 496 (1) |
| 0x1B4B | Skew |
num | 500 (5) |
| 0x1B65 | LastLineIndent |
num | 497 (2) |
| 0x1B81 | PositionalForm |
0 None, 1 Calculate, 2 Initial |
500 (5) |
| 0x1B87 | IgnoreEdgeAlignment |
bool | 498 (3) |
| 0x42AD | GlyphForm |
0 None, 5 MonospacedHalfWidthForm, 9 ProportionalWidthForm, 10 FullWidthForm |
501 (6) |
| 0x4222 | LeadingAki |
num (−1 kept) | 502 (7) |
| 0x4223 | TrailingAki |
num | 504 (9) |
| 0x4225 | KinsokuType |
0 KinsokuPushInFirst, 2 KinsokuPushOutOnly, 3 KinsokuPrioritizeAdjustmentAmount |
502 (7) |
| 0x4226 | KinsokuHangType |
0 None, 1 KinsokuHangRegular, 2 KinsokuHangForce |
498 (3); code 1 below |
| 0x4227 | BunriKinshi |
bool | 499 (4) |
| 0x421D | Tsume |
num | 499 (4) |
| 0x42A6 | CjkGridTracking |
bool | 497 (2) |
| 0x422C | RubyOpenTypePro |
bool | 505 (10) |
| 0x422F | RubyFontSize |
num | 500 (5) |
| 0x4248 | KentenFontSize |
num | 500 (5) |
| 0x4232 | RubyType |
0 GroupRuby, 1 PerCharacterRuby |
497 (2) |
| 0x4247 | KentenKind |
0 None, 1 KentenSesameDot, 5 KentenSmallBlackCircle |
496 (1); code 5 below |
| 0x1DF1F | MergeConsecutiveParaBorders |
bool | 347 |
| 0x1DF1A | ParagraphBorderTopLineWeight |
num | 393 (67) |
| 0x1DF1B | ParagraphBorderBottomLineWeight |
num | 395 (69) |
| 0x1DF1C | ParagraphBorderLeftLineWeight |
num | 387 (61) |
| 0x1DF1D | ParagraphBorderRightLineWeight |
num | 387 (61) |
| 0x1DF01 | ParagraphBorderLeftOffset |
num | 348 (22) |
| 0x1DF02 | ParagraphBorderRightOffset |
num | 347 (21) |
| 0x1BF7 | ParagraphBorderTint |
num | 336 (10) |
| 0x1DF16 | ParagraphBorderStrokeEndCap |
0 ButtEndCap, 1 RoundEndCap |
339 (13) |
| 0x1DF17 | ParagraphBorderWidth |
0 ColumnWidth, 1 TextWidth |
328 (2) |
| 0x1DF20 | ProviderHyphenationStyle |
0 HyphAll, 3 HyphPreferredAesthetic |
327 (1) |
| 0x1BD9 | ParagraphShadingLeftOffset |
num | 406 (26) |
| 0x1BDA | ParagraphShadingRightOffset |
num | 406 (26) |
| 0x1BD5 | ParagraphShadingWidth |
0 ColumnWidth, 1 TextWidth |
386 (6) |
| 0x1BD7 | ParagraphShadingClipToFrame |
bool | 388 (8) |
Found in the corpus of 2026-10. These IDs are in every text default list (chunk 0x23F of the preferences, 1,460 of 1,460 files, no contradiction) and in styles and runs. Counts are the converter's output over the 1,251 trustworthy pairs, all reproduced, with no extra value:
| ID | IDML | Encoding | Text defaults; styles; ranges |
|---|---|---|---|
| 0x1B3A | KeepFirstLines |
num | 1,251; 1,258 paragraph styles |
| 0x1B3B | KeepLastLines |
num | 1,251; 1,258 paragraph styles |
| 0x42C1 | AllowArbitraryHyphenation |
bool | 1,251; 1,270; 30 |
| 0x4264 | GridGyoudori |
num | 1,251; 1,323; 80 |
| 0x4268 | RotateSingleByteCharacters |
bool | 1,251; 1,277; 329 |
| 0x4261 | AutoTcy |
num | 1,251; 1,285; 241 |
| 0x42A3 | ScaleAffectsLineHeight |
bool | 1,251; 1,359 paragraph and character styles; 879 |
| 0x1BD4 | ParagraphShadingOverprint |
bool | 1,032; 1,033 |
| 0x1BFD | ParagraphBorderType (Properties) |
stroke type | 918; 919 |
| 0x4233 | RubyFont (Properties) |
u32 font family UID; 0 is $ID/ (as BulletsFont) |
1,251; 1,255; 23 |
| 0x4257 | KentenFillColor (Properties) |
swatch | 1,251; 1,262; 23 |
KeepFirstLines and KeepLastLines are equal in every list (2 in all
but one file, 1 in that one), also in every paragraph style that has
them, so which ID is which is assumed from their order. 0x1BD4 is told
from 0x1BD8 by one document whose shading is overprinted (0x1BD4 1,
0x1BD8 0). 0x4233 and 0x4257 are told apart in the one document that
sets them by the class of the stored UID: a font family (class 0x3E03)
and a colour. ParagraphBorderType uses the stroke type codes of page
items: 0x5A29 Solid in 1,042 files, 0x5A3F Japanese Dots in one.
0x1BD4 and 0x1BFD are absent exactly where IDML has no attribute.
MergeConsecutiveParaBorders is in IDML from version 13.1 (in none of
the 3 trustworthy pairs of version 13.0, in all 46 of 13.1); the
converter writes it when the header or the last session of the save
history is 13.1 or later (objects.md, save history).
Evidence over the converter's output (trustworthy pairs): 121,196
values of these attributes in paragraph and character styles, text
defaults and text ranges; 120,409 reproduced, 3 wrong (TextDefault
DesiredLetterSpacing, DesiredWordSpacing and UnderlineType in one
document each), the rest in stories whose text differs.
Ruby, kenten and warichu
These attributes are in story runs (character and paragraph runs, chunk 0x262) and in style chunk 0x23F. They were found in the corpus of 2026-10 (803 pairs, 606 trustworthy) by aligning IDML character and paragraph ranges with the INDD run at the same text offset, and styles by kind and name. The evidence:
- 24 character ranges in 4 pairs store a full block of CJK attributes
(150 to 152 attributes each), all with default values, and their IDML
ranges write every ruby, kenten and warichu attribute. Values that
occur only once in the block identify the field: 0.66 ↔ 66, 0.5 ↔ 50,
4 ↔
RubyJIS, 7 ↔Auto. - One paragraph style (a pair of version 13) sets eight ruby attributes to other values, and one ruby range (another pair of version 13) sets five others.
- 326 ranges and 9 styles in 6 pairs set
RubyAutoAlign="false"andWarichuAlignment="LeftAlign". - 205 trustworthy ranges in 13 documents have
RubyXScaleandKentenXScale, 44 haveRubyAutoScaling, and 573 ranges and styles have an empty ruby and kenten font style.
Over all these items, each ID below is present exactly when the IDML
element has the attribute, and every value matches. Encodings: bool =
u16, 1 true; pct = f64 fraction, written ×100; code = u16, by the
table; string = flag byte and in-object string.
| ID | IDML | Encoding | Values seen (items) |
|---|---|---|---|
| 0x4231 | RubyAlignment |
code: 1 RubyCenter, 2 RubyRight, 4 RubyJIS |
4: 24 ranges; 2: 1 range; 1: 1 style |
| 0x4235 | RubyParentSpacing |
code: 0 RubyParentNoAdjustment, 1 RubyParentBothSides, 2 RubyParent121Aki |
2: 24; 0: 1; 1: 1 |
| 0x423C | RubyParentOverhangAmount |
code: 0 None, 1 RubyOverhangOneRuby, 5 RubyOverhangNoLimit |
1: 24; 5: 1; 0: 1 |
| 0x423A | RubyPosition |
code: 0 AboveRight, 1 BelowLeft |
0: 24; 1: 1 |
| 0x4239 | RubyYOffset |
f64, points | 0: 24; −1.4173228: 1 |
| 0x423F | RubyParentScalingPercent |
pct | 0.66: 24; 0.4: 1 |
| 0x423E | RubyAutoScaling |
bool | true: 21 ranges and 1 style; false: 24 |
| 0x423B | RubyAutoAlign |
bool | false: 326 ranges and 9 styles; true: 24 |
| 0x42B1 | RubyAutoTcyDigits |
u16 number | 0: 24; 2: 3 styles; 5: 1 |
| 0x42B2 | RubyAutoTcyIncludeRoman |
bool | false: 24; true: 1 |
| 0x4236 | RubyXScale |
pct | 222 ranges and 1 style, 80.9 to 113.1 |
| 0x424C | KentenXScale |
pct | the same items; always equal to 0x4236 |
| 0x4234 | RubyFontStyle (Properties) |
string; empty = enumeration Nothing |
512 ranges and 61 styles, all empty |
| 0x424B | KentenFontStyle (Properties) |
as 0x4234 | the same items |
| 0x4281 | WarichuAlignment |
code: 0 LeftAlign, 7 Auto |
0: 326 ranges and 9 styles; 7: 24 |
| 0x427D | Warichu |
bool | false: 24 ranges; true: print PDF, below |
| 0x427E | WarichuLines |
u16 number | 2: 24; see below |
| 0x427F | WarichuSize |
pct | 0.5 ↔ 50: 24; print PDF, below |
| 0x4280 | WarichuLineSpacing |
f64, points | 0: 24; print PDF, below |
KentenKind (0x4247) code 5 is KentenSmallBlackCircle (1 range).
KinsokuHangType (0x4226) code 1 is KinsokuHangRegular: 31 styles and
120 ranges over all pairs (5 styles, 8 paragraph ranges and 6 story
ranges in trustworthy pairs), and no other value goes with code 1.
How IDs with equal values were told apart.
RubyAutoAlignandWarichuAlignmentare always present together, with (1, 7) for (true,Auto) and (0, 0) for (false,LeftAlign). 0x423B has value type 0x1B03, which 17 attributes use (booleans andRubyType), and over all styles the values of that type are 0 or 1 (9,186 of 9,186). 0x4281 has its own value type and holds 7. So 0x423B is the boolean.RubyYOffset,RubyPositionandRubyParentScalingPercentare in the same 25 items. The style's values −1.4173 (f64), 1 (u16) and 0.4 (fraction) fit only one attribute each.RubyAlignment,RubyParentSpacing,RubyParentOverhangAmount,RubyAutoTcyDigitsandRubyAutoTcyIncludeRoman: the range sets (2, 0, 5, 5, 1) and the style (1, 1, 0, none, none). 0x423C and 0x42B1 are both 5 in the range; the 24 default ranges (1 ↔RubyOverhangOneRuby, 0 ↔RubyAutoTcyDigits="0") and the style (0x423C = 0 ↔None, no 0x42B1) separate them.- Ruby or kenten for 0x4234/0x424B and 0x4236/0x424C: the two values are
equal in every pair item. The ruby strand (
objects.md) decides it: its records hold only ruby attributes, including 0x4234 (5,145 runs) and 0x4236 (5,297 runs), and never 0x424B, 0x424C or a kenten ID (0x4247, 0x4248). So 0x4234 and 0x4236 are the ruby attributes.
Values without an IDML pair. 0x423C = 2 (6 styles), 0x4281 = 2 (5
styles), 0x423F = 0.75 (5 runs) and non-empty font styles (Regular in
104 runs) occur only in files without IDML. The converter leaves them
out.
Warichu. No pair has warichu switched on. The evidence for
Warichu, WarichuSize and WarichuLineSpacing is a third-party
sample typeset vertically (version 21, no IDML) and its print PDF:
- A run of 7 characters sets only 0x427D = 1. In the PDF the paragraph is 8.504 pt and the run is set at 4.252 pt (50 %) in two rows of 3 and 4 characters, with baselines 4.252 pt apart (row pitch = size + 0), between full-size characters. The PDFs of three saved revisions show the same.
- A run of 36 characters sets 0x427D = 1, 0x427F = 0.6, 0x4280 = 0.708661, 0x4281 = 0, and 0x428E = 0x428F = 1. In the PDF the paragraph is 6.378 pt and the run is 3.827 pt (0.600 × 6.378) in two rows that start at the same position, with baselines 4.535 pt apart (3.827 + 0.708), and it continues on the next line in two rows again.
So 0x427D switches warichu on, 0x427F is the size as a fraction of the
point size, and 0x4280 is the extra space between the rows in points.
Both runs have two rows, the second with 0x428E and 0x428F set to 1, and
the root style stores 0x427E = 2. So neither 0x428E nor 0x428F is the
number of rows. 0x427E is WarichuLines: value type 0x1B10 is used
only by 0x427E, 0x428E and 0x428F, and 0x427E is the remaining one.
Not mapped. The 24 default ranges also hold IDs for the ruby and kenten fonts, colours, tints, overprint, weights, Y scales and offsets, kenten placement and characters, and two warichu IDs (0x428E, 0x428F; 2 and 2 in every IDML range, so their order is not known). Each holds the default value in every pair, and several IDs hold the same value, so none of them can be told apart. The converter does not write them.
Root styles and text defaults
The root paragraph style [No paragraph style] and the document's text
defaults (TextDefault in Resources/Preferences.xml) take their
values from attribute lists like other styles, but IDML leaves some of
them out. Over the 489 trustworthy pairs (measurement.md):
| Value | IDML |
|---|---|
NextStyle of the root paragraph style |
never (0 of 489) |
AllNestedStyles of the root paragraph style |
never (0 of 489) |
AllNestedStyles of TextDefault |
only when the list has items: absent in 485, written in the 4 with items |
AllGREPStyles and AllLineStyles of the root paragraph style |
never (0 of 1,251 trustworthy pairs after 2026-10); the root style stores a count of 0 in all 1,251 |
AllGREPStyles of TextDefault |
only when the list has items (48 of 48 such lists written, 1,251 trustworthy pairs) |
Empty TabList of the root paragraph style |
DOM 8 on: 482 of 482; DOM 7: 0 of 7 |
TabList of TextDefault |
DOM 8 on: in 482 of 482 (459 empty); DOM 7: 0 of 7 |
The converter leaves out these values accordingly; it writes a
non-empty TabList in any version.
Paragraph borders and shading: corners and origins
| ID | IDML | Styles with both (other than the root) |
|---|---|---|
| 0x1DF12 | ParagraphShadingTopLeftCornerRadius |
452 (126) |
| 0x1DF14 | ParagraphShadingBottomLeftCornerRadius |
452 (126) |
On every style other than the root the ID is present exactly when the IDML style has the attribute, and every value matches. The two are told apart by 8 styles (4.5 against 0).
Tied groups. The IDs of each group below have the same value in every style, so which ID belongs to which attribute is not known. The converter writes a group only when all its IDs are present and equal:
| IDs | IDML | Styles |
|---|---|---|
| 0x1DF0A–0x1DF0D | the four ParagraphBorder…CornerRadius |
446 (120) |
| 0x1DF13, 0x1DF15 | ParagraphShadingTopRightCornerRadius, ParagraphShadingBottomRightCornerRadius |
444 (118) |
| 0x1DF0E, 0x1DF10 | ParagraphShadingTopLeftCornerOption, ParagraphShadingBottomLeftCornerOption |
339 (13) |
| 0x1DF0F, 0x1DF11 | ParagraphShadingTopRightCornerOption, ParagraphShadingBottomRightCornerOption |
331 (5) |
The shading corner option codes are 0 None, 0x5A15 RoundedCorner
and 0x5A18 BevelCorner.
Origins. The two IDs of each pair always change together; the converter writes a pair only for these combinations of codes:
| IDs | IDML | Codes → values | Styles |
|---|---|---|---|
| 0x1BDD, 0x1BDE | ParagraphShadingTopOrigin, ParagraphShadingBottomOrigin |
0, 0 → AscentTopOrigin, DescentBottomOrigin; 3, 2 → EmBoxTopOrigin, EmBoxBottomOrigin; 1, 1 → BaselineTopOrigin, BaselineBottomOrigin |
378, 14, 4 |
| 0x1DF18, 0x1DF19 | ParagraphBorderTopOrigin, ParagraphBorderBottomOrigin |
0, 0 → AscentTopOrigin, DescentBottomOrigin; 3, 2 → EmBoxTopOrigin, EmBoxBottomOrigin |
325, 13 |
Attributes whose value never varies in the corpus cannot be located this
way. The converter writes the root styles' values for them from IDML
observation (idml-values.md); styles and ranges inherit them. These include
KeepFirstLines, KeepLastLines, KeepAllLinesTogether,
KeepWithNext, KeepWithPrevious, Skew, StrikeThru,
LastLineIndent, RuleAbove, RuleAboveColor, the RuleBelow indents
and width, and the hyphenation and word-spacing settings other than those
in the table. Some attributes vary but cannot be told apart from another
attribute, because both always have the same value or appear in the same
styles:
- left and right shading offsets, left and right border offsets, and the four border line weights (equal in every sample);
KeepRuleAboveInFrameandRuleAboveType(always set together, with other attributes, in one pair);TreatIdeographicSpaceAsSpaceandDiacriticPosition.
OTFFigureStyle code 3 occurs only in a sample without IDML; the
converter leaves it out.
ParagraphBreakType (0x1B6A) codes. The codes are those of
StartParagraph. The evidence is the 112 pairs of the corpus of 2026-10
whose IDML has a CharacterStyleRange with a value other than
Anywhere (no paragraph range has one). In each story the runs with a
code other than 0 were aligned in order with those ranges; every story
of these pairs aligns:
| Code | IDML value | Trustworthy pairs | Stale pairs |
|---|---|---|---|
| 1 | NextColumn |
642 ranges in 74 documents | 80 in 11 |
| 2 | NextPage |
159 in 19 | 16 in 8 |
| 3 | NextFrame |
76 in 19 | 0 |
| 4 | NextOddPage |
5 in 1 (version 20.1) | 0 |
NextEvenPage occurs in no IDML. Its code is not known, and the
converter leaves other codes out.
Empty font styles. A list can store an empty FontStyle (0x1B02).
IDML then writes the style of a font of the list's AppliedFont family:
the font whose style is Regular, or the family's first font if none
is. Over the 1,251 trustworthy pairs, writing the stored empty string
gave 294 wrong FontStyle values (ParagraphStyle 69, CharacterStyle 35,
TextDefault 11, text ranges 179); with this rule 243 of them match and
no value that matched before changes. 20 of the 243 come from the
first-font case (a family of Light and LightItalic, IDML Light).
So every empty value that IDML also writes empty is in a list without
an AppliedFont, or in a family without a Regular font whose first
font has an empty style. Not explained: 22 empty values that IDML writes as
Nothing, and lists without an AppliedFont, which keep the empty
string.
Font family names. AppliedFont and BulletsFont name a font family
(class 0x3E03), and IDML writes the family's name. An AppliedFont
whose family stands for a composite font is written as a reference to
the composite font, except in character styles. See fonts.md,
composite fonts as applied fonts.