# Document Feature Support

This matrix describes the public `@pptx-glimpse/document` surface. It is intentionally
separate from SVG/PNG rendering fidelity: a value can be available in the document model
without being rendered by `pptx-glimpse`.

## Status legend

- **S — supported**: a typed public workflow exists for this stage and is covered by an
  implementation test. This does not mean that every OOXML variant is supported.
- **△ — partial**: typed support exists, but only for the constraints described below.
- **P — preserved**: there is no typed workflow for this stage, but unchanged source material is
  retained as a raw sidecar or raw package part for structural round trips.
- **— — unsupported**: neither a typed workflow nor a preservation guarantee is currently
  documented and tested.

“Existing edit” means changing or deleting an element already present in an input PPTX. Adding a
new element to a slide loaded from an existing PPTX uses the same authoring operations as the
from-scratch writer and is therefore represented in the “from-scratch writer” column instead.

“Round-trip preservation” is structural, not byte-for-byte. `P` in that column means no-edit,
opaque preservation only; `S` means supported edits or typed authoring are also written and
reread in tests. See [Writing and round-trip preservation](./writing.md).

Consecutive authoring can be coordinated through the public `createPptxAuthoringSession` API.
Its target scopes delegate to the same immutable authoring functions documented below and return
the `SourceHandle` of each newly added drawing or slide. The public `reorderShapes` operation (also
available on target scopes) sets the complete direct-child drawing order for a slide, layout,
master, or native group after additions, including placing a connector behind its connection
targets. `moveShapes` moves a consecutive sibling block within one container or across
root/native-group parents in the same part before an anchor or to the drawing-order end without
requiring a complete sibling list. Cross-parent moves rewrite only moved root transforms when the
source-to-destination affine mapping is exactly representable after OOXML quantization.
`moveShapesAcrossSlides` separately moves consecutive non-placeholder shape/picture/connector/chart
roots between slides, reissues destination-local identities and relationships, and returns the
old-to-new handle mapping. It shares picture media, remaps closed connector endpoints, rejects
selection-crossing references atomically, reuses chart/embedded-workbook target parts at their
existing paths without changing their bytes, and preserves authored local values rather than
materializing source-slide effective appearance.

At drawing-part roots, `readPptx` retains unmodeled slide, layout, and master children such as
timing and extension lists as raw sidecars. They remain preservation-only (`P`) material and are
available to internal safety checks; no typed timing or extension editing API is implied. See the
[typed reader tests][reader-tests], [cross-part planning tests][cross-part-planning-tests], and
[cross-slide move tests][cross-slide-move-tests].

## Matrix

| PowerPoint element      | Reader | Computed view | From-scratch writer | Existing edit | Round-trip preservation |
| ----------------------- | :----: | :-----------: | :-----------------: | :-----------: | :---------------------: |
| Text                    |   S    |       S       |          S          |       △       |            S            |
| Shape                   |   △    |       △       |          △          |       △       |            S            |
| Picture                 |   △    |       S       |          △          |       △       |            S            |
| Connector               |   △    |       S       |          △          |       △       |            S            |
| Table                   |   △    |       S       |          △          |       △       |            S            |
| Chart                   |   △    |       △       |          △          |       △       |            S            |
| Group                   |   △    |       S       |          △          |       △       |            S            |
| Background              |   △    |       △       |          △          |       △       |            S            |
| Master / layout / theme |   △    |       △       |          △          |       △       |            S            |

## Constraints and evidence

