Files
indd-utils/docs/format/objects.md
T

79 KiB
Raw Blame History

INDD objects

How the byte stream of a database object (see database.md) is structured, and what the classes and chunks used by the converter mean. Implemented in src/object.rs and src/model/.

How this was learned

IDML exported by InDesign names most objects Self="u<hex>", and that hex number is the object's UID in the INDD file. So each corpus pair gives, for every such IDML element, the INDD object, its class, and the attribute values its chunks must encode. Facts below were found by comparing the two, and are checked by tools/compare.py, which converts every pair (78 unique pairs, InDesign 7.5–21) and compares the output with the reference IDML attribute by attribute.

Chunks

Most objects (99.9 % of 773,753 in the little-endian corpus) are a sequence of chunks:

Size Field
4 Chunk ID
4 Data length n
n Data

The rest are plain byte streams: objects of class 0x129 (raw data, below) and the XMP packet (UID 0x80000001). In the 245 distinct little-endian files, all 1,171 class 0x129 objects are plain byte streams. Chunk IDs are in the same number space as class IDs; a chunk often lists objects of the class with the same number (for example chunk 0x501 of the document lists spreads, class 0x501).

Primitive encodings

Object data is in the byte order of the header's flag (header.md). All samples except two are little-endian, and the examples here are little-endian. Big-endian data and the layouts of InDesign 3.0 and 4.0 are in big-endian.md.

  • UID lists: u32 count, then that many u32 UIDs.
  • Matrices: six f64, in IDML ItemTransform order (a b c d tx ty).
  • Text segments: a u16 header, flags in bits 14–15 and a count in bits 0–13. 0x4000: count single-byte characters follow. 0x8000: count UTF-16 code units follow. A text of n code units is a sequence of segments adding up to n. Example: "WOMEN’S\r" is 05 40 "WOMEN" 01 80 19 20 02 40 "S\r".
  • In-object strings: u8 2, u8 (usually 0, meaning unknown), u16 length in code units, then segments. 4,135 occurrences in three sample files. In files from InDesign 2.0 the first byte is 1: in the four distinct 2.0 files, the pattern tag, 0, length n, 0, segment header 0x4000 + n occurs 154 to 353 times per file with tag 1 and never with tag 2. In the 83 distinct 3.0, 4.0 and 5.0 little-endian files the same pattern has tag 2 (76 to 4,296 times per file); tag 1 matches once in each of two of them.

Document (class 0xE01, always UID 1)

Chunk Contents
0x501 UID list: spreads, in order
0x1401 UID list: master spreads
0x301 UID list: layers (the first is an internal layer that holds pages)
0x313 u32: active layer (IDML ActiveLayer)
0x222 Two UID lists: the stories, then the XML backing story; IDML StoryList is both (xml.md)
0x4C01 UID list: sections
0xA443 Document users: u32 count, then per user a flag byte, the name as an in-object string, u32 colour

Document users. IDML lists one DocumentUser per user in chunk 0xA443, Self being dDocumentUser and the index in hexadecimal (491 of 495 trustworthy pairs have as many users as the chunk; the other 4 are DOM 7 and 16 files with one user more in the IDML). A user with flag 0 has its stored name as UserName (1,724 of 1,724). Flag 2 marks the placeholder for an unknown user, stored with a name such as Unknown User Name or the same words in the language of the computer that saved it; IDML writes $ID/Unknown User Name for 495 of the 586 such users, and the stored name for the other 91. The schema requires UserName, so the converter writes $ID/Unknown User Name for every flag 2 user. The colour UID names an interface colour, but the IDML UserColor does not follow from it (users stored with 0.6, 0.4, 0 are BrickRed in 4 files and Gold in 1), so it is left out of the conversion and of the measurement (measurement.md).

Spreads (0x501) and master spreads (0x1401)

Chunk Contents
0x503 u32 self, u32 0, UID list of spread layers
0x56E Matrix: ItemTransform
0x1B8 u32: BindingLocation
0x1A8 u16: 0 = AllowPageShuffle="true", 1 = false
0x10833 Flattener settings (below)
0x14580 Tab orders: u32 count, then per page u32 page UID and a UID list (the page's TabOrder)
0x140D Master spreads: u16, 0 = ShowMasterItems="false"

Evidence, over the 5,129 spreads and 914 master spreads of the 495 trustworthy pairs:

  • AllowPageShuffle: 0x1A8 is 0 in 5,064 spreads, all true, and 1 in 53, all false. The 12 spreads without the chunk (in 7 documents) are all false.
  • ShowMasterItems of master spreads: 913 have no chunk 0x140D and are true; the one with the chunk (0) is false.
  • TabOrder of pages: the list for the page in its spread's chunk 0x14580 equals the IDML list for 9,367 of 9,367 pages (8 with a tab order); pages not in the chunk have an empty TabOrder.

Flattener settings. Every IDML spread has a FlattenerPreference child. Chunk 0x10833 (52 bytes) is in 20 spreads of 5 trustworthy documents, always with the same bytes: f64 0.5 at offset 8, f64 400 at offsets 20 and 28, 2 at 36 and 800 at 44. Their IDML has LineArtAndTextResolution and GradientAndMeshResolution 400 and RasterVectorBalance 50. The converter writes the f64 at 20 and 28 as the two resolutions; which is which is not known, as they are equal in every sample. Without the chunk, 5,080 spreads have 300 and 150 and 29 spreads (all spreads of 9 documents, DOM 8 to 20) have 400 and 400; the field that decides this was not found in the spread or the document preferences, so the converter leaves the two resolutions out. The other four values are the same in every IDML (idml-values.md).

Spread layers (0x301) hold the items of one document layer on one spread. Chunk 0x302: u32 document layer UID, u16 1 for the layer's guide part. Chunk 0x303: u32 spread, u32 spread, UID list of children. Pages are children of the spread layer for the internal pages layer.

Guides (0x3301)

Ruler guides are objects of class 0x3301. They are children of a spread layer (listed in its chunk 0x303), like page items, and their chunk 0x15B names the spread and the spread layer. The spread layer's document layer is IDML ItemLayer. IDML writes a guide as a Guide element inside a Page element. Chunk 0x3308 (52 bytes):

Offset Contents IDML
0 f64 position in spread coordinates: y for a horizontal guide, x for a vertical one Location (below)
8 u32 owner: a page of the spread, or the spread itself the Page element the guide is in
12 u16 orientation: 1 horizontal, 0 vertical Orientation
14 f64, 0.05 in every sample ViewThreshold="5" in every sample
22 u32, 6 in every sample GuideColor Cyan in every sample
26 u16 fit to page: 1 true, 0 false FitToPage
28 f64, not identified
36 u32, not identified (24, 25, 30 or 31)
40 u32 guide type: 0 ruler, 1 liquid GuideType (Ruler, Liquid)
44 f64, 1 in every sample

Evidence. The 137 distinct little-endian files hold 847 guides; 815 have this 52-byte record. The other 32 are in one InDesign 7.0 file with no IDML and have a 40-byte record, the first 40 bytes of the layout above; the InDesign 3.0 and 4.0 files have it too (big-endian.md). The converter reads it and leaves out GuideType. In the corpus pairs, 71 IDML guides in 33 distinct files have an INDD object with the same UID. Two more pairs have the same number of guides on both sides but different UIDs (the IDML was exported from another save) and are not used. For the 71:

  • Orientation: 71 of 71 (50 horizontal, 21 vertical).
  • FitToPage: 71 of 71 (49 true, 22 false).
  • GuideType: 71 of 71 (59 ruler, 12 liquid).
  • ItemLayer: 71 of 71.
  • Owner: the 49 guides owned by a page are in that page's element, the 22 owned by the spread are in the spread's first page (71 of 71). All 22 spread guides have FitToPage="false" and all 49 page guides FitToPage="true".
  • The view threshold and colour have one value each in the INDD and in IDML, so the fields are not proven. The converter writes ViewThreshold="5" only for 0.05 and GuideColor Cyan only for 6.

Location. IDML measures Location from the ruler origin in ViewPreference (RulerOrigin). With SpreadOrigin, it is the stored position minus the top edge (horizontal guides) or the left edge (vertical guides) of the spread's pages, each page's edge being its GeometricBounds corner mapped by its ItemTransform. This holds for 66 of 66 guides in files with SpreadOrigin, including pages whose bounds do not start at 0 and two-page spreads. One file has SpineOrigin: its vertical guides on a two-page spread are measured from the spine (x = 0) instead (2 guides), its other 3 guides agree with the rule above.

The ruler origin was not found in the INDD: 235 of the 240 corpus IDML files have SpreadOrigin, one SpineOrigin and four PageOrigin, and no field separates them in the objects searched (every class with at most 40 objects in a file, apart from page items and text). The converter writes ViewPreference with RulerOrigin="SpreadOrigin" and measures guide locations from the spread, so the two agree.

Other settings. A guide has chunks 0x2C2D (Locked) and 0x1424 (OverriddenPageItemProps) as page items do (Page item settings), and the f64 at offset 44 of the 52-byte record is GuideZone. Over the 7,003 guides of the trustworthy pairs: Locked 7,003 of 7,003 (3 locked), GuideZone 6,988 of the 6,988 with a 52-byte record (464 with 0), OverriddenPageItemProps 6,988 of 6,988; the 15 guides with a 40-byte record have neither attribute in IDML.

PageIndex counts from the spine of the spread: 0 for a guide of the spread itself; for a page guide, the pages left of the spine are −1, −2, … (counting outwards) and those right of it 1, 2, …, the spine being after BindingLocation pages; on master spreads it is at the left edge. This gives 6,998 of 7,003 (1,215 spread guides 0; 2,266 of 2,269 page guides on document spreads, 473 of them −1 and 12 −2; 3,517 of 3,519 on master spreads).

Layers (0x302)

Chunk 0x304:

Offset Contents IDML
0 u16 Locked (1 = true)
2 u16 Visible
4 u16 Printable
6 u16 LockGuides
8 u16, 1 in every sample
10 u32 UID of an interface colour LayerColor (below)
14 u16 UI
16 u16, 1 in every sample
18 u8 flag, in-object string Name
after the name u16 IgnoreWrap

The internal layer is named Internal_pages_layer_name and has no IDML element. In all 1,053 layers of the trustworthy pairs the name starts at offset 19, and each field above equals the IDML value for 1,053 of 1,053 layers (127 locked, 55 hidden, 59 not printable, 4 with locked guides, 1 without UI, 2 ignoring text wrap). ShowGuides and Expendable are true in every layer; the two fields that are 1 in every sample may hold them. The converter reads the fields only when the name starts at offset 19 (in all little-endian corpus pairs, 1,465 layers).

Pasted smooth shades (0x5533)

Objects of class 0x5533 hold shadings. Chunk 0x5531: a flag byte (1 = built-in key) and the name, then a u32. Chunk 0x5532 holds the shading; a constant shade has 92 bytes, with u32 28 (the length of what follows) at offset 60, then a u32 and three f64. IDML writes it as a PastedSmoothShade with ContentsType="ConstantShade" and Contents the base64 of the same u32 and three f64 in big-endian order (AAAAAUBv4AAA… for 1 and 255, 0, 0).

Every trustworthy pair has one constant shade in IDML, and it is the class 0x5533 object of lowest UID with a constant shade (495 of 495); in 84 pairs the INDD has two more that IDML leaves out. The converter writes that one shade, and matches the IDML on all values in 495 of 495 (name $ID/ from flag 1 and an empty name; two contents values, 255 and 1). The other shades in IDML are AxialShades whose contents re-encode a longer structure in the same way; they are not decoded.

Index sort options

Chunk 0x1307E of the preferences object (class 0x2202) holds the index groups: u32 count, then for each group its name (a flag byte and an in-object string such as kIndexGroup_Symbol or kWRIndexGroup_GreekAlphabet), u8 include, u8, u16 header variant, and further fields with the group's sections, whose letters and names repeat strings. The section records are not decoded: the converter finds each group at the first occurrence of its name (a flagged string starting with kIndexGroup_ or kWRIndexGroup_) and uses the result only when it finds as many groups as the count says.

IDML writes an IndexingSortOption per group, in the stored order: Self dIndexingSortOptionn and the name, Name $ID/ and the name, Include, Priority (the position, from 0) and HeaderType:

Group Variant HeaderType
kIndexGroup_Alphabet 0, 3, 5 BasicLatin, Spanish, Czech
kWRIndexGroup_CyrillicAlphabet 2 Russian
kIndexGroup_Kana 0 HiraganaAll
kIndexGroup_Chinese 0 ChinesePinyin
kIndexGroup_Korean 0 KoreanConsonant
Symbol, numeric, Greek, Arabic and Hebrew groups 0 Nothing

The converter leaves HeaderType out for other combinations. Evidence: the 495 trustworthy pairs have 11 different lists (8 or 10 groups, in different orders, with different groups included); the converted groups match the IDML in all 4,934 groups on every attribute. Over all 654 pairs the Alphabet variant is 0 in 652 files, 3 and 5 in one each, and the Cyrillic variant is 2 in all.

Assignments (0x1BE01)

Every document has one object of class 0x1BE01, listed in chunk 0x1BE13 of the document; IDML writes it as an Assignment with Self its UID (495 of 495 trustworthy pairs). Chunk 0x1BE1B starts with a flag byte and the name in the language the document was made in (Unassigned InCopy Content, Contenu InCopy non affecté, …), then two empty strings and fields that are the same in every pair. IDML names it $ID/UnassignedInCopy in 476 pairs and gives the stored name in 19, in files of several languages and versions, so the name follows the computer that exported the IDML; the converter leaves Name out (it is optional in the schema) and the measurement too. The other attributes are the same in every IDML (idml-values.md).

Named grids (0xCD12)

Chunk 0xCD28: u32, a flag byte (1 = built-in key) and the name ([Page Grid], IDML $ID/[Page Grid]). IDML writes a NamedGrid per object, with a GridDataInformation that holds no INDD field of its own: it equals the layout grid settings of the document pages (chunk 0xCD02, pages above) when all pages have the same, which is so in 494 of the 495 trustworthy pairs; the named grid's settings match those in 493 of the 494. The converter writes the named grid with the pages' settings when they agree, and without GridDataInformation otherwise. Over the trustworthy pairs: 494 of 496 named grids, all names.

Table of contents styles (0x11605)

Chunk 0x11605: a flag byte (1 = built-in key) and the name, three u32 (the third the UID of the title's paragraph style), a flag byte and the title, a flag byte and a string not identified, then u16 fields: at 2 NumberedParagraphs (0 IncludeFullParagraph, 2 ExcludeNumbers), at 4 MakeAnchor and at 6 RemoveForcedLineBreak (1 = true; the chunk of older files ends before the fields IDML does not have yet), then the entries. IDML writes one TOCStyle per object in Styles.xml.

A story made by a table of contents has chunk 0x8C40, the UID of an object of class 0x8C20 whose chunk 0x11613 is the TOC style; IDML writes that style as the story's AppliedTOCStyle, and n for other stories.

Evidence over the trustworthy pairs: the 511 TOC styles the converter writes match on Name, Title and TitleStyle (511 of 511), NumberedParagraphs (511, one ExcludeNumbers), MakeAnchor (445 of 445 from DOM 9 on, 4 true) and RemoveForcedLineBreak (340 of 340 from DOM 13 on, 4 true); AppliedTOCStyle matches for 18,923 of 18,923 stories (21 made by a table of contents). CreateBookmarks (false in 1 of 676 IDML styles) and IncludeBookDocuments (true in 8) were not found, and the entries (TOCStyleEntry, 130 in all corpus IDML files) are not decoded: the converter writes the styles without them.

Languages (0x2D07)

Chunk 0x2D0F: a flag byte and the name (English: USA), a flag byte and the primary name (English), a flag byte and the secondary name (USA, often empty), u16 Id, then two vendors, each a flag byte, a u32 and a string: first the spelling vendor, then the hyphenation vendor (Hunspell, Proximity, Duden, WinSoft); last the locale (en_US).

IDML lists the language objects in UID order as Language elements at the start of designmap.xml: Name, PrimaryLanguageName and SublanguageName are $ID/ and the stored names, except that the language named Neutral is $ID/[No Language] in all three. Evidence over the trustworthy pairs: in 488 of 495 the IDML list equals the INDD objects in that order; in the other 7 the INDD has 4 to 61 language objects and the IDML lists only some of them (1 or 2), for no reason found. For the 1,249 IDML languages the names and Id are equal in 1,249. HyphenationVendor is the second vendor and SpellingVendor the first when their flag is 1 (1,146 and 1,166 of 1,249); otherwise the stored string is empty or names a vendor the IDML does not show, and IDML gives $ID/, $ID/InDihyph or a vendor such as Hunspell that depends on the computer that exported it, so the converter leaves the attribute out. The quotes (SingleQuotes, DoubleQuotes) are not in the chunk; they are written from observation (idml-values.md).

Interface colours (0x1F11)

Layers, pages and XML tags name their colour by the UID of an object of class 0x1F11. Chunk 0x1F01 of that object: u32 5 (RGB), u16 3, three f64 fractions. IDML writes the colour as one of its named colours, or, for other colours, as a list of three numbers (0 to 255):

Red, green, blue IDML Red, green, blue IDML
0.31, 0.6, 1 LightBlue 1, 0.6, 0 Gold
1, 0, 0 Red 1, 0.4, 0 Orange
0.31, 1, 0.31 Green 0, 0.33, 0 DarkGreen
0, 0, 1 Blue 0.6, 0.6, 1 Lavender
1, 1, 0.31 Yellow 0.67, 0.64, 0.71 Charcoal
1, 0.31, 1 Magenta 0.6, 0.2, 1 Violet
0, 1, 1 Cyan 1, 1, 1 White
0.5, 0.5, 0.5 Gray 1, 0.6, 0.8 Pink
0, 0, 0 Black 0.61, 0.87, 0.61 GridGreen
0.6, 0, 0 BrickRed 0, 0, 0.53 DarkBlue
0.6, 0.8, 0 GrassGreen 0.81, 0.51, 0.71 Lipstick
1, 0.71, 0.42 GridOrange 0.97, 0.35, 0.42 Fiesta
0, 0.6, 0.6 Teal

Evidence: in the layers and pages of the trustworthy pairs every colour object with these components has this name (1,107 layers and pages; from 491 LightBlue down to 1 Teal). Two other colours occur, 1, 0.4863, 0.651 (3 layers) and 0.9412 three times (1 layer); IDML writes them as the lists 255, 124, 166 and 240, 240, 240, the components times 255. The converter writes such a list for a colour whose components are whole multiples of 1/255 and that is not in the table, and leaves the colour out otherwise. XML tags use the table but no list, as before.

Pages (0x50F)

Chunk Contents
0x140F u32 applied master spread, u16 (unknown), matrix MasterPageTransform
0x5CC Matrix: ItemTransform
0x5DD Four f64: left, top, right, bottom. IDML GeometricBounds is top, left, bottom, right.

Files from InDesign 3.0 and 4.0 store the page transform and bounds in chunks 0x151 and 0x154, and chunk 0x140F has no matrix (big-endian.md).

Page settings.

Chunk Contents IDML Without the chunk
0x1404 u32 count; if not 0, a UID list of master page items and a UID list of their overrides OverrideList: each item and its override (n for 0) empty
0xCD04 6 bytes, the last u16 UseMasterGrid (1 = true)
0x563 u32, u32 code: 1 Recenter, 2 ObjectBased, 3 Scale, 4 GuideBased, 5 UseMaster LayoutRule Off
0x5FF u32: 0 Nothing, 1 UseMasterColor, else an interface colour PageColor UseMasterColor

Evidence over the 9,366 pages (document and master pages) of the trustworthy pairs that the converter writes: OverrideList, UseMasterGrid and PageColor 9,366 of 9,366 each, LayoutRule 9,347 of the 9,347 pages that have it. Of the 9,367 IDML pages, 1,352 have overrides and 2,445 UseMasterGrid="false"; 5,111 have no chunk 0x563 and Off, 4,117 UseMaster, 92 ObjectBased, 24 GuideBased, 3 Recenter and 1 Scale; 9,260 have no chunk 0x5FF, 44 code 1, 5 code 0 and 58 an interface colour. LayoutRule is in IDML from DOM 8 on (no page of the DOM 7 files has it). | 0x51A | Margins: four f64 (left, top, right, bottom), u16 own-margins flag | | 0x528 | Columns: u32 count n, n f64 column edges, f64 gutter, u16 own-columns flag, 4 bytes | | 0xCD02 | Layout grid (GridDataInformation, below) |

Margins and columns. IDML writes them as MarginPreference. The column edges are ColumnsPositions (left and right edge of each column, so ColumnCount is n/2), the gutter is ColumnGutter. A flag of 1 means the page has its own values. With 0, or without the chunk, the page shows the values in effect on its master page: the page at the same position, counted from the left by ItemTransform, in the applied master spread, or that spread's only page. That master page can itself take them from its own master. The stored values of such a page are often stale.

Evidence: all 325 IDML pages of the same-version pairs that have an INDD page with the same UID (document and master pages):

  • Margins: 156 pages with flag 1 match their own values; 169 take them from a master page (146 directly, 23 through two or three masters) and match. 325 of 325. Without the rule, 72 pages with flag 0 differ.
  • Columns, gutter and positions: 156 with flag 1, 169 from a master page, 325 of 325. Without the rule, 83 differ.
  • The order of the margins: the four values differ in many pages (for example 56.69, 42.52, 56.69, 56.69 with IDML Top="42.51968503937008").

In the 250 distinct little-endian files, 2,246 pages hold 0x51A in 2,160 (34 bytes each, flag 0 or 1) and 0x528 in 2,211 (always 18 bytes after the positions). The two bytes after the flag of 0x528 are 1 in 26 pages and 0 elsewhere; they are not identified.

ColumnDirection has no identified field: all 832 MarginPreference elements of the 240 corpus IDML files say Horizontal. The converter writes that value (idml-values.md).

Layout grid (chunk 0xCD02). u32 font family UID, a flag byte, the font style as an in-object string, five f64, four u32. IDML writes GridDataInformation:

Field IDML Evidence
Font family AppliedFont (Properties, the family name) 283 of 325 (below)
Font style FontStyle 325 of 325 (Regular, Roman)
f64 1 to 5 PointSize, CharacterAki, LineAki, HorizontalScale (×100), VerticalScale (×100) see below
u32 1 to 4 LineAlignment, GridAlignment, CharacterAlignment; one not identified see below

The numbers are 12, 0, 9, 1, 1 and the codes 3, 0, 3, 1 in all 2,246 pages of the 250 distinct little-endian files, and all 832 GridDataInformation elements of the corpus IDML files have PointSize="12", CharacterAki="0", LineAki="9", scales of 100, LineAlignment="LeftOrTopLineJustify" and AlignEmCenter for both alignments. The numbers 12 and 9 occur once, so those fields are located; the others are not proven. The converter writes each number only when it is the observed value, and the three alignments only when the codes are 3, 0, 3, 1. The other 42 pages are in one pair whose IDML names the family Minion Pro (OTF) where the INDD family name is Minion Pro; its FontFamily element has the same difference (fonts.md).

Applied master of a master page. Pages of master spreads use the same chunk 0x140F. When it is absent or names UID 0, IDML writes AppliedMaster="n" and MasterPageTransform="1 0 0 1 0 0" (220 of 220 master pages in the corpus pairs; 2 of them have the chunk with UID 0 and an identity matrix). In 147 master pages of 73 distinct INDD files without an IDML, chunk 0x140F names another master spread of the same document, never the page's own spread. No pair shows the IDML for this case; the converter writes it as AppliedMaster, as for document pages.

Page items

Frames, shapes and lines are all class 0x6201; groups are 0x401.

Chunk Contents
0x151 Matrix: ItemTransform
0x162B Path geometry (below)
0x15B Hierarchy: u32 spread, u32 parent, UID list of children
0x6E03 Attribute list: local formatting (see attributes.md)
0x1B916 u32: applied object style

Path geometry: u32 path count; per path: u32 point count, points, u16 1 if the path is open. Each point is a u32 type, then f64 values: type 2 = anchor (x, y) only; types 0 and 1 = left direction, anchor, right direction. All 3,191 path chunks in the samples parse exactly, and the points of every page item path match the IDML PathPointType values.

IDML element type. A frame is a TextFrame if a child of class 0x263 exists. Otherwise chunk 0x6204 (u16, then u32) gives a shape code: 1 GraphicLine, 2 or 3 Rectangle, 4 or 5 Oval, 0 and 6 to 8 Polygon; code 9 means none. With code 9 or without the chunk the converter uses the path: two points and open → GraphicLine; four corner points on two distinct x and y values → Rectangle; four points with direction points, all of point type 0 → Oval; anything else → Polygon. Path points of type 1 have direction points too, and a closed four-point path with one or more of them is a Polygon in IDML (1,672 shapes in the trustworthy pairs).

Evidence over the 62,908 rectangles, ovals, polygons and lines of the trustworthy pairs: the code gives the IDML element for 22,579 of 22,587 shapes that have one (7 polygons have code 2 or 3, 1 rectangle code 4); the path for 40,070 of 40,321 without one. Most of the others (215) are polygons whose four points of type 0 form an ellipse, as ovals do.

Text frames: the frame's child of class 0x263 (multi-column frame) has a child of class 0x227 (frame column). Chunk 0x220 of the column holds the frame list (class 0x228). Its chunk 0x205: u32 story, then a UID list of the columns of all threaded frames in order, which gives PreviousTextFrame and NextTextFrame.

Page item settings

Every page item element in IDML (TextFrame, Rectangle, Oval, Polygon, GraphicLine, Group) has the attributes below. Each is stored in a chunk of the item (class 0x6201 or 0x401), or in its attribute list (chunk 0x6E03, attributes.md); without the chunk the IDML value is the default in the table.

Chunk Contents IDML Without the chunk
0x2C10 (groups: 0x418) u8 1 if a built-in key, then an in-object string Name: the string, or $ID/ and the key $ID/
0x2C32 u16, 0 = hidden Visible true
0x2C2D u32, 1 = locked Locked false
0x21D4E u32 count n, n pairs of u32 ParentInterfaceChangeCount: the numbers empty
0x21D50 same TargetInterfaceChangeCount empty
0x21D53 same LastUpdatedInterfaceChangeCount empty
0x1424 u32 master page item, UID list OverriddenPageItemProps: the list in decimal; empty if the master item is 0 empty
0x22228 u8 flags HorizontalLayoutConstraints (bits 4–6), VerticalLayoutConstraints (bits 0–2): per bit FixedDimension if set, else FlexibleDimension as 0x22
Attribute IDML Without the attribute
0x5520, 0x551F, 0x551E GradientFillStart, GradientFillLength, GradientFillAngle 0 0, 0, 0
0x5526, 0x5525, 0x5524 GradientStrokeStart, GradientStrokeLength, GradientStrokeAngle same
0x5522, 0x5523 GradientFillHiliteLength, GradientFillHiliteAngle 0
0x5528, 0x5529 GradientStrokeHiliteLength, GradientStrokeHiliteAngle 0

Rules the IDML follows, over the 92,409 page item elements of the 495 trustworthy pairs:

  • Locked is on the 36,817 items that are children of a spread or anchored in text, and on none of the 55,592 items inside a group or another page item.
  • The change counts, OverriddenPageItemProps and the layout constraints are in IDML from DOM 8 on: every page item of the distinct corpus IDML files from DOM 8 on has them, none of the DOM 7 files does (145 text frames, 335 rectangles, 61 groups).
  • A group has no gradient attributes of its own (no group in the pairs has 0x551E to 0x5529). IDML gives it, for each gradient attribute, the value all its child items have, and leaves the attribute out when they differ: 58,068 of the 58,080 gradient values of the 5,808 groups.

Evidence: the INDD values, decoded as above, against the IDML of the same item, over the page items of the trustworthy pairs that have an INDD object:

IDML attribute Equal
Name 92,264 of 92,402
Visible 92,402 of 92,402
Locked 36,810 of 36,810
The three change counts and OverriddenPageItemProps 91,812 of 91,812 each
Both layout constraints 91,812 of 91,812 each
Gradient start and length, fill and stroke (four attributes), items other than groups 86,594 of 86,594 each
Gradient angles and highlights (six attributes) all, 92,396 to 92,402 per attribute (groups by the rule above)

The 138 names that differ belong to groups that are states of a button (their parent has class 0x1450D); they have no name chunk, and IDML names them $ID/$$$/StateType/.... The converter does not write such groups.

Values other than the default: 206 items with a name given by the user, 176 hidden, 1,241 with change counts, 1,113 with overridden properties. Flags 0x22 are in 66,820 items, 0x55 (FixedDimension FlexibleDimension FixedDimension both ways) in 643 and 0x02 (FlexibleDimension three times horizontally) in 13; with another bit set the converter leaves both attributes out. In 14,918 items with chunk 0x1424 the master item is 0; in 197 of them the list still holds IDs, and IDML writes the attribute empty.

Text wrap

Page items (class 0x6201 and groups, 0x401) and placed graphics have chunk 0x3703 (44 bytes):

Offset Contents
0 u32 wrap mode: 0 None, 1 JumpObjectTextWrap, 3 BoundingBoxTextWrap, 6 Contour
4 u32 UID of the wrap path object (class 0x3702), or 0
8 Four f64 offsets: left, top, right, bottom (IDML TextWrapOffset)
40 u32, not fully identified; 1 in all but one element of the pairs

The wrap path object holds the contour as path geometry (chunk 0x162B, as for page items) and names the item in chunk 0x3709.

Placed graphics also have chunk 0x373D. Its first u32 is the contour type: 5 = SameAsClipping.

Evidence from the pairs. For every element with a Self in the corpus pairs, the IDML TextWrapPreference was compared with chunk 0x3703 of the INDD object with that UID. Same-version pairs first, then the pairs whose IDML is from an older version:

INDD IDML Same version Older IDML
Mode 0 TextWrapMode="None" 2,625 of 2,625 615 of 615
No chunk 0x3703 TextWrapMode="None" 1,468 of 1,468 873 of 873
Mode 1 TextWrapMode="JumpObjectTextWrap" 2 of 2 (one file) 1, matched by geometry (below)
Mode 3 TextWrapMode="BoundingBoxTextWrap" 1 of 1 (an image) none
Mode 6 TextWrapMode="Contour" 3 of 3 (one file) 1 of 1 (an image)
Offsets as left, top, right, bottom TextWrapOffset 2,631 of 2,631 616 of 616
u32 at 40 = 1 Inverse="false", ApplyToMasterPageOnly="false", TextWrapSide="BothSides" 2,630 of 2,630 616 of 616
0x373D type 5 ContourType="SameAsClipping" 224 of 225 (1 has no ContourOption) 75 of 75

Order of the offsets. Most offsets in the pairs are 0, so the order rests on a few elements:

  • Offset 24 (third) is Right: the bounding-box image has 2.83 there and 0 elsewhere; its IDML has Right="2.834645669291339" and 0 for the other sides.
  • Offset 32 (fourth) is Bottom: both jump-object frames have 14.17 there and 0 elsewhere; their IDML has Bottom="14.173228346456694" and 0 for the other sides.
  • Offset 16 (second) is Top. In a pair whose IDML is from an older version (IDML 17.0, INDD 18.1), the INDD has one jump-object frame with 11.34 at offset 16 and 5.67 at offset 32. Its UID differs from the IDML element's, but its path and ItemTransform are identical to those of the IDML's only jump-object frame, which has Top="11.338582677165356" and Bottom="5.669291338582678". A sample and its print PDF agree; see below.
  • Offset 8 (first) is therefore Left. It is 0 in every sample that has a reference.
  • The two contour frames have the same value at all four offsets, as in their IDML.

Evidence from a sample and its print PDF. The sample has frames with mode 1. Offset 8 is 0 in all of them; offset 16 is 0, negative or positive. With jump-object wrap, no text is set beside a frame, and text above the frame must end above the top of the wrap area. Text line positions in the PDF were taken from pdftotext word boxes and compared with the frame bounds:

  • Where offset 16 is 0, the body line above a frame ends at most 1.5 pt below the frame's top edge.
  • Where offset 16 is negative, the body line above may end inside the frame, never further below its top edge than the offset's size plus 1.5 pt. Where the next line position would end further down than that, it is left empty.
  • A line that lies wholly between a frame's top and bottom edges falls inside the band that a large negative offset opens.

So the value at offset 16 moves the top edge of the wrap area, and a negative value lets text into the frame from above.

Other values. One image in the same-version pairs has 0x40001 at offset 40 and TextWrapSide="SideAwayFromSpine"; no other value is shown, so the converter writes the side and inverse settings only when the u32 at 40 is 1. Modes other than 0, 1, 3 and 6 have no IDML evidence; the converter leaves out TextWrapPreference for them.

Frame fitting

The frame fitting settings are attributes in the page item attribute list (chunk 0x6E03, attributes.md). Object styles hold all of them in chunk 0x1B956 (a u16 count, then records of the same layout).

ID IDML FrameFittingOption attribute Encoding
0x6E83 AutoFit u32, 0 in every sample (false)
0x6E7E LeftCrop f64
0x6E7F TopCrop f64
0x6E80 RightCrop f64
0x6E81 BottomCrop f64
0x6E7C FittingOnEmptyFrame u32: 0 None, 1 ContentToFrame, 2 Proportionally, 3 FillProportionally
0x6E7D FittingAlignment u32: 0 TopLeftAnchor, 4 CenterAnchor

Evidence, from the same-version pairs:

  • Object styles. All 337 object styles paired by name hold all seven IDs in chunk 0x1B956, and all seven match the style's IDML FrameFittingOption in 337 of 337 (FittingAlignment 4 in 313 styles, 0 in 24).
  • Crops. Each crop ID is told apart by non-zero values: wherever IDML writes the attribute, the frame's own value, or its style's if the frame has none, matches: left 429, top 397, right 433, bottom 451, no mismatch. Non-zero values: left 235, top 204, right 239, bottom 258.
  • Fitting on an empty frame. 301 of 301; codes 0, 1, 2 and 3 occur (1,154, 9, 77 and 16 values).
  • Alignment. 200 of 205. The other 5 are frames in one file with the style [None], no local value and a style value of 0, where IDML says CenterAnchor; not explained. Code 0 is shown in 9 frames, code 4 in object styles. Other codes are left out.
  • AutoFit. 0 and false wherever IDML writes it (200 of 200); other values are left out.

Where IDML writes it. Only on rectangles, ovals and polygons, never on text frames (1,154) or lines (136), even when their list has these attributes. Let D be the item's local attributes whose value differs from its object style's. IDML writes D if it is not empty; otherwise all seven of the style's values, unless the style is the root [None], in which case it writes no element. This gives the IDML element exactly for 1,849 of 1,864 frames (2,582 of 2,599 with the pairs whose IDML is from an older version); in the other 15, IDML writes all seven values although D is not empty. The converter follows the rule, and writes the seven values of every object style.

Clipping path settings

Images, PDF and EPS graphics may have chunk 0x2C1A (37 bytes):

Offset Contents IDML ClippingPathSettings
0 u32, 0 in every sample ClippingType="None"
4 f64 Tolerance
12 f64 InsetFrame
20 u8 Threshold
23 i16 Index
25 u8: 2 true, 0 false UseHighResolutionImage

Evidence: 75 of 235 images in the same-version pairs have the chunk, and all 75 match on these fields (tolerance 2 or 0, threshold 25 or 0). The byte at 25 changes together with the threshold and tolerance in the same 5 images, so it is identified only as the field that is left. PDF (153 of 206) and EPS (6 of 18) graphics have the chunk with the same values as images that use the defaults. Graphics without the chunk (160 images, 53 PDF, 12 EPS) have UseHighResolutionImage="true", Threshold="25", Tolerance="2", InsetFrame="0" and Index="-1" in IDML, and the converter writes those values for them. The converter leaves out the element for a type other than 0.

InvertPath="false", IncludeInsideEdges="false", RestrictToFrame="false" and AppliedPathName="$ID/" have no identified field. All 496 images, 386 PDF and 49 EPS graphics with the element in the corpus IDML files have these values, and the converter writes them (idml-values.md).

ImageIOPreference. Chunk 0x8C39 of an image, u16 at 0: ApplyPhotoshopClippingPath (1 true, 0 false); 235 of 235 images (293 of 293 with the older-version pairs, 11 of them false). AllowAutoEmbedding="true" and AlphaChannelName="$ID/" are in all 496 images of the corpus IDML files and are written from that observation.

Placed graphics

Images (0x1702), PDF (0x2501), EPS (0x6601) and SVG (0x6639) are children of a frame (in its 0x15B list) and share these chunks:

Chunk Contents
0x151 Matrix: ItemTransform (437/437 match)
0x1633 Four f64: GraphicBounds left, top, right, bottom
0x8CBC u32, u32, u32 link UID

Links (0x8C42). Chunk 0x8C9B: u32 0, u32, u32 link resource UID, u32, u32 graphic UID, fields, then the import stamp as a u32 length and text segments, then two 8-byte timestamps. Link resources (0x8C41): chunk 0x8C92 is a flag byte, u32 length, then the URI as bytes (LinkResourceURI; 335/340 match, the rest were relinked after export).

After the URI, chunk 0x8C92 continues:

Offset after the URI Field
0 u8 1, u8 1, u16 0 (all resources)
4 u32 0 or 1, not identified
8 u32 0, 2 or 3
12 u32 UID of a raw data object (class 0x129), or 0

Embedded links. A link is embedded (StoredState="Embedded") when its resource names a raw data object at offset 12. That object holds the linked file's bytes, which IDML writes as the graphic's Contents.

Evidence:

  • In the 245 distinct little-endian files there are 883 link resources. The field at offset 8 is 2 in 123 of them, and exactly those 123 name a raw data object at offset 12. The other 760 have 0 at offset 12 (742 with 0 at offset 8, 18 with 3; no pair shows what 3 means).
  • In the corpus pairs, all 10 resources of embedded links (12 links) name a raw data object, and none of the 369 resources of normal links do.
  • For all 12 embedded links, the raw data object's bytes equal the base64-decoded Contents of the IDML graphic (JPEG, PNG, PDF, EPS and SVG files, 2 KB to 11 MB).

A graphic with no link (its chunk 0x8CBC names no link) can hold its file itself:

Class Chunk Contents
Image (0x1702) 0x8C23 u32 raw data object (0 = none)
PDF (0x2501) 0x2521 u32 raw data object (0 = none)

Evidence from the corpus pairs: the raw data object equals the IDML Contents for 124 of 124 PDFs and 2 of 2 images without a link. One more image without a link has 0x8C23 = 0; its IDML Contents equals the preview data described below, which the converter does not use. In the whole corpus, two linked and embedded PDFs also have a 0x2521 object, different from the link resource's; with no pair to compare, the converter uses the link resource's.

Graphic previews

Placed graphics also have chunk 0x170D, the UID of an object of class 0x1708, whose chunk 0x119 names a raw data object. In the 245 distinct little-endian files, these objects are TIFF (613), JPEG (411), PNG (307), GIF (27) and one other. In the same-version pairs they equal the IDML Contents for only 3 of 109 embedded or pasted graphics, so they are most likely screen previews. The converter does not use them.

Embedded data in IDML

The reference IDML files write Contents inside the graphic's Properties as base64 (with = padding) in lines of 76 characters joined by a line feed, with no line feed at the end. The text is split into CDATA sections of 262,144 characters. The converter writes the same form.

Stories (0x201)

Chunk 0x223: u32 length, u16, u32 first strand, UID list of more strands, then other fields. Each strand has chunk 0x261: u16 count, then (u32 length, u32 data object UID) pairs. Each data object has chunk 0x262:

Field Contents
u32 Kind: 0x202 text, 0x203 character style runs, 0x204 paragraph style runs
u32 Owning strand
u16 Run count
runs Each: u32 record size, then the record
u32 Total length

Each record starts with a u32 run length in UTF-16 code units. Text records continue with text segments. Style records continue with the style UID.

Owned items (run kind 0x209). Each record: u32 run length, u16 count, then that many (u32 class, u32 UID) pairs, the objects owned by the text position at the start of the run. An item anchored in text has the character U+FFFC at that position and is owned through an object of class 0x262, whose chunk 0x2C8 (u32, u32, UID list) lists the anchored page item. IDML writes the page item element in place of the U+FFFC. A text variable instance (class 0xCA64) is owned by a U+0018 at its position; see text-variables.md.

Anchored object settings (chunk 0x2800). The anchor object (class 0x262) and object styles have a 62-byte chunk 0x2800:

Offset Contents IDML AnchoredObjectSetting
0 f64 AnchorYoffset
32 f64, the negative of the value at 0 in every sample
52 u16: 0 TopAlign, 1 CenterAlign, 2 BottomAlign VerticalAlignment

Evidence: 42 anchored items in the pairs (including those whose IDML is from an older version), compared with their IDML values or, where the item has none, its object style's. AnchorYoffset: 42 of 42, 11 of them non-zero in 2 files (−3.54 and −111.46). VerticalAlignment: 42 of 42; 4 items in 2 files have 0 and TopAlign, the others 2 and BottomAlign. In the 337 object styles, 312 have 2 and BottomAlign, 25 have 1 and CenterAlign, and all have 0 at offset 0 and AnchorYoffset="0". IDML writes an item's AnchoredObjectSetting with the values that differ from its object style (14 of the 42 items); the converter does the same.

Two groups of u16 fields change together in every sample, so each group is written as a whole, for the combinations observed only:

u16 at 46, 50, 56 AnchorPoint, PinPosition
0, 2, 1 BottomRightAnchor, true
2, 0, 0 TopLeftAnchor, false
u16 at 40, 48 AnchoredPosition, HorizontalAlignment
0, 2 InlinePosition, LeftAlign
2, 1 AboveLine, CenterAlign

Evidence: 2,858 object styles in the 654 pairs whose IDML style has the same name (2,628 and 230 for the first table; 2,821 and 37 for the second) and the preferences of 527 files (preferences.md). Which field holds which attribute is not known.

Positions count characters. A text record's run length counts UTF-16 code units, but every other position counts characters, a surrogate pair being one: the lengths in a strand's chunk 0x261 (also for the text strand), and the run lengths of style runs, owned items and text owners. Evidence: the 6 stories of the little-endian corpus whose text has a character outside the Basic Multilingual Plane (emoji, all in one pair). In all 6 the text records add up to the number of UTF-16 units, and the other strands and all chunk 0x261 lengths to the number of characters; with that reading, each emoji gets the character style range IDML gives it (6 of 6). The converter applies the same reading to hyperlink range trees, for which no sample with such a character exists.

U+FEFF characters can be XML markers, which IDML does not write (xml.md).

INDD stores a forced line break as U+000A; IDML writes it as U+2028. The last paragraph return of a story is not written to IDML.

Styles (0x205)

Paragraph and character styles share the class. Chunk 0x230: u32 next style (0 = itself), u32 based-on style, fields not yet identified, u16 1 for paragraph styles or 0 for character styles, u16 Imported (1 = true), u8 1 if the name is a built-in key ($ID/ in IDML), the name as an in-object string, then, in newer files, a GUID string (StyleUniqueId). The name's offset varies (23–26 bytes), so the converter locates it as a flag byte followed by a valid in-object string. All 486 style names and 291 NextStyle values in the pairs match.

Imported and unique ID. Over the 4,694 paragraph and character styles of the trustworthy pairs whose IDML style has the same name, the u16 after the kind equals Imported in 4,694 (180 imported). The GUID is a 36-character in-object string after the name; where it is stored, IDML has it as StyleUniqueId in 2,769 of 2,793 styles (DOM 11 on; the other 24 have another GUID in IDML). Styles without a stored GUID (1,108 from DOM 11 on) have a StyleUniqueId in IDML that the INDD does not hold, which the converter leaves out.

Kind field. The kind and the Imported u16 after it can be read as one u32 in most files, because the second u16 is 0. The InDesign 7.5 template fixture scml-template/scml.indt (no IDML) has 1 there in 600 of its styles: 151 have 00 00 01 00 before the flag and 449 have 01 00 01 00. The 151 are all listed in the tree of the root character style group (chunk 0x28C2 = 0xCA0D, below) and the 449 in the tree of the root paragraph style group, so the kind is the first u16 alone. Read as a u32, the 151 character styles were taken for paragraph styles, which gave ParagraphStyle/… references and a NextStyle that the schema does not allow on a character style. In every other distinct little-endian corpus file the u32 is 0 or 1 (2,125 styles), and the kind agrees with the root group in all of them. In the two big-endian files the u16 kind is also the first two bytes (00 01 for their three paragraph styles, 00 00 for their two character styles).

IDML writes a BasedOn of the root [No paragraph style] or [No character style] as a string ($ID/[No paragraph style]), and any other base as an object reference.

Keyboard shortcuts. Ten bytes before the name's flag byte is a u32 key; the two bytes 6 and 5 before the flag are modifier bytes m0 and m1. Evidence: the 6,957 paragraph and character styles of all pairs whose IDML style has the same name.

Key KeyboardShortcut ExtendedKeyboardShortcut
0 (5,272 styles) 0 0 0 0 0
0xC000xx, xx a digit 0–9, m1 = 0 m0 and the code below 0 0 0
the same, m1 = 1, paragraph style m0 + 256 and 96 + the digit 0 0 0
0x8000xx (4 styles, one file) 0 0 not written (256 49 1 and similar in IDML)

The 103 styles with a key other than 0 are in 38 files.

Codes with m1 = 0: digits 0 to 7 give 82 to 89, 8 gives 91 and 9 gives 92 (every digit occurs). The converter writes the attribute only for these rows; character styles with m1 = 1 (11 styles: 257 83, 257 84, 257 105) are left out. Over all pairs, KeyboardShortcut is reproduced for 5,273 of 5,273 paragraph styles and 2,191 of 2,202 character styles. IDML has ExtendedKeyboardShortcut from DOM 15 on; the converter writes it from version 15.

Empty nested, line and GREP styles. Paragraph styles have EmptyNestedStyles, EmptyLineStyles and EmptyGrepStyles (DOM 8.1, and 10 on). Each is false when the style's list of nested styles (attribute 0x1B75), line styles (0x1BBB) or GREP styles (0x1BBA) has items, where the list is that of the first style in the based-on chain that has the attribute; an empty list is stored as a count of 0. This gives the IDML value of 5,401 of 5,403 paragraph styles for each of the three (all pairs; the other 2 are not written).

Style groups and object styles

Root groups (class 0xCA8C for paragraph and character styles, 0x1B972 object styles, 0x20241 cell styles, 0x1044F table styles) are named in IDML by UID (RootParagraphStyleGroup Self="u7e"). Chunk 0x28C2 says which kind: 0xCA0C paragraph, 0xCA0D character, 0x1B924 object, 0xB669 cell, 0xB668 table (all 75 pairs). Children: chunk 0x28DC (text styles) or 0x1B95A (object styles), each u32, u32, UID list. A built-in root style such as [No character style] need not be listed.

Groups (class 0xCA8B): chunk 0x28D3 is parent, root, UID list of children; chunk 0x28D2 a flag byte and the name. IDML names every group $ID/<name> (20 of 21 groups), and a style inside groups is referenced as ParagraphStyle/<group>:<group>:<name> with : escaped as %3a. All 412 paragraph styles and 21 groups in the pairs match.

Object styles (class 0x1B901): chunk 0x1B907 is u32 based-on style, u8 1 for a built-in name, then the name. A page item's chunk 0x1B916 is its applied object style (AppliedObjectStyle, 671/671 rectangles). A style based on the root [None] has its BasedOn written as a string.

Object style settings

Object styles (class 0x1B901) hold their settings in these chunks. Evidence: the 337 object styles of the same-version pairs whose name matches an IDML ObjectStyle (259 of them other than [None]); all counts are matches of 337 unless stated.

Chunk Contents IDML
0x1B92B Attribute list, u16 count, page item records (attributes.md) FillColor, StrokeColor, StrokeWeight, StrokeType, CornerOption, CornerRadius, GradientFillAngle (0x551E), GradientStrokeAngle (0x5524)
0x1B956 Attribute list, frame fitting (see frame fitting) FrameFittingOption
0x1B924 Text frame settings (below) TextFramePreference, TextFrameFootnoteOptionsObject
0x285B u16 story orientation at 0, f64 12 at 2, u16 frame type at 14 StoryPreference
0x50F28 u16 story direction StoryPreference/StoryDirection
0x3776, 0x3777 Text wrap, as chunks 0x3703 and 0x373D of page items TextWrapPreference
0x1B92E u32 count, IDs of the categories the style turns on Enable… attributes (below)
0x1B946 u32 paragraph style, 0 = none AppliedParagraphStyle (n for none)

Attribute list. The IDs of page items carry over. CornerOption 0 is None and 0x5A16 InverseRoundedCorner (1 style). The two gradient angles are told apart by one style with −90 and 0. Per-corner values come in pairs of IDs whose order is not known: the top-left and top-right radius are 0x6E70 and 0x6E94, the bottom ones 0x6E92 and 0x6E93; the options 0x6E6F and 0x6E91, and 0x6E8F and 0x6E90. The two of each pair are equal in every style. The converter writes the four corner radii, and the four corner options, only when all four values are equal (336 of 337 styles).

Text frame settings (chunk 0x1B924). 222 bytes; 162, 142 or 106 in files from older versions (942, 48, 66 and 61 object styles in the little-endian corpus). The converter reads it only with these sizes. The InDesign 4.0 file has 104 bytes, with another layout; the converter leaves it out with a warning (big-endian.md).

Offset Contents Attribute
0 f64 TextColumnFixedWidth
8 f64 TextColumnGutter
34, 42, 50, 58 four f64, inset spacing InsetSpacing (below)
66 u32 TextColumnCount
144 u16, 1 = true FootnotesSpanAcrossColumns, SpanFootnotesAcross
146 f64 FootnotesMinimumSpacing, MinimumSpacingOption
154 f64 FootnotesSpaceBetween, SpaceBetweenFootnotes
190 f64 ColumnRuleStrokeWidth
198 u32 swatch, 0 = n ColumnRuleStrokeColor
210 f64 ColumnRuleStrokeTint

Footnote and column rule values: 305 of 305 styles whose chunk has them. The column rule colour maps one to one over 41 (file, UID) pairs. Only one style (3 copies) has unequal insets, and it shows only the top inset (offset 50), so the converter writes InsetSpacing only when all four are equal (334 of 337).

Story settings. Frame type: 0 Unknown, 1 TextFrameType, 2 FrameGridType. Orientation: 0 Unknown, 1 Horizontal. Direction: 1 LeftToRightDirection, 0 or no chunk UnknownDirection. 337 of 337 each. The f64 at 2 is 12 in every style, like OpticalMarginSize, and is not used.

Text wrap. 234 styles have chunk 0x3776 with mode 0, offsets 0 and the u32 at 40 = 1, and chunk 0x3777 type 5: IDML None with ContourType="SameAsClipping". 103 styles have neither chunk and IDML None.

Categories (chunk 0x1B92E). An ID in the list means the attribute is true. Over the 1,684 object styles other than [None] of the trustworthy pairs whose name matches an IDML style (fewer for attributes that IDML has only from a later version), each attribute below equals the presence of its ID in every style:

ID Attribute From DOM
0x1B933 EnableFill 7
0x1B934 EnableStroke 7
0x1B935, 0x1B936 EnableStrokeAndCornerOptions 7
0x1B93E EnableTextFrameGeneralOptions 7
0xADC8 EnableTextFrameBaselineOptions 7
0xADC9 EnableTextFrameAutoSizingOptions 8
0x1B940 EnableStoryOptions 7
0x1B960 EnableFrameFittingOptions 7
0x1B93F EnableParagraphStyle 7
0xADCB EnableTextFrameColumnRuleOptions 15
0xCA2F EnableAnchoredObjectOptions 7
0x1B942, 0x37C8, 0x37C9 EnableTextWrapAndOthers 7
0xADCA EnableTextFrameFootnoteOptions 12
0x6EA1 to 0x6EA7 EnableTransformAttributes 13
0x1B97A, 0x1B97C to 0x1B97E EnableExportTagging, EnableObjectExportAltTextOptions, EnableObjectExportEpubOptions, EnableObjectExportTaggedPdfOptions 9
0x1B937 EnableTransparency of ObjectStyleObjectEffectsCategorySettings 7
0x1B948, 0x1B950, 0x1B958 EnableTransparency of the fill, stroke and content effects categories 7

Where a row has several IDs, they are all present or all absent in every style, so the corpus does not tell which one the attribute follows; the converter writes the attribute only when they agree. The four export attributes are equal in every style (84 true, 1,358 false). With the 88 pairs of the earlier corpus, fill and stroke, and the general and baseline frame options, were not told apart; the larger corpus has styles that differ in them (10 without fill, 13 without stroke, 506 without general options and 531 without baseline options).

Anchored object settings are in chunk 0x2800, as for anchors (see stories), including the two groups of fields that are written together. The other values of object styles come from IDML observation (idml-values.md).

Master spread names and sections

Master spread chunk 0x1402: a flag byte and the name prefix (A), a flag byte and the base name (Master). IDML Name is <prefix>-<base>, and the master's pages are named by the prefix (99/99 match).

Sections (class 0x4C01). The document's chunk 0x4C01 lists them. Section chunk 0x4C02:

Field Contents
u8, string SectionPrefix
u8, string Marker
u32 First page of the section; 0 for the section that starts at the document's first page
u32 Page number start (PageNumberStart)
u32 Page number style: 0x4C15 = Arabic, 0x4C17 = LowerRoman, 0x4C12 = Kanji
u32 Continue numbering (1 = true, ContinueNumbering)
u32 Not identified
u8 flag, string AlternateLayout: the string, with $ID/ before it if the flag is 1

In the 546 sections of the trustworthy pairs, 539 chunks have all these fields; the prefix, marker and alternate layout equal the IDML values in 539 of 539 (417 named layouts such as Letter V, 82 empty, 40 $ID/). The 7 shorter chunks are in DOM 7 and 8 files and end after the second u32 above.

Alternate layouts. A section with a layout name (not empty and not $ID/) starts an alternate layout, and so does the first section. AlternateLayoutLength of a section is the number of pages from its first page to the start of the next layout, or to the end of the document (538 of 539). The AppliedAlternateLayout of a document page is the section that starts its layout; master pages have n. Both are in IDML from DOM 8 on. Over the trustworthy pairs the converted AppliedAlternateLayout equals the IDML value for 9,347 of 9,347 pages.

Page descriptor. A document page has a Descriptor property, a list of the section prefix, the page number style, ContinueNumbering, false, the page number and the marker; from DOM 20 on the page number is in the list twice. Over the trustworthy pairs: 7,800 of 7,924 pages; 64 others are in sections with a style the converter does not know (IDML gives it as an empty string), and the converter leaves their descriptor out. The fourth item is IncludeSectionPrefix, false in every sample.

Evidence:

  • In every corpus pair the first section's IDML PageStart is the document's first page, and its first-page field is 0. All but one pair have one section; one has four. All 79 sections that the converter writes match on PageStart, Length, ContinueNumbering and, where IDML writes it, PageNumberStart. IDML writes PageNumberStart only for sections with ContinueNumbering="false" (14 of 14); a continuing section can store a start number that IDML leaves out.
  • 84 distinct INDD files without an IDML have more than one section (254 sections). The first section listed has first page 0 in all 84. Each of the other 170 names a page of the document (170 of 170). The list is not always in page order, so the converter sorts sections by their first page. A section ends where the next one starts; that gives IDML Length.
  • The style is 0x4C15 in all 423 sections of the 250 distinct little-endian files, and those in the pairs are Arabic. The InDesign 3.0 file stores 0x4C06 (big-endian.md).
  • Style 0x4C17 is lower-case Roman. No pair has it. The evidence is a sample and its print PDF. The PDF's page labels (/PageLabels in the document catalog) give the pages of the sample's 0x4C17 sections style /r, lower-case Roman, and the pages of its 0x4C15 section style /D, decimal.
  • Style 0x4C12 has no pair either. The evidence is a sample typeset vertically and its print PDF. The folios on the pages of its 0x4C12 section are Chinese numerals written digit by digit (〇 一 二 … 九, so 10 is 一〇 and 100 is 一〇〇), counting from the section's start number. The PDF's page labels belong to a larger document and do not show the style. Kanji is the only value of the schema's PageNumberStyle enumeration that uses such numerals.

The converter writes PageNumberStyle for these three codes and leaves it out (with a warning) for other codes.

The converter names document pages by their number in their section, counting on from the previous section when numbering continues. In a section with style 0x4C17 it writes the number in lower-case Roman (i, ii, iii), as in the PDF labels above, and in a section with style 0x4C12 in Chinese digits, as the folios show. No pair shows IDML page names in such sections.

Document preferences (class 0x2202)

One object of class 0x2202 holds document-wide preferences. Chunk 0x533 (DocumentPreference): f64 page width at 0, f64 page height at 8, byte 58 2 for facing pages and 1 otherwise, four f64 bleeds from offset 70 (inside, top, outside, bottom; preferences.md), u32 intent at 142 (0 print, 1 web, 2 mobile). All values match the 75 pairs. Files from InDesign 3.0 to 7.5 have a shorter chunk with another layout; the converter leaves it out with a warning (big-endian.md).

Page binding (u16 at 64). 0 is PageBinding="LeftToRight", 1 RightToLeft. Evidence:

  • The u16 is 0 in all 247 distinct little-endian public files that have the 146-byte chunk. All 88 distinct corpus IDML files have PageBinding="LeftToRight", and in all 73 two-page spreads and master spreads of those files the first page lies left of the second.
  • A sample typeset vertically, whose print PDF shows columns ordered right to left, stores 1. In each of its two-page spreads and master spreads the first page lies right of the second: the book is bound on the right. The schema's other value, Default, has no sample.

The converter writes PageBinding from this field and leaves it out, with a warning, for other codes. Pages are written in the order the spread lists them, for both bindings.

Text frame preferences

From the frame's multi-column frame object (class 0x263):

Chunk Offset TextFramePreference attribute
0x2D1 u32 0 TextColumnCount (1,052/1,052)
0x2D1 f64 4 TextColumnGutter (93/93)
0x2D1 f64 14 TextColumnFixedWidth (1,045/1,045)
0x2CE u16 0 FirstBaselineOffset: 0 LeadingOffset, 1 AscentOffset, 2 CapHeight, 3 EmboxHeight (below)
0x2CE u16 2 VerticalJustification: 0 Top, 1 Center, 2 Bottom, 3 Justify (350/350)
0x2CE u16 20 VerticalBalanceColumns (18/18)
0x2CE u16 22 AutoSizingType: 0 Off, 1 HeightOnly, 2 WidthOnly, 3 HeightAndWidth (61/61)
0x2CE u16 24 AutoSizingReferencePoint: 0–8, top-left to bottom-right by rows (58/58)
0x2CE u16 26, f64 28 UseMinimumHeightForAutoSizing, MinimumHeightForAutoSizing
0x2CE u16 36, f64 38 UseMinimumWidthForAutoSizing, MinimumWidthForAutoSizing
0x2CE u16 46 UseNoLineBreaksForAutoSizing
0x2D1 u8 12 UseFixedColumnWidth
0x2D1 f64 32 TextColumnMaxWidth (in 40-byte chunks)
0x3730 u16 IgnoreWrap
0x22646 f64 28, u32 36 ColumnRuleStrokeWidth, ColumnRuleStrokeColor (a swatch; 0 = n)
0x22608 f64 4, f64 12 FootnotesMinimumSpacing, FootnotesSpaceBetween

The frame itself (class 0x6201) holds the inset spacing in chunk 0x3723 (44 bytes): f64, u32, then four f64 (left, top, right, bottom). IDML writes InsetSpacing as a list of top, left, bottom and right.

Evidence over the text frames of the trustworthy pairs that the converter writes (TextFramePreference values reproduced): the auto-sizing minimums and their flags 4,069 to 4,071 of 4,069 to 4,071 each (5 frames with 108 pt minimums, 4 without line breaks), UseFixedColumnWidth 747 of 747 (9 true), TextColumnMaxWidth 23,043 of 23,043 (one frame with 210.24; the 30-byte chunks of DOM 7 files have no such field and their IDML no such attribute), IgnoreWrap 643 of the 817 frames that have it (74 true; 174 frames without the chunk have false in IDML and are left without it), column rule width and colour 7,277 and 7,323 of 7,277 and 7,323, footnote spacings 4,351 of 4,351 each. Without chunk 0x22646 the IDML has width 1 and Color/Black (2,816 frames); without chunk 0x22608, 12 and 6 (1,430 frames). The column rule and footnote settings are written from the versions in which IDML has them (idml-values.md).

InsetSpacing: 16,560 of 18,091 frames. IDML gives 870 frames a single number instead of a list (the first f64 of chunk 0x3723 in most of them); what decides this was not found, and the converter writes the list for every frame from DOM 11 on. DOM 7 to 10 files give most frames no InsetSpacing at all, and the converter writes none for them.

ColumnRuleOverride: chunk 0x2265A is all zero in the frames of the pairs except one, whose IDML has true; the converter writes false for zero chunks and frames without it (7,247 of 7,248).

Text orientation (chunk 0x2DE). The multi-column frame holds a matrix (six f64) in chunk 0x2DE. Its first four values are 1 0 0 1 for horizontal text and 0 1 −1 0 (a quarter turn) for vertical text. IDML has no frame attribute for this; it writes the orientation on the story (StoryPreference, StoryOrientation). Evidence:

  • All 18,207 multi-column frames in the 239 distinct little-endian public files that have text frames have 1 0 0 1. All 2,094 stories in the corpus IDML files have StoryOrientation="Horizontal".
  • A sample typeset vertically has 0 1 −1 0 in the frames of some stories and 1 0 0 1 in the others. In its print PDF, the text of every frame with the quarter turn is set in vertical columns ordered right to left (glyphs of a column share an x position and follow each other downwards), and the text of every frame with 1 0 0 1 is set in horizontal lines, such as the running heads. The frames of one story always agree.
  • In the rotated frames, TextColumnFixedWidth (chunk 0x2D1) equals the frame's height, not its width: the columns run down the page.

The last two values of the matrix are not identified. The converter writes Vertical for a story whose frames all have the quarter turn, and otherwise Horizontal, the value every IDML has. A story whose frames disagree or have another matrix gets a warning. Two frames in the InDesign 3.0 file have no chunk 0x2DE; they do not count.

First baseline offset. IDML writes FirstBaselineOffset on a frame's TextFramePreference only when it differs from the frame's object style. Over the frames of the corpus pairs, compared with the value written on the frame or, if absent, on its object style:

Code IDML value Frames
1 AscentOffset 1,121 of 1,121 (13 on the frame, 1,108 from the object style)
2 CapHeight 10 of 10 (copies of one document)

No pair has code 0. The evidence for it is a sample and its print PDF. In the PDF, the first baseline in each frame with code 0 lies below the frame's top edge by exactly the leading of that first line, for first lines with several different leadings. Of the values in the IDML schema (AscentOffset, CapHeight, LeadingOffset, EmboxHeight, XHeight, FixedHeight), only LeadingOffset depends on the leading.

Code 3 is EmboxHeight. No public file has it: the 18,207 multi-column frames of the 239 distinct little-endian public files have code 1 or 2 only. The evidence is a sample and its print PDF, and a sample typeset vertically with the same print PDF:

  • The frames measured have code 3, TopAlign and one line. No chunk of these frames or of their multi-column frame objects holds the measured distance as a number, so it is not a stored minimum offset.
  • A first line set in a CJK font lies below the frame's top edge by 0.880 of its point size. The font's ideographic em box (its BASE table) has its bottom at −0.120 em, so the em box top is at 0.880 em. The font's cap height (0.742 em), its x-height (0.503 em), the leading and a fixed offset of 0 give other distances. Its ascent is also 0.880 em.
  • A first line set in a Latin font lies below the frame's top edge by 0.825 of its point size. The font's ascent is 0.710 em, its cap height 0.650 em and its x-height 0.400 em; the leading and a fixed offset of 0 do not match either. So code 3 is not AscentOffset, which is code 1 in any case.
  • Of the values in the IDML schema, only EmboxHeight remains. The Latin font has no em box data; the measured 0.825 em equals an em box centred on half the cap height (0.325 + 0.5).

The converter leaves out codes other than 0 to 3.

Kinsoku and mojikumi tables

Kinsoku tables are objects of classes 0x4209 (hard), 0x420A (soft), 0x42B4 (Korean), 0x42B5 (Simplified Chinese), 0x42B6 (Traditional Chinese) and 0x4204 (custom); mojikumi tables are class 0x4206. IDML writes one KinsokuTable or MojikumiTable per object in designmap.xml, kinsoku tables first, each in UID order. Chunk 0x100B is a flag byte (1 = built-in key, $ID/) and the name; Self is KinsokuTable/<Name> or MojikumiTable/<Name>. Implemented in src/model/cjk.rs.

Evidence: 8 pairs have such objects, and their IDML lists exactly them, by name and in that order (6 with one table of each kind, 2 with 6 kinsoku and 16 mojikumi tables). The other 70 pairs have neither objects nor elements.

Custom kinsoku table (chunk 0x4214). Five u16 counts, then that many UTF-16 units for each of five lists: CantBeginLineChars, CantEndLineChars, a list not identified, HangingPunctuationChars and CantBeSeparatedChars. The evidence is one table in two copies of one document: the four non-empty lists have different lengths (66, 22, 4 and 3), and each matches the IDML attribute of that length. The layout parses in all 85 objects of class 0x4204 in the 250 distinct little-endian files, and the third count is 0 in all of them.

Built-in tables have only Self and Name in IDML. Mojikumi chunk 0x421E (a u16 from 1 to 16) is not used.

Colours (0x1F05)

Chunk Contents
0x1F10 u8 1 if the name is a built-in key; name; u32 flags: bit 0 removable, bit 1 visible, bit 2 editable
0x1F01 u32 space (5 RGB, 6 CMYK), u16 count, f64 components as fractions
0x1F09 u32 model: 0 Process, 1 Spot, 2 Registration (below)
0x1F24 f64 tint value (−1 for a colour, see tints below), then u32 ColorOverride: 0 Normal, 1 Specialpaper, 2 Specialblack, 3 Specialregistration, 4 Hiddenreserved
0x1F0A Alternate colour, as 0x1F01: space 3 none, 6 CMYK, 7 LAB

After the flags, chunk 0x1F10 has two u32 and the SwatchCreatorID (7937 for colours made in the document, other numbers for colours from a swatch library, such as 31527). AlternateSpace is NoAlternateColor with AlternateColorValue="" without chunk 0x1F0A or with space 3; otherwise the space and the values, CMYK as percentages. Evidence over the 12,197 colours of the trustworthy pairs whose IDML colour has the same name: SwatchCreatorID 12,197 of 12,197; alternate space and values 12,197 of 12,197 (7,527 without the chunk, 4,624 with space 3, 33 LAB and 13 CMYK alternates, all library colours).

Space 14 holds hue, saturation and brightness as fractions. IDML writes such a colour as RGB with ConvertToHsb="true"; the 9 such colours in the pairs (all hue 0, saturation 1, brightness 1) are 255 0 0. The converter converts with the usual hexagon formula. Every other colour has ConvertToHsb="false" (4,695 of 4,695 colours of the IDML files from DOM 16 on, where the attribute exists).

Colour groups. From DOM 12 on, every swatch (colour, tint, gradient, None) has SwatchColorGroupReference: the ColorGroupSwatch of the colour group that lists it, or n. Over the trustworthy pairs from DOM 12 on: colours 9,135 of 9,135, gradients 450 of 450, None 353 of 353, tints 24 of 24. DOM 11 files have the attribute on some swatches only (639 of 1,584 colours), and the converter writes it from DOM 12 on.

Unnamed colours are referenced by UID (Color/u93). All 1,296 colours in the pairs match on Model, Space, ColorValue, ColorOverride, Name and the three flags.

Model codes. The 250 distinct little-endian files hold 13,067 colours with chunk 0x1F09: 12,814 with code 0, 250 with code 2 (one Registration colour per file) and 3 with code 1. Two of the three are copies of one colour in two pairs, and their IDML has Model="Spot"; the third is in a file without an IDML. No file has another code, so the converter leaves Model out, with a warning, for any other code.

Tints are objects of the same class without chunks 0x1F10 and 0x1F01. Chunk 0x117 is the UID of the base colour, and chunk 0x1F24 holds the tint value in percent (IDML TintValue) where a colour has −1, followed by the colour override as for colours. IDML names a tint after its base colour and value: Name="Gold 80%" and Self="Tint/Gold 80%25" for 80 % of a colour named Gold. The black swatch (override Specialblack) is written in brackets: [Black] 40%.

Evidence: all 2,107 colours with a name in the distinct little-endian files have −1 at the start of chunk 0x1F24. The same files have 26 tints in 24 files, all with this layout and a named base colour. The pairs have 3 IDML Tint elements (2 files, one of them on black), and all 3 match on TintValue, BaseColor, Name and ColorOverride. Their 19 references (FillColor of 15 page items, StrokeColor of 3, one gradient stop) match too.

Tints have no flags chunk, so ColorEditable, ColorRemovable and Visible (true in all 3 IDML tints) are not written. Brackets are known only for black; other reserved colours as a tint base do not occur in the pairs.

The None swatch is class 0x6E0B (name in chunk 0x1F30).

Gradients (0x5503). Chunk 0x5503: u16 stop count n, n u32 stop colour UIDs, n f64 locations (0–1), n f64 midpoints, u32 type (1 linear). Chunk 0x5505: flag byte, name, u32 flags as for colours. All 99 gradients and 198 stops in the pairs match.

The midpoint stored with stop i is the position of the midpoint between stops i and i+1, measured from the start of the gradient (0–1), as for opacity gradient stops (transparency.md). IDML writes it on stop i+1 as a percentage of the distance between the two stops: Midpoint = (midpoint i − location i) / (location i+1 − location i) × 100. Evidence:

  • Most pairs have two stops at locations 0 and 1, where both readings give the same value. Two gradients in one pair have their first stop at 0.0037; stored midpoints 0.50184 and 0.60147 give IDML Midpoint 50 and 60 with this formula (2 of 2), not 50.18 and 60.15.
  • Gradients with more than two stops, or with stops not at 0 and 1, occur in 26 files, 392 gradients. Only the two above are in a reference IDML. In all 426 stop gaps of non-zero width, the stored midpoint lies between the two stops' locations, as a position from the start of the gradient must (for example stops at 0, 0.5 and 1 with stored midpoints 0.25 and 0.75). Written to IDML unconverted, 13 of them were outside the 13–87 that the IDML schema allows for Midpoint; converted, all 426 are inside it.
  • 8 gaps, all in one file, have width 0 (two stops at the same location), so the formula gives no value.

When the computed value is outside 13–87 or there is none, the converter leaves the Midpoint out and warns.

Inks (0x1F07)

Each ink object with chunk 0x1F0D is one IDML Ink in Resources/Graphic.xml, in UID order (314 of 314 inks, 78 of 78 pairs; the four process inks are UIDs 7 to 10). Self is Ink/<Name> (973 of 973 inks in the corpus IDML files). Chunk 0x1F0D is a flag byte (1 = built-in key, $ID/) and the name, then 86 bytes. Offsets from the end of the name:

Offset Contents IDML Evidence
14 f64 NeutralDensity 314 of 314 (2,786 of 2,786 over the 654 pairs of the later corpus)
26 u32, one less than the IDML value TrapOrder 314 of 314
32 f64 Frequency 314 of 314
40 f64 Angle 314 of 314 (0, 15, 27, 45, 63 and 75)

Byte 2 is 1 for the four process inks and 0 for spot inks; its meaning is not known. InkType="Normal", PrintInk="true" and ConvertToProcess="false" are in all 973 IDML inks and are written from that observation (idml-values.md). The schema puts inks after the colours and before the tints.

In 41 files without an IDML (InDesign 6.0, 13.x and 14.x, from two font projects), the neutral density of all four process inks, their only inks, is −1. The IDML schema allows 0.001 to 10 and no corpus IDML shows what InDesign writes for such an ink, so the converter leaves NeutralDensity out (with a warning) when the value is outside that range.

Colour groups (0x1F39)

Chunk 0x13C is a flag byte and the group name, chunk 0x1F60 a UID list of the group's swatches. The preferences object (class 0x2202) lists the groups in chunk 0x1F61 (u32 count, UIDs). IDML writes a ColorGroup in designmap.xml for each listed group, in that order, with Self="ColorGroup/<Name>"; the first has IsRootColorGroup="true", the others false (77 of 77 pairs; the DOM 7 pair has no chunk 0x1F61 and no groups). The root group is named [Root Color Group] with no $ID/, though its flag byte is 0.

Each swatch of the list is a ColorGroupSwatch with Self="u<group UID>ColorGroupSwatch<index in hex>" and SwatchItemRef the swatch's reference (Swatch/None, Color/…, Tint/… or Gradient/…). In 99 of 101 groups the list gives exactly the IDML swatches, in order; the other two are in the pairs whose IDML was exported from another save. The converter writes 907 of the 942 IDML swatches, all with the IDML reference. A swatch without a reference is left out, and the indices of the others are kept.

Bullet characters

The preferences object (class 0x2202) lists the bullet characters offered for lists in chunk 0x1A488: u16 1, u32 count, then for each bullet u32 character type (0 UnicodeOnly, 1 UnicodeWithFont, 2 GlyphWithFont, as in attributes.md), u32 character value, u32 font family UID (0 = none), a flag byte (1 = built-in key, $ID/) and the font style as an in-object string, then a byte: 0, or 1 followed by four more bytes. IDML writes one ABullet per entry in designmap.xml, with Self="dABullet<index>", CharacterType, CharacterValue and the BulletsFont (the family name, $ID/ for none) and BulletsFontStyle properties.

Evidence: all 78 pairs have the chunk; the count equals the number of IDML ABullet elements in 78 of 78 and the records end the chunk. All 396 bullets match on type, value and font style, and 395 on the font; the other is in the pair whose IDML names the family Minion Pro (OTF) (fonts.md).

The byte after the font style is 0 in 7,443 of the 7,447 bullets in the 1,428 distinct little-endian files that have the chunk. In one InDesign 20.0 file (with IDML) it is 1 in four bullets, each with flag byte 2, and four bytes follow: 00 00 90 01 after Regular and 00 00 BC 02 after Bold (read as two u16: 0 and 400, 0 and 700). Their meaning is not known, and IDML writes nothing for them. With this layout the records end the chunk in all 1,428 files. In the same file, the same five bytes also follow Regular in FontStyle attribute values (0x1B02, attributes.md), whose length prefix includes them. Flag byte 2 occurs in 46 bullets; in that file's IDML its style names have no $ID/ prefix, as with flag 0.

XML tags (0xBF19)

Chunk 0xBF2F is a u32 length and the tag name as text segments (in files from InDesign 2.0 to 5.0, a flag byte and an in-object string; big-endian.md); chunk 0x117 is the UID of the tag's colour, an object of class 0x1F11 whose chunk 0x1F01 holds u32 colour space 5 (RGB), u16 3 and three f64 fractions, as for swatches. IDML writes each tag as an XMLTag in XML/Tags.xml, with Self="XMLTag/<Name>" and the colour as the TagColor property. In all 78 pairs the number of tag objects equals the number of XMLTag elements and the names match (87 tags). IDML lists them by name, ignoring case (the one pair with more than one tag, 10 tags).

Red, green, blue TagColor Evidence
0.31, 0.6, 1 LightBlue 78 tags (Root)
1, 0, 0 Red 1
0.31, 1, 0.31 Green 1
0, 0, 1 Blue 1
1, 1, 0.31 Yellow 1
1, 0.31, 1 Magenta 1
0, 1, 1 Cyan 1
0.5, 0.5, 0.5 Gray 1
0, 0, 0 Black 1
0.6, 0, 0 BrickRed 1

Each colour other than light blue occurs once, all in one file. The converter leaves out TagColor for other colours.

The XML structure (the backing story and the elements) is described in xml.md.