| Element                 | Current boundary                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| ----------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Text                    | The reader and computed view expose typed paragraphs, runs, body properties, and the supported style cascade. Authoring covers text boxes and shape/table text with the typed formatting inputs shown in [Authoring a PPTX from scratch](./authoring.md). Existing shape text and Table cell text share the public plain run/paragraph text, selected run properties, and paragraph alignment/level/bullet operations. See [writer edit tests][writer-tests] and [Table cell text edit tests][table-text-edit-tests].                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| Shape                   | Common transforms, preset/custom geometry, fills, outlines, text, and selected effects are typed; unmodeled DrawingML remains raw. Authoring accepts the inputs defined by `AddShapeInput`; `reorderShapes` changes the complete direct-child drawing order for slide/layout/master roots or native groups when every target has a node id, preserves non-drawing children in the selected container, and rejects duplicate ids and `mc:AlternateContent` shape trees. `moveShapes` moves one consecutive typed drawing block within or across root/native-group parents in the same part before an anchor or to the end. It preserves source document order, ids, handles, empty source groups, non-target sibling order, and authored shape-tree container-property slots; same-parent moves preserve transforms, while cross-parent moves rewrite only moved root transforms to retain their part-absolute mappings. Cross-parent moves require complete, non-zero source/destination ancestor chains, an exact source-to-destination affine mapping after integer EMU/angle quantization, and a connector graph closed inside the moved subtree. `moveShapesAcrossSlides` moves consecutive slide-root shape/picture/connector/Chart blocks, allocates destination-local node IDs, handles, ordering slots, and owner relationship IDs, shares picture media and Chart/workbook target parts, and returns old-to-new handle mappings. It remaps internal connector endpoints and rejects placeholders, unsupported typed/raw nodes, template boundaries, pending participant edits, and selection-crossing references atomically. Authored local values are unchanged, so the destination theme/layout/master cascade can change effective appearance. Raw, unknown future, and idless drawing siblings participate in z-order and contiguity validation, and their XML subtrees remain unchanged. Existing slide, layout, and master property editing supports transforms on typed drawing nodes with `xfrm`, fill on `p:sp`, and outline on `p:sp` / `p:cxnSp`. These edits resolve conforming top-level or nested group nodes by the part-local `(partPath,nodeId)` identity and patch only the owning drawing part. `orderingSlot` is the handle-comparison and preservation fallback when no node id exists, but these property edits require `nodeId` for both top-level and nested targets. Group/ungroup can move consecutive siblings at the root or within a group while preserving child ids and handles. Public `deleteShape` accepts `p:sp`, `p:cxnSp`, `p:pic`, native Table/Chart `p:graphicFrame`, and `p:grpSp` at the slide root or any native-group depth. Nested deletion patches only the immediate parent child list, preserves empty parent groups, ancestor transforms, sibling order/ids/handles, and surrounding unknown XML. It rejects SmartArt/raw/`mc:AlternateContent` targets and any deletion subtree referenced by an external connector. Owner relationships are removed only when absent from the retained owner XML; reachable internal parts are then removed recursively only after package-wide incoming relationships reach zero, preserving shared resources, unprovable references, and unrelated orphans. Reorder remains within one root/group parent; cross-parent moves rewrite only each moved root transform and preserve its descendants and unknown XML. See [shape authoring][shape-authoring], [shape ordering][shape-ordering], [shape grouping][shape-grouping], [shape editing][shape-editing], [cross-slide move tests][cross-slide-move-tests], [writer edit tests][writer-tests], and [typed reader tests][reader-tests].                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| Picture                 | Typed reading/computation resolves embedded media, crop, stretch/tile mode, and supported picture/effect properties. Authoring is limited to PNG/JPEG bytes and the typed crop/effect inputs. Existing replacement preserves the media content type: a singly referenced part is updated in place, while a shared part uses copy-on-write with a collision-free media path and relationship so only the selected picture changes. The edit journal reserves allocated paths; undo/redo restore the corresponding snapshots, and no orphan sweep is needed for this operation. Existing crop editing accepts integer OOXML percentages (`100000` = 100%) in `0..100000`, requires each opposing-edge sum below `100000`, rejects rather than clamps invalid values, and supports only slide pictures with exactly one `a:stretch` and no `a:tile`. Set/clear operations patch only the targeted `a:srcRect`, preserve sibling/unknown XML and media bytes, and detect effective no-ops. Pictures at the slide root or any native-group depth support public deletion with retained-owner relationship proof; unshared media is removed only at zero package-wide incoming references, while shared media and unprovable/raw references are preserved. See [picture authoring][picture-authoring], [picture crop editing][picture-crop-editing], [image replacement][image-replacement], [writer edit tests][writer-tests], [editor command tests][editor-command-tests], and [core editor tests][core-editor-tests].                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| Connector               | Typed source/computed nodes retain supported transforms, geometry, outlines, connection sites, and arrow endpoints. Authoring uses the connector presets, endpoint forms, and horizontal/vertical transform flips accepted by `AddConnectorInput`. Existing root or nested connectors support outline and delete operations. Deleting any supported drawing rejects atomically when a connector outside its deletion subtree references the target or a group descendant; endpoints are never silently detached or rerouted. There is no endpoint/geometry editing API. See [shape authoring][shape-authoring], [shape editing][shape-editing], and [writer edit tests][writer-tests].                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| Table                   | Native tables have typed rows, columns, cells, text, fills, borders, margins, merges, and hyperlinks for the implemented subset. Existing cell paragraphs and runs support the same public text operations as shape text. Existing physical cells are addressed by Table handle plus zero-based row/cell indices; inline fill (`none` or solid sRGB), four-side border width/fill, and four margins can be set or cleared to inheritance. Dirty writes patch only the targeted cell text or `a:tcPr` values and preserve text, merges, sibling cells, unknown cell XML, and surrounding Table XML. A native Table `p:graphicFrame` at the slide root or any native-group depth supports public deletion; SmartArt and unknown/raw graphic frames are rejected, and only relationships exclusively referenced by the deleted frame are eligible for cleanup. Row/column topology, merge/unmerge, diagonal or advanced line styles, and table-style definition editing remain unsupported. See [table authoring][table-authoring], [Table cell text edit tests][table-text-edit-tests], [Table cell property edit tests][table-cell-property-edit-tests], and [reader tests][reader-tests].                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| Chart                   | The reader/computed view supports typed chart relationships and data projections for bar, line, pie, doughnut, area, scatter, bubble, radar, stock, surface, of-pie, and fixed bar+line category combo charts; combo projection retains plot-group document order, authored grouping, the authored `axId` element count, populated group `axId` references, uniquely resolved category/value-axis IDs, and value-axis positions. The adapter skips unsupported grouping or inexact/incomplete/ambiguous combo axis topology with a diagnostic. The renderer uses a zero-inclusive scale for groups referencing the same value axis, draws the category baseline at the primary value-axis zero coordinate, renders a distinct right-side scale for a secondary value axis, and handles zero-only and all-negative domains. Other chart XML remains preserved package material. Authoring is narrower: `addChart` creates bar, line, pie, area, doughnut, or radar charts with an editable embedded workbook and the typed formatting implemented in [chart authoring][chart-authoring]. Existing category charts of those six types can use `updateChartData` when they have one internal, unshared embedded workbook, one worksheet, and the standard row-1 names / column-A categories / column-B-onward values layout. The same operation accepts exactly one nonempty, non-stacked `barDir=col` bar plus one nonempty, non-stacked line plot group when each authors exactly two populated `axId` elements, both use one common `catAx`, each resolves exactly one `valAx`, every input carries the computed plot-type + OOXML `idx` source descriptor, and the series count and group membership stay fixed; it updates all group caches/formulas and the shared standard worksheet while preserving group order, `idx` / `order`, axes, formatting, and unknown XML. Horizontal, stacked, empty, or inexact-axis bar+line combos are rejected atomically for editing and skipped with an unsupported renderer diagnostic. Existing scatter charts can separately use `updateScatterChartData` with paired finite X/Y values when each series occupies a standard two-column XY table (X in A, Y/name in B, one spacer row between series). Existing bubble charts use `updateBubbleChartData` with equal finite X/Y/bubble-size arrays and a standard three-column table (X in A, Y/name in B, `Size`/bubble size in C, one spacer row between series). The single-group operations can append or truncate trailing series and replace names, caches, formulas, point counts, worksheet range, and target cells together. Retained positional series preserve their formatting, unknown XML, and `idx` / `order`; additions clone the last original series as their formatting template, receive values after the largest existing `idx` / `order`, and regenerate cloned `c16:uniqueId`; deleted series take their owned formatting/unknown XML with them. Chart type, axes, title, legend, chart-level unknown XML, and unrelated workbook parts are preserved. Series removal with explicit legend entries is rejected because their index semantics vary by chart type. External or shared data, unsupported combos, unresolved relationships, multiple worksheets, formulas or cells outside the chart data range, and other layouts are rejected atomically. Native Chart graphic frames at a slide root can move between slides through `moveShapesAcrossSlides`; the destination owner relationship and handle are reissued while the Chart part, embedded workbook subgraph, content types, part paths, and bytes remain unchanged. A pending supported Chart data edit may precede the move, and later edits require the remapped destination handle; the editor rejects a command after the batch-final move. Native Chart graphic frames at the slide root or any native-group depth also support public deletion. The owner chart relationship is removed only after retained XML proves it unused; the chart part and its embedded workbook/media dependency chain are recursively removed only when each part has zero package-wide incoming relationships. Shared charts/workbooks, unprovable references, and unrelated orphan parts are retained. See [chart data editing][chart-data-editing], [cross-slide move tests][cross-slide-move-tests], and their public-root, editor/core, renderer, snapshot VRT, and LibreOffice validity tests. |
| Group                   | Group `off` / `ext` / rotation / flips and `chOff` / `chExt` remain source-local and children retain immediate-parent coordinates in the recursive source/computed tree. The renderer boundary composes ancestor transforms; incomplete child transforms use a warning-backed `chOff=(0,0), chExt=group ext` display fallback, while zero `chExt` axes remain typed and render with identity scale for that axis. Existing groups with a conforming node id and authored transform can use the public transform edit, including when nested, and supported child property edits use the same recursive locator. `groupShapes` replaces consecutive siblings under one root/group parent with an identity-mapped native group; `ungroupShape` expands only identity-mapped groups without group appearance/unknown XML; `reorderShapes` replaces one group's complete direct-child z-order; `moveShapes` relocates one consecutive direct-child block before an anchor or to the end. `reorderShapes` does not change ids, handles, transforms, connector endpoints, relationships, or package parts. Cross-parent `moveShapes` also rewrites only each moved root transform to preserve its part-absolute affine mapping; a moved group's `chOff` / `chExt`, descendants, ids, handles, connector endpoints, relationships, package parts, and unknown XML remain unchanged. The authoring session exposes these direct-child operations after generic shape/text, PNG/JPEG picture, connector, native Table/Chart graphic-frame, or native-group creation; slide/layout/master and native-group targets share the direct-child container contract. Headless and integrated editor commands select the new group after grouping, retain selection after moving, and select the first child in document order after ungrouping, with topology/selection restored by undo/redo. These operations preserve child ids/handles/order and internal connector ids, and reject crossing/dangling connector references, ambiguous ids, unsupported topology, and non-lossless mappings atomically. Public deletion removes one root or nested native group and its complete descendant subtree while preserving sibling order, ids, handles, ancestor transforms, and surrounding XML; deleting the last child keeps an empty parent group. Connectors outside the subtree that reference the group or a descendant reject the operation atomically; relationships and reachable parts follow the same retained-owner proof and package-wide zero-incoming cleanup rule. Affine ungrouping, approximate or shear-producing affine moves, SmartArt/raw-node authoring, connector rerouting, group fill editing, and cross-part drawing moves remain unsupported. See [authoring guide](./authoring.md#native-groups), [authoring session tests][authoring-session-tests], [shape grouping][shape-grouping], [shape ordering][shape-ordering], [editor command tests][editor-command-tests], [core editor tests][core-editor-tests], [computed view types][computed-types], [reader tests][reader-tests], [computed view tests][computed-view-tests], [writer edit tests][writer-tests], and [renderer group tests][renderer-group-tests].                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| Background              | Slide/layout/master fallback and the implemented fill/style-reference subset are typed; unmodeled backgrounds stay raw. The public handle-based `setBackground` / `clearBackground` API edits existing slides, layouts, and masters with solid sRGB, linear/radial gradient, PNG, JPEG, or direct-background removal; `setSlideBackground` remains a slide-only compatibility API. Image edits allocate target-owned media relationships and retain replaced relationships/media as raw package material, while dirty writes preserve unrelated siblings and raw sidecars. Core invalidation rerenders only slides whose effective inherited background may change. See [background editing](./authoring.md#editing-existing-backgrounds), [background authoring](https://github.com/hirokisakabe/pptx-glimpse/blob/main/packages/document/src/source/slide-background-authoring.ts), [writer edit tests][writer-tests], [core editor tests][core-editor-tests], and [master/layout authoring](./authoring.md#slide-master-and-layout-authoring).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| Master / layout / theme | The reader exposes presentation masters in `p:sldMasterIdLst` order through `SourcePresentation.slideMasterPartPaths`, each master's layouts in `p:sldLayoutIdLst` order through `SourceSlideMaster.layoutPartPaths`, and layout visibility through `SourceSlideLayout.show`; missing id-list relationships produce diagnostics, while packages without an id list fall back to relationship order. Placeholder-capable `p:sp`, `p:pic`, and typed or raw `p:graphicFrame` nodes retain source-local `type` / `idx` / `orient` / `sz` / `hasCustomPrompt` omission and stable handles. The computed view resolves schema defaults, slide → layout by unique effective index, then layout → master by the title/body/special type category without heuristic fallback. The public `createComputedTemplateView` root API also projects one master or layout without a source slide: layout projection resolves layout/master background, visible master normal shapes, layout shapes, and compatible placeholder inheritance while excluding all real slide content. `addPlaceholder` and the authoring session create master `title`/`body` and layout `title`/`ctrTitle`/`body`/`subTitle` definitions, reject duplicate effective indexes, and `addEmptySlideFromLayout` materializes non-special empty shells without copying prompt, transform, geometry, or style. Direct slide authoring, special placeholders, and layout reconciliation remain unsupported. Existing master/layout shapes accept the same supported property subset documented in the Shape row. `createPptx` configures its single theme. `addSlideLayout` appends a layout to an existing master; `cloneSlideLayout` clones only within the same master, shares linked resources, and rejects source layouts whose XML part has pending edits. `updateThemeScheme` edits selected color-scheme slots and major/minor Latin, East Asian, or complex-script typefaces through exactly one existing theme handle. Omitted fields, `a:fmtScheme`, unknown XML, the theme path, and master relationships are preserved; malformed or ambiguous targets are rejected atomically. Core invalidation follows every master that references the edited shared theme. Theme creation/deletion/duplication, relationship rewiring, additional masters, cross-master layout moves, and format-scheme authoring/editing remain unsupported. No-edit round trips plus authored layouts/placeholders, template projection, and existing-theme edits are covered by public-root write/read/computed/render tests and LibreOffice validity. See [template projection tests][computed-template-view-tests], [existing theme editing](./editing.md#existing-theme-color-and-font-schemes), [theme editing tests][theme-editing-tests], [native placeholders](./authoring.md#native-placeholders), [placeholder authoring tests][placeholder-authoring-tests], [layout authoring][layout-authoring], [presentation reader tests][presentation-reader-tests], [computed view][computed-view-source], and [builder][builder-source].                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |

The raw preservation hooks and dependency boundaries behind the final column are documented on
[`PptxSourceModel`][source-model] and in the [`writePptx` implementation][writer-source]. If a
capability is not supported by a public root export and confirmed by implementation tests, this
table must not mark it `S`.

[builder-source]: https://github.com/hirokisakabe/pptx-glimpse/blob/main/packages/document/src/builder/create-pptx.ts
[authoring-session-tests]: https://github.com/hirokisakabe/pptx-glimpse/blob/main/packages/document/src/source/authoring-session.test.ts
[chart-authoring]: https://github.com/hirokisakabe/pptx-glimpse/blob/main/packages/document/src/source/chart-authoring.ts
[chart-data-editing]: https://github.com/hirokisakabe/pptx-glimpse/blob/main/packages/document/src/source/chart-data-editing.ts
[computed-types]: https://github.com/hirokisakabe/pptx-glimpse/blob/main/packages/document/src/computed/pptx-computed-view.ts
[computed-view-tests]: https://github.com/hirokisakabe/pptx-glimpse/blob/main/packages/document/src/computed/create-computed-view.test.ts
[computed-template-view-tests]: https://github.com/hirokisakabe/pptx-glimpse/blob/main/packages/document/src/computed/create-computed-template-view.test.ts
[computed-view-source]: https://github.com/hirokisakabe/pptx-glimpse/blob/main/packages/document/src/computed/create-computed-view.ts
[core-editor-tests]: https://github.com/hirokisakabe/pptx-glimpse/tree/main/packages/core/src
[cross-part-planning-tests]: https://github.com/hirokisakabe/pptx-glimpse/blob/main/packages/document/src/source/cross-part-move-planning.test.ts
[cross-slide-move-tests]: https://github.com/hirokisakabe/pptx-glimpse/blob/main/packages/document/src/source/cross-slide-drawing-move.test.ts
[editor-command-tests]: https://github.com/hirokisakabe/pptx-glimpse/tree/main/packages/editor/src
[image-replacement]: https://github.com/hirokisakabe/pptx-glimpse/blob/main/packages/document/src/source/image-replacement.ts
[picture-authoring]: https://github.com/hirokisakabe/pptx-glimpse/blob/main/packages/document/src/source/picture-authoring.ts
[picture-crop-editing]: https://github.com/hirokisakabe/pptx-glimpse/blob/main/packages/document/src/source/picture-crop-editing.ts
[placeholder-authoring-tests]: https://github.com/hirokisakabe/pptx-glimpse/blob/main/packages/document/src/source/placeholder-authoring.test.ts
[layout-authoring]: https://github.com/hirokisakabe/pptx-glimpse/blob/main/packages/document/src/source/slide-layout-authoring.test.ts
[presentation-reader-tests]: https://github.com/hirokisakabe/pptx-glimpse/blob/main/packages/document/src/reader/read-pptx.test.ts
[reader-tests]: https://github.com/hirokisakabe/pptx-glimpse/blob/main/packages/document/src/reader/slide-reader.test.ts
[renderer-group-tests]: https://github.com/hirokisakabe/pptx-glimpse/blob/main/packages/renderer/src/renderer/svg-renderer.test.ts
[shape-authoring]: https://github.com/hirokisakabe/pptx-glimpse/blob/main/packages/document/src/source/shape-authoring.ts
[shape-editing]: https://github.com/hirokisakabe/pptx-glimpse/blob/main/packages/document/src/source/shape-editing.ts
[shape-grouping]: https://github.com/hirokisakabe/pptx-glimpse/blob/main/packages/document/src/source/shape-grouping.ts
[shape-ordering]: https://github.com/hirokisakabe/pptx-glimpse/blob/main/packages/document/src/source/shape-ordering.ts
[source-model]: https://github.com/hirokisakabe/pptx-glimpse/blob/main/packages/document/src/source/pptx-source-model.ts
[table-authoring]: https://github.com/hirokisakabe/pptx-glimpse/blob/main/packages/document/src/source/table-authoring.ts
[table-cell-property-edit-tests]: https://github.com/hirokisakabe/pptx-glimpse/blob/main/packages/document/src/writer/table-cell-property-editing.test.ts
[table-text-edit-tests]: https://github.com/hirokisakabe/pptx-glimpse/blob/main/packages/document/src/writer/table-text-editing.test.ts
[theme-editing-tests]: https://github.com/hirokisakabe/pptx-glimpse/blob/main/packages/document/src/source/theme-scheme-editing.test.ts
[writer-source]: https://github.com/hirokisakabe/pptx-glimpse/blob/main/packages/document/src/writer/write-pptx.ts
[writer-tests]: https://github.com/hirokisakabe/pptx-glimpse/tree/main/packages/document/src/writer
