Compare commits

..
Author SHA1 Message Date
FredApps 5f58c3c208 #792: read password-protected decks with craft-cfb and drop the local PNG encoder
DeckCraft's pptx crate carried a copy of GridCraft's CFB directory walk to tell an
encrypted package from other compound files. It now asks the shared craft-cfb
(has_entry_named, same UTF-16 fallback for damaged directories, directory entries
capped at 4096 as before). The placeholder for missing picture media keeps its
exact bytes, written as a constant instead of through a hand-rolled CRC/Adler/PNG
encoder.

Part of storytold/craft-libs#778 and storytold/craft-libs#792.
2026-11-16 10:52:29 +01:00
Zinadin Zidan 596ec54b59 Slide show: play a slide's animations again when the show advances to it (#2090) (#2126)
ShowState remembers what was played on each visited slide, so a slide
reached again by a link or by Back looks as it was left. Going forward
used the same path: next() entered a visited slide at the step it was
left at, so after Back and forward again its entrance effects did not
play and the shapes were already in place.

next() now forgets the slide's run before entering it, when it moves
to the next slide and when a looping show comes round to the first
one. The slide starts over: its automatic first step plays, an On
Click build starts at its first step, and its triggered animations
start over. Back, links, Go to slide and Return to Zoom are unchanged.
2026-11-16 10:22:24 +01:00
scks1 9e975b0049 engine: arrange.align and arrange.distribute refuse values they do not name (#1974)
* engine: arrange.align and arrange.distribute refuse values they do not name

arrange.align took an `edge` it did not know as a no-op that still
reported its shapes as edited, aligned left when `edge` was left out
(the spec does not mark it optional), and read any `to` other than
exactly "slide" as the selection. arrange.distribute distributed
vertically for any `dir` starting with "v" and horizontally for any
other, and also read any `to` other than "slide" as the selection.

`edge` must now be left, center, right, top, middle or bottom, `to`
slide or selection, and `dir` horizontal or vertical. Anything else, or
a missing `edge`, is refused with the accepted values and nothing moves.
A missing `to` or `dir` keeps its default.

Test: align_and_distribute_refuse_values_they_do_not_name.

* engine: arrange.align and arrange.distribute refuse a dir or to that is not a string

`align_to` and `distribute` read `to` and `dir` through `str_param`, which
returns None for a value that is present but not a string, the same as for a
missing one. So `{"dir": 123}` distributed horizontally, and
`{"edge": "left", "to": false}` aligned to each command's default reference,
moving the selected shapes instead of failing.

Both now match on `p.get(..).map(Value::as_str)`: a missing field keeps its
default (horizontal for `dir`, each command's own rule for `to`), the named
strings work as before, and anything else, null included, is refused with the
accepted values.

The new test `align_and_distribute_refuse_dir_and_to_that_are_not_strings`
sends null, 123, false, {} and [] as `dir` to arrange.distribute and as `to`
to both commands, in a fresh three-shape session each time, and checks the
error, the revision and every shape's box.
2026-11-16 07:46:28 +00:00
FredApps 4c844f9332 Merge pull request #2165 from storytold/extract/shared-opc-names
Reuse shared OPC part-name primitives
2026-11-16 07:57:56 +01:00
FredApps 5cf7f5f20a Merge main into extract/shared-opc-names 2026-11-16 07:29:45 +01:00
FredApps fb7755717b Merge pull request #1803 from storytold/fix/sec-pptx-theme-budget
PPTX import: budget preserved theme XML, SmartArt drawing shapes and diagram definitions across the presentation
2026-11-16 07:28:46 +01:00
FredApps d04db56f3b Merge pull request #2167 from storytold/cutover/shared-base64-decoder
Reuse shared Base64 decoder with command transport guards
2026-11-16 07:15:16 +01:00
FredApps ea1b4c5539 Merge main into fix/sec-pptx-theme-budget
Keep both sets of import state: the rollback's kept-chart key log and main's
chart decode budget (rejected_kept, chart_decode_bytes). A capture refused by
the retained-byte check records no key; chart decode work stays charged across
a rollback.
2026-11-16 07:14:36 +01:00
FredApps e6574eb39e Merge pull request #2160 from storytold/cutover/shared-base64
Use shared Base64 encoding for command payloads
2026-11-16 07:04:13 +01:00
FredApps 48de308315 Merge main into extract/shared-opc-names
# Conflicts:
#	Cargo.lock
#	Cargo.toml
#	crates/pptx/Cargo.toml
2026-11-16 07:03:32 +01:00
FredApps 1d30834cca Merge cutover/shared-base64 into cutover/shared-base64-decoder
Pin craft-mime to 254e9a40, the craft-libs main revision craft-deckcraft-format
already uses; craft-mime and craft-codepage are unchanged since 0325b2d7.
2026-11-16 06:55:02 +01:00
FredApps 97423d80fd test(engine): pin the standard Base64 alphabet in the encoder test
The lenient decoder accepts both alphabets, so the round trip alone would
not catch a switch to the URL-safe encoder.
2026-11-16 06:46:59 +01:00
FredApps 9e7fa3b571 Merge remote-tracking branch 'origin/main' into HEAD
# Conflicts:
#	Cargo.toml
2026-11-16 06:46:59 +01:00
FredApps bb2c2254ee Native format: take the .deckcraft package layer from craft-deckcraft-format (#2170)
* Native format: golden package bytes and load results before the move to craft-libs

A deck that reaches every kind of member (stored and deflated media, linked media
without bytes, stored and deflated chart parts, a NaN) is saved with a fixed
generator. Its bytes, the presentation and media loaded from them, and the damage
report for a copy missing two members are golden files written by the current
code. `save_as` names the generator so the bytes don't change with the version.

* Native format: the .deckcraft package layer comes from craft-deckcraft-format

The mimetype and legacy type, sniffing, the presentation.json envelope, the
NaN-safe writer (finite.rs, deleted), the null-number manifest reader, member
names, the stored-or-deflated choice, bounded and budget-charged member reads
and the format limits now come from craft-deckcraft-format
(storytold/craft-libs#1748), pinned at its PR tip. The presentation mapping
stays here: which media and chart parts become members, the load loop over
them, repair and sanitising, and outline/RTF.

The golden tests from the previous commit pass unchanged: the saved bytes, the
loaded presentation and the damage report are the same. The crate no longer
depends on serde, serde_json or thiserror; zip is a test dependency.

Part of storytold/craft-libs#778.

* ATTRIBUTION: the native format golden deck

* Native format: pin craft-deckcraft-format to the craft-libs merge commit 254e9a40 (storytold/craft-libs#1748)
2026-11-16 00:27:58 +01:00
Dylan M. Taylor 0d5c0b854b Merge pull request #2163 from storytold/extract/shared-pptx-xml
Reuse shared XML escaping in PPTX writer
2026-11-15 15:21:30 -05:00
Dylan M. Taylor 349d3d1c24 Integrate refreshed encoder and RTF cutovers 2026-11-15 15:02:44 -05:00
autocraft-bot[bot] f33d22001c Merge main into cutover/shared-base64 2026-11-15 19:59:20 +00:00
Dylan M. Taylor d842a0cc2a Delegate Base64 decoding while preserving command input guards 2026-11-15 14:54:50 -05:00
Dylan M. Taylor e51ff1a6a8 Merge pull request #2159 from storytold/cutover/shared-rtf-text
Reuse shared RTF text escaping and code-page decoding
2026-11-15 14:39:46 -05:00
Dylan M. Taylor 455a3fdc35 Reuse shared OPC part-name primitives 2026-11-15 14:14:46 -05:00
Dylan M. Taylor 988d721d7d Reuse shared XML escaping in PPTX writer 2026-11-15 13:57:20 -05:00
Dylan M. Taylor 6bbb593d82 Use shared Base64 encoding for command payloads 2026-11-15 13:22:23 -05:00
Dylan M. TaylorandNikita Rakitin 187afbd4e5 Reuse shared RTF text escaping and Windows-1252 decoding
Keep outline parser and formatting policy local. Preserve exact escaping with explicit compatibility policy and exhaustive scalar/byte oracles. Original text writer and preserved oracle by Nikita Rakitin (beb883d0).

Co-authored-by: Nikita Rakitin <nnnrrr93@gmail.com>
2026-11-15 13:01:05 -05:00
Mex 1af57126a0 fix: reject incomplete Base64 character tails (#2152)
* fix: reject incomplete Base64 character tails

Reject a final six-bit fragment that cannot form a byte while preserving existing accepted encoding forms.

* fix: reject Base64 data after padding

Track padding before accumulator updates and cover the reviewed Zg==A case while retaining whitespace and repeated padding.
2026-11-15 15:55:35 +00:00
Mex b0c532d2d1 fix: lowercase Greek sigma across formatting runs (#2151)
Use whole-text lowercase context while preserving the output pieces for each formatting run, including Unicode expansion.
2026-11-15 15:08:12 +00:00
Mex 3bad02d1f1 fix: skip escaped symbols in RTF Unicode fallback (#2150)
Count an escaped RTF control symbol as one Unicode fallback character and keep parser positions at UTF-8 boundaries. Extend the parser regressions for escaped fallback sequences.
2026-11-15 14:51:32 +00:00
Mex 1ff3b87f5a fix: honor Arabic Letter Mark in paragraph direction detection (#2149)
Recognize U+061C alongside RLM before the alphabetic-character check. Extend directional-mark coverage to preserve first-strong precedence.
2026-11-15 14:12:23 +00:00
Mex 9f7d1c426f fix: round engineering notation after forming the mantissa (#2148)
Keep chart labels such as 999.94 in ##0.0E+00 at 999.9E+00 until the full mantissa actually rounds past its available digits. Add regression coverage for widths, signs, small values, carries and decimal localization.
2026-11-15 13:44:43 +00:00
autocraft-bot[bot] a4674dbd1c Merge pull request #2133 from MMexicann/patch-3
fix(xtask): reject numeric prereleases with leading zeroes
2026-11-15 03:53:24 +00:00
autocraft-bot[bot] 04907481c1 Apply review fixes
- xtask/src/version.rs
2026-11-15 03:43:10 +00:00
autocraft-bot[bot] 3c60448691 Apply review fixes
- xtask/src/version.rs
2026-11-15 03:20:15 +00:00
Mex 772219838e docs: correct the control protocol method reference (#2132)
* DOC2: correct the control method reference

Updated descriptions for various UI commands and actions, including clarifications on parameters and behaviors.

* DOC2: clarify text replacement and slide-show key limits

* DOC2: describe the grid shortcut restriction
2026-11-15 03:01:23 +00:00
FredAppsandFredApps e86c25af9c Release: DeckCraft v0.19.0 on main (#2134)
Co-authored-by: FredApps <FredApps@users.noreply.github.com>
2026-11-14 21:45:54 +01:00
Mex 10fef35fe6 M1: reject leading-zero numeric prerelease versions 2026-11-14 21:35:21 +01:00
Dylan M. Taylor 3746f259a0 test: rollback restores budgets and removes only what the discarded read added 2026-11-11 19:22:48 +00:00
Dylan M. Taylor 175fa54642 address review: roll back by journal, preflight fallback parts, restore tag and chart sidecar accounting on a rejected drawing 2026-11-11 18:50:18 +00:00
Dylan M. Taylor 64c89064ea address review: drop media copied by a rolled-back diagram fallback or parent drawing 2026-11-11 15:11:54 +00:00
Dylan M. Taylor 96c6b5da4c address review: refund the diagram XML budget when a fallback or a parent drawing is dropped 2026-11-11 10:20:58 +00:00
Dylan M. Taylor 40052f4b09 address review: budget diagram definition parts copied by the opaque fallback, refuse a SmartArt drawing over the remaining shape budget 2026-11-11 02:07:46 +00:00
Dylan M. Taylor 8ecb818f81 address review: layout id follows generated layout, charge text-rect shapes to smartart budget 2026-11-10 22:21:47 +00:00
aiongg 953ae8d060 Apply review fixes
- crates/pptx/src/read/shapes.rs
2026-11-04 23:44:51 +00:00
aiongg 1b2b48c0d7 Merge main into fix/sec-pptx-theme-budget 2026-11-04 23:24:41 +00:00
Dylan M. Taylor 9e7fab1038 PPTX import: budget preserved theme XML, SmartArt drawing shapes and diagram definitions across the presentation 2026-11-03 21:05:30 +00:00
38 changed files with 1097 additions and 780 deletions
+1
View File
@@ -35,6 +35,7 @@ artwork. The ribbon and menu icons stay original drawings.
| `crates/fonts/tests/fixtures/legacy-semibold.ttf` | DeckCraft contributors | a one-glyph Semibold face named like Segoe UI Semibold (its Windows family differs from the typographic one), built by `make_legacy_font.py` (fontTools as the builder only) | CC0-1.0 | Font lookup by Windows family name tests |
| `crates/fonts/tests/fixtures/legacy-regular.ttf` | DeckCraft contributors | the same family's one-glyph Regular face, built by `make_legacy_font.py` (fontTools as the builder only) | CC0-1.0 | Font lookup by Windows family name tests |
| `crates/render/tests/fixtures/make_colr_font.py` | DeckCraft contributors | this repository | MIT OR Apache-2.0 | Regenerates the COLR test font |
| `crates/format/tests/golden/deck.deckcraft` | DeckCraft contributors | a synthetic deck (placeholder bytes, no images or text from elsewhere) written by `crates/format/src/golden_tests.rs` with `DECKCRAFT_BLESS_GOLDEN=1` | CC0-1.0 | Native format golden bytes |
| Lucide icon paths in `crates/engine/src/icon_data.rs` (Insert › Icons) | Lucide Contributors; Feather icons by Cole Bemis | https://github.com/lucide-icons/lucide/tree/440a1e1dfb1e712505308da46bead3c28b1f1398/icons (release 1.56.0, 2026-10-13) | ISC; MIT for the Feather-derived icons named in that commit's LICENSE | Stroke icons inserted as shapes |
## Bundled through dependencies
Generated
+100 -10
View File
@@ -222,7 +222,7 @@ dependencies = [
"objc2-foundation 0.3.2",
"parking_lot",
"percent-encoding",
"windows-sys 0.61.2",
"windows-sys 0.52.0",
"wl-clipboard-rs",
"x11rb",
]
@@ -853,6 +853,33 @@ dependencies = [
"thiserror 2.0.21",
]
[[package]]
name = "craft-cfb"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=ea24422ae9859dc5da398d0462bc87f8e02e0d10#ea24422ae9859dc5da398d0462bc87f8e02e0d10"
[[package]]
name = "craft-codepage"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=254e9a409b410dc93c0e06ff66cd1e767893ac32#254e9a409b410dc93c0e06ff66cd1e767893ac32"
[[package]]
name = "craft-codepage"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=63196e66f3033a6623eb629af95a104d26986725#63196e66f3033a6623eb629af95a104d26986725"
[[package]]
name = "craft-deckcraft-format"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=254e9a409b410dc93c0e06ff66cd1e767893ac32#254e9a409b410dc93c0e06ff66cd1e767893ac32"
dependencies = [
"craft-zip 0.1.0 (git+https://github.com/storytold/craft-libs?rev=254e9a409b410dc93c0e06ff66cd1e767893ac32)",
"serde",
"serde_json",
"thiserror 2.0.21",
"zip 9.1.0",
]
[[package]]
name = "craft-fonts-build"
version = "0.1.0"
@@ -900,6 +927,27 @@ dependencies = [
"thiserror 2.0.21",
]
[[package]]
name = "craft-mime"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=254e9a409b410dc93c0e06ff66cd1e767893ac32#254e9a409b410dc93c0e06ff66cd1e767893ac32"
dependencies = [
"chrono",
"craft-codepage 0.1.0 (git+https://github.com/storytold/craft-libs?rev=254e9a409b410dc93c0e06ff66cd1e767893ac32)",
"encoding_rs",
]
[[package]]
name = "craft-opc"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=ea24422ae9859dc5da398d0462bc87f8e02e0d10#ea24422ae9859dc5da398d0462bc87f8e02e0d10"
dependencies = [
"craft-xml",
"craft-zip 0.1.0 (git+https://github.com/storytold/craft-libs?rev=ea24422ae9859dc5da398d0462bc87f8e02e0d10)",
"log",
"thiserror 2.0.21",
]
[[package]]
name = "craft-pdf"
version = "0.1.0"
@@ -909,6 +957,15 @@ dependencies = [
"thiserror 2.0.21",
]
[[package]]
name = "craft-rtf"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=63196e66f3033a6623eb629af95a104d26986725#63196e66f3033a6623eb629af95a104d26986725"
dependencies = [
"craft-codepage 0.1.0 (git+https://github.com/storytold/craft-libs?rev=63196e66f3033a6623eb629af95a104d26986725)",
"encoding_rs",
]
[[package]]
name = "craft-ui"
version = "0.1.0"
@@ -986,6 +1043,35 @@ dependencies = [
"web-sys",
]
[[package]]
name = "craft-xml"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=ea24422ae9859dc5da398d0462bc87f8e02e0d10#ea24422ae9859dc5da398d0462bc87f8e02e0d10"
dependencies = [
"quick-xml 0.41.0",
"thiserror 2.0.21",
]
[[package]]
name = "craft-zip"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=254e9a409b410dc93c0e06ff66cd1e767893ac32#254e9a409b410dc93c0e06ff66cd1e767893ac32"
dependencies = [
"flate2",
"thiserror 2.0.21",
"zip 9.1.0",
]
[[package]]
name = "craft-zip"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=ea24422ae9859dc5da398d0462bc87f8e02e0d10#ea24422ae9859dc5da398d0462bc87f8e02e0d10"
dependencies = [
"flate2",
"thiserror 2.0.21",
"zip 9.1.0",
]
[[package]]
name = "crc32fast"
version = "1.5.2"
@@ -1110,6 +1196,7 @@ name = "deckcraft-engine"
version = "0.19.0"
dependencies = [
"chrono",
"craft-mime",
"deckcraft-anim",
"deckcraft-color",
"deckcraft-fonts",
@@ -1147,10 +1234,10 @@ dependencies = [
name = "deckcraft-format"
version = "0.19.0"
dependencies = [
"craft-deckcraft-format",
"craft-rtf",
"deckcraft-model",
"serde",
"serde_json",
"thiserror 2.0.21",
"zip 3.0.0",
]
@@ -1219,6 +1306,9 @@ dependencies = [
name = "deckcraft-pptx"
version = "0.19.0"
dependencies = [
"craft-cfb",
"craft-opc",
"craft-xml",
"deckcraft-color",
"deckcraft-engine",
"deckcraft-geom",
@@ -1687,7 +1777,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
dependencies = [
"libc",
"windows-sys 0.61.2",
"windows-sys 0.52.0",
]
[[package]]
@@ -3049,7 +3139,7 @@ version = "0.50.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
dependencies = [
"windows-sys 0.61.2",
"windows-sys 0.59.0",
]
[[package]]
@@ -4077,7 +4167,7 @@ dependencies = [
"errno",
"libc",
"linux-raw-sys 0.12.1",
"windows-sys 0.61.2",
"windows-sys 0.52.0",
]
[[package]]
@@ -4134,7 +4224,7 @@ dependencies = [
"security-framework",
"security-framework-sys",
"webpki-root-certs",
"windows-sys 0.61.2",
"windows-sys 0.52.0",
]
[[package]]
@@ -4805,10 +4895,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
dependencies = [
"fastrand",
"getrandom 0.4.3",
"getrandom 0.3.4",
"once_cell",
"rustix 1.1.5",
"windows-sys 0.61.2",
"windows-sys 0.52.0",
]
[[package]]
@@ -5759,7 +5849,7 @@ version = "0.1.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
dependencies = [
"windows-sys 0.61.2",
"windows-sys 0.52.0",
]
[[package]]
+11
View File
@@ -11,6 +11,12 @@ rust-version = "1.95"
repository = "https://github.com/storytold/deckcraft"
[workspace.dependencies]
# OPC part-name primitives; relationship admission stays app-local.
craft-opc = { git = "https://github.com/storytold/craft-libs", rev = "ea24422ae9859dc5da398d0462bc87f8e02e0d10", version = "0.1.0" }
# Compound File Binary directory reads (password-protected deck detection).
craft-cfb = { git = "https://github.com/storytold/craft-libs", rev = "ea24422ae9859dc5da398d0462bc87f8e02e0d10", version = "0.1.0" }
# XML writer primitives; parser admission and OOXML policy stay app-local.
craft-xml = { git = "https://github.com/storytold/craft-libs", rev = "ea24422ae9859dc5da398d0462bc87f8e02e0d10", version = "0.1.0" }
# internal
deckcraft-geom = { path = "crates/geom" }
deckcraft-color = { path = "crates/color" }
@@ -48,7 +54,12 @@ harfrust = "0.13"
vello_cpu = "0.2"
vello_common = { version = "0.2", default-features = false }
image = { version = "0.25", default-features = false, features = ["png", "jpeg", "webp", "gif", "tiff", "bmp"] }
# Base64 for command payloads (engine); base64_compat keeps the legacy lenient decoder. Same rev as craft-deckcraft-format.
craft-mime = { git = "https://github.com/storytold/craft-libs", rev = "254e9a409b410dc93c0e06ff66cd1e767893ac32", version = "=0.1.0" }
# craft-media, craft-audio and craft-video share types and stay on one rev.
# The .deckcraft package layer (identity, manifest, member names, bounded reads); crates/format maps the presentation onto it.
craft-deckcraft-format = { git = "https://github.com/storytold/craft-libs", rev = "254e9a409b410dc93c0e06ff66cd1e767893ac32", version = "=0.1.0" }
craft-rtf = { git = "https://github.com/storytold/craft-libs", rev = "63196e66f3033a6623eb629af95a104d26986725", version = "=0.1.0" }
craft-media = { git = "https://github.com/storytold/craft-libs", rev = "63196e66f3033a6623eb629af95a104d26986725", version = "=0.1.0", default-features = false }
craft-audio = { git = "https://github.com/storytold/craft-libs", rev = "63196e66f3033a6623eb629af95a104d26986725", version = "=0.1.0", default-features = false, features = ["opus-decode"] }
# H.264, HEVC, VP9 and AV1 decoders.
+3 -1
View File
@@ -2,7 +2,7 @@
**Stage: alpha** · next: beta, ~20 points and ~120–210 h away
> **Last reviewed:** 2026-11-04 · **Last updated:** 2026-11-11 · **Change:** trivial (slide-list entries with missing relationships are reported as lost slides and open as repaired copies; the Opus decoder and the Ogg, MP4 and Matroska demuxers come from craft-libs; parity scores unchanged) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
> **Last reviewed:** 2026-11-04 · **Last updated:** 2026-11-14 · **Change:** trivial (a slide the show advances to again plays its animations again, #2090; slide-list entries with missing relationships are reported as lost slides and open as repaired copies; the Opus decoder and the Ogg, MP4 and Matroska demuxers come from craft-libs; parity scores unchanged) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
> **Last reviewed:** 2026-11-02 · **Last updated:** 2026-11-03 · **Change:** trivial (progress log: web `?host=parent` bridge opens and saves through a same-origin framing page; scores unchanged) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
> **Last reviewed:** 2026-11-02 · **Last updated:** 2026-11-03 · **Change:** trivial (community PR wave 10: PPTX and native saves keep table cell centred anchoring, text overflow, compatible line spacing, normalised character height, Thai distributed alignment, RTL table direction, alternate run language and reflection transforms; imported effects placed by parent time-node delays; Reuse Slides fits the destination size and brings custom table styles; deleted slides leave custom shows; merged shapes drop their animations; Compress Pictures measures grouped pictures at displayed size; parity scores unchanged) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
@@ -154,6 +154,7 @@ app's JSON control channel (`deckcraft --control PORT`).
| Date | What landed |
|---|---|
| 2026-11-14 | Slide show: a slide the show advances to again (click, →, Space, automatic advance or a loop) starts over, so its animations play again, as in PowerPoint. Back and links still show it as it was left (#2090) |
| 2026-11-11 | Media: the Opus decoder and the Ogg, MP4/MOV and Matroska demuxers are craft-audio and craft-media from craft-libs; DeckCraft's own copies and re-export crates are removed |
| 2026-11-07 | PPTX slide-list entries with missing relationships are reported in lostSlides instead of silently omitted. The engine opens the partial deck as a repaired copy with no original save path. Slide lists over 10,000 entries are explicitly refused before a partial load; exactly 10,000 remain supported. Synthetic 13-slide regression; does not establish the cause of #1910's field report. |
| 2026-11-04 | Ogg Opus recovery keeps trailing packets without granules in the total duration, matching their recovered positions; valid end trimming stays covered |
@@ -342,6 +343,7 @@ app's JSON control channel (`deckcraft --control PORT`).
| Date | Change | Summary |
|---|---|---|
| 2026-11-14 | trivial | Progress log: a slide the show advances to again plays its animations again (#2090); parity scores unchanged |
| 2026-11-11 | trivial | Opus and container code moved to craft-libs crates; parity scores unchanged |
| 2026-11-04 | trivial | Ogg Opus recovery duration includes its recovered tail; parity scores unchanged |
| 2026-11-02 | trivial | Progress log: run alternate-language metadata round-trips through native and PPTX formats; product parity scores unchanged |
+2 -1
View File
@@ -9,7 +9,8 @@
//! - a shape with a link and a triggered animation follows the link at once. The animation's clock
//! runs only while its slide is shown, so it goes on where it stopped when the show returns;
//! - with "advance on click" off a click never leaves the slide, but it still plays animation steps;
//! - a slide the show returns to (link or arrow keys) looks as it was left.
//! - a slide the show returns to by a link or by going back looks as it was left; going forward
//! to a slide starts it over (#2090).
use deckcraft_model::text::Action;
use deckcraft_model::{Presentation, ShapeId};
+12 -3
View File
@@ -47,7 +47,8 @@ pub enum LinkJump {
/// Where a slide show is. Besides the current position it remembers what was played on every slide
/// the show has visited (main steps, triggered sequences), so a slide reached again by a link or
/// the arrow keys looks the way it was left, as in PowerPoint.
/// by going back looks the way it was left, as in PowerPoint. Going forward to a slide starts it
/// over, so its animations play again (#2090).
#[derive(Clone, Debug, PartialEq, Default)]
pub struct ShowState {
/// Index into `presentation.slides`.
@@ -226,6 +227,14 @@ impl ShowState {
}
}
/// Advance to slide `i`: it starts over, as if the show had not been there, so its
/// animations play again (#2090). Links and Back keep a slide as it was left.
fn enter_forward(&mut self, pres: &Presentation, i: usize) {
self.leave(pres);
self.runs.remove(&i);
self.enter(pres, i);
}
fn next_index(&self, pres: &Presentation) -> Option<usize> {
let order = self.visit(pres);
match order.iter().position(|&i| i == self.slide) {
@@ -271,12 +280,12 @@ impl ShowState {
}
match self.next_index(pres) {
Some(i) => {
self.enter(pres, i);
self.enter_forward(pres, i);
ShowAction::Slide(i)
}
None if looping(pres) => match self.visit(pres).first() {
Some(&i) => {
self.enter(pres, i);
self.enter_forward(pres, i);
ShowAction::Slide(i)
}
None => {
+52
View File
@@ -876,6 +876,8 @@ fn show_back_leaves_a_slide_whose_first_step_is_automatic() {
// While the automatic step plays.
assert_eq!(s.prev(&p), ShowAction::Slide(0), "{start:?}");
assert_eq!(s.next(&p), ShowAction::Slide(1));
// Going forward again plays the automatic step again (#2090).
assert_eq!(s.step_done(&p), ShowAction::FinishStep(0), "{start:?}");
// Once it has played, the click step is undone first, then Back leaves the slide.
assert_eq!(s.next(&p), ShowAction::PlayStep(1));
assert_eq!(s.step_done(&p), ShowAction::FinishStep(1));
@@ -885,6 +887,56 @@ fn show_back_leaves_a_slide_whose_first_step_is_automatic() {
}
}
#[test]
fn a_slide_entered_going_forward_again_plays_its_animations_again() {
// #2090: the show remembered slide 2 as fully built, so its entrance effects did not play the
// second time the show advanced to it.
for start in [AnimStart::WithPrevious, AnimStart::AfterPrevious] {
let mut p = pres(3);
Arc::make_mut(&mut p.slides[1]).shapes = vec![shape(1, "A")];
Arc::make_mut(&mut p.slides[1]).animations = vec![anim(1, AnimClass::Entrance, "fade", start)];
let mut s = ShowState::new(&p);
assert_eq!(s.next(&p), ShowAction::Slide(1));
assert_eq!(s.step_done(&p), ShowAction::FinishStep(0));
assert_eq!(s.prev(&p), ShowAction::Slide(0), "{start:?}");
assert_eq!(s.next(&p), ShowAction::Slide(1));
assert_eq!((s.step, s.playing), (0, true), "{start:?}: the slide starts again");
let a = ShowState::timeline(&p, 1).state(ShapeId(1), None, s.step, 0.0);
assert!(!a.visible || a.opacity < 0.01, "{start:?}: the shape has not come in yet");
// Back from the next slide still shows it as it was left.
assert_eq!(s.step_done(&p), ShowAction::FinishStep(0));
assert_eq!(s.next(&p), ShowAction::Slide(2));
assert_eq!(s.prev(&p), ShowAction::Slide(1));
assert_eq!((s.step, s.playing), (1, false), "{start:?}");
}
// An On Click build left by a jump starts again when the show advances to the slide.
let mut p = pres(2);
Arc::make_mut(&mut p.slides[1]).shapes = vec![shape(1, "A")];
Arc::make_mut(&mut p.slides[1]).animations = vec![anim(1, AnimClass::Entrance, "fade", AnimStart::OnClick)];
let mut s = ShowState::new(&p);
assert_eq!(s.next(&p), ShowAction::Slide(1));
assert_eq!(s.next(&p), ShowAction::PlayStep(0));
assert_eq!(s.step_done(&p), ShowAction::FinishStep(0));
assert_eq!(s.goto(&p, 0), ShowAction::Slide(0));
assert_eq!(s.next(&p), ShowAction::Slide(1));
assert_eq!((s.step, s.playing), (0, false));
}
#[test]
fn a_looping_show_plays_the_first_slide_again() {
// #2090: a kiosk or loop-until-Esc show comes round to the first slide going forward.
let mut p = pres(2);
p.show.loop_until_esc = true;
Arc::make_mut(&mut p.slides[0]).shapes = vec![shape(1, "A")];
Arc::make_mut(&mut p.slides[0]).animations = vec![anim(1, AnimClass::Entrance, "fade", AnimStart::WithPrevious)];
let mut s = ShowState::new(&p);
assert!(s.playing);
assert_eq!(s.step_done(&p), ShowAction::FinishStep(0));
assert_eq!(s.next(&p), ShowAction::Slide(1));
assert_eq!(s.next(&p), ShowAction::Slide(0));
assert_eq!((s.step, s.playing), (0, true));
}
#[test]
fn show_auto_advance() {
let mut p = pres(2);
+17
View File
@@ -325,6 +325,23 @@ fn a_slide_comes_back_the_way_it_was_left() {
assert_eq!(s.step, ShowState::steps(&pres, 1));
}
#[test]
fn a_slide_entered_going_forward_again_starts_over() {
// #2090: the show advances to slide 2 a second time; its triggered animation is undone too.
let s1 = slide(1000, vec![], vec![], true);
let s2 = slide(1001, vec![shape(4)], vec![exit_on_click(4, 4, 0)], true);
let pres = Presentation { slides: vec![s1, s2], ..Default::default() };
let mut r = Run::new(pres, vec![vec![], vec![hit(4, None)]]);
assert_eq!(r.show.next(&r.pres), ShowAction::Slide(1));
assert_eq!(r.click(), Click::Animated);
assert!(!r.visible(ShapeId(4)));
assert_eq!(r.show.prev(&r.pres), ShowAction::Slide(0));
assert_eq!(r.show.prev(&r.pres), ShowAction::None);
assert_eq!(r.show.next(&r.pres), ShowAction::Slide(1));
assert!(r.visible(ShapeId(4)), "the shape is back");
assert!(r.show.trigger_plays().is_empty());
}
#[test]
fn a_playing_main_step_is_finished_when_the_show_leaves() {
let a = Animation { shape: ShapeId(1), class: AnimClass::Entrance, effect: "fade".into(), duration_ms: 500, ..Default::default() };
+1
View File
@@ -9,6 +9,7 @@ description = "DeckCraft engine: sessions, undo history, selection, the command
workspace = true
[dependencies]
craft-mime = { workspace = true }
deckcraft-geom = { workspace = true }
deckcraft-color = { workspace = true }
deckcraft-model = { workspace = true }
+113 -31
View File
@@ -607,51 +607,133 @@ fn param_optional(alt: &str) -> Option<bool> {
/// Base64 (standard alphabet) for binary payloads in JSON params and results.
pub fn base64_encode(data: &[u8]) -> String {
const A: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
let mut out = String::with_capacity(data.len().div_ceil(3) * 4);
for chunk in data.chunks(3) {
let b = [chunk.first().copied().unwrap_or(0), chunk.get(1).copied().unwrap_or(0), chunk.get(2).copied().unwrap_or(0)];
let n = ((b[0] as u32) << 16) | ((b[1] as u32) << 8) | b[2] as u32;
for (i, shift) in [18, 12, 6, 0].iter().enumerate() {
if i <= chunk.len() {
out.push(A.get(((n >> shift) & 63) as usize).copied().unwrap_or(b'A') as char);
} else {
out.push('=');
}
}
}
out
craft_mime::base64::STANDARD.encode(data)
}
pub fn base64_decode(s: &str) -> Option<Vec<u8>> {
let s = s.split_once("base64,").map(|(_, b)| b).unwrap_or(s);
let mut out = Vec::with_capacity(s.len() / 4 * 3);
let mut acc = 0u32;
let mut bits = 0;
// Preserve the command transport's admission rules before the shared legacy decoder:
// padding ends the payload and one trailing symbol cannot encode a byte.
let (mut symbols_mod_four, mut padded) = (0u8, false);
for c in s.bytes() {
let v = match c {
b'A'..=b'Z' => c - b'A',
b'a'..=b'z' => c - b'a' + 26,
b'0'..=b'9' => c - b'0' + 52,
b'+' | b'-' => 62,
b'/' | b'_' => 63,
b'=' | b'\n' | b'\r' | b' ' => continue,
match c {
b'=' => padded = true,
b'\n' | b'\r' | b' ' => {}
b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'+' | b'-' | b'/' | b'_' if !padded => {
symbols_mod_four = (symbols_mod_four + 1) % 4;
}
_ => return None,
} as u32;
acc = (acc << 6) | v;
bits += 6;
if bits >= 8 {
bits -= 8;
out.push(((acc >> bits) & 0xff) as u8);
}
}
Some(out)
if symbols_mod_four == 1 {
return None;
}
craft_mime::base64_compat::decode(s).ok()
}
#[cfg(test)]
mod tests {
use super::*;
// Frozen pre-cutover implementation (Brandon Thomas, with Mex's padding/tail fixes).
fn previous_base64_decode(s: &str) -> Option<Vec<u8>> {
let s = s.split_once("base64,").map(|(_, b)| b).unwrap_or(s);
let mut out = Vec::with_capacity(s.len() / 4 * 3);
let mut acc = 0u32;
let mut bits = 0;
let mut padded = false;
for c in s.bytes() {
let v = match c {
b'A'..=b'Z' => c - b'A',
b'a'..=b'z' => c - b'a' + 26,
b'0'..=b'9' => c - b'0' + 52,
b'+' | b'-' => 62,
b'/' | b'_' => 63,
b'=' => {
padded = true;
continue;
}
b'\n' | b'\r' | b' ' => continue,
_ => return None,
} as u32;
// Padding ends the payload; no further data may be decoded.
if padded {
return None;
}
acc = (acc << 6) | v;
bits += 6;
if bits >= 8 {
bits -= 8;
out.push(((acc >> bits) & 0xff) as u8);
}
}
// A trailing lone Base64 character cannot encode another byte.
(bits != 6).then_some(out)
}
#[test]
fn shared_decoder_preserves_command_transport_admission() {
for text in ["", "=", "Zg== \r\n==", "Zg==A", "A", "AAAAA", "AB", "+_8=", "Z=m9v", "Zm9v\t", "Zm9v!", "data:text/plain;base64,Zm9v"] {
assert_eq!(base64_decode(text), previous_base64_decode(text), "{text:?}");
}
let alphabet = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/-_= \r\n!\t";
let mut seed = 0x1234_5678u32;
for n in 0..50_000 {
let mut text = String::new();
for _ in 0..n % 65 {
seed = seed.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
text.push(char::from(alphabet[(seed as usize) % alphabet.len()]));
}
assert_eq!(base64_decode(&text), previous_base64_decode(&text), "{text:?}");
}
}
#[test]
fn shared_encoder_preserves_rfc4648_and_all_byte_remainders() {
for (input, expected) in
[("", ""), ("f", "Zg=="), ("fo", "Zm8="), ("foo", "Zm9v"), ("foob", "Zm9vYg=="), ("fooba", "Zm9vYmE="), ("foobar", "Zm9vYmFy")]
{
assert_eq!(base64_encode(input.as_bytes()), expected);
}
// The decoder accepts both alphabets, so pin the standard one explicitly.
assert_eq!(base64_encode(&[0xfb, 0xff]), "+/8=");
let all: Vec<u8> = (0..=255).cycle().take(513).collect();
for len in 0..=all.len() {
let encoded = base64_encode(&all[..len]);
assert_eq!(encoded.len(), len.div_ceil(3) * 4);
assert_eq!(encoded.bytes().rev().take_while(|b| *b == b'=').count(), (3 - len % 3) % 3);
assert_eq!(base64_decode(&encoded).as_deref(), Some(&all[..len]));
}
}
#[test]
fn base64_rejects_a_single_character_tail() {
for (encoded, decoded) in [
("", b"".as_slice()),
("Zg==", b"f"),
("Zg", b"f"),
("Zm8=", b"fo"),
("Zm8", b"fo"),
(" Zm9v \r\n", b"foo"),
("data:text/plain;base64,Zm9v", b"foo"),
("+/8=", &[0xfb, 0xff]),
("-_8=", &[0xfb, 0xff]),
] {
assert_eq!(base64_decode(encoded).as_deref(), Some(decoded), "{encoded:?}");
}
for encoded in ["A", "AAAAA", "Zm9vZ", " Zm9vZ \r\n", "data:text/plain;base64,Z"] {
assert!(base64_decode(encoded).is_none(), "{encoded:?}");
}
}
#[test]
fn base64_rejects_data_after_padding() {
assert_eq!(base64_decode("Zg== \r\n=="), Some(b"f".to_vec()));
for encoded in ["Zg==A", "Zg== Zm8=", "Zm8=A", "=Zg", "Zg==\r\nA", "data:text/plain;base64,Zg==A"] {
assert!(base64_decode(encoded).is_none(), "{encoded:?}");
}
}
#[test]
fn the_palette_skips_a_command_that_needs_a_value() {
assert!(needs_arguments("{path}"));
+24 -8
View File
@@ -417,17 +417,28 @@ fn regroup(s: &mut Session, _p: &Value) -> Result<Value> {
}
}
/// `to` of arrange.align and arrange.distribute: `Some(true)` for the slide, `Some(false)` for the
/// selection, `None` when it is left out. Any other value, a non-string included, is refused.
fn align_to(cmd: &str, p: &Value) -> Result<Option<bool>> {
match p.get("to").map(Value::as_str) {
None => Ok(None),
Some(Some("slide")) => Ok(Some(true)),
Some(Some("selection")) => Ok(Some(false)),
Some(_) => Err(bad(cmd, "`to` must be slide or selection")),
}
}
fn align(s: &mut Session, p: &Value) -> Result<Value> {
let edge = str_param(p, "edge").unwrap_or("left").to_string();
let edge = match str_param(p, "edge") {
Some(e @ ("left" | "center" | "right" | "top" | "middle" | "bottom")) => e.to_string(),
_ => return Err(bad("arrange.align", "`edge` must be left, center, right, top, middle or bottom")),
};
let to = align_to("arrange.align", p)?;
let ids = targets(s, p)?;
let st = s.doc()?;
let size = st.doc.slide_size;
let boxes: Vec<(ShapeId, Xfrm)> = ids.iter().filter_map(|id| st.shape(*id).map(|x| (*id, xfrm_of(&st.doc, &st.selection, x)))).collect();
let to_slide = match str_param(p, "to") {
Some("slide") => true,
Some(_) => false,
None => boxes.len() < 2,
};
let to_slide = to.unwrap_or(boxes.len() < 2);
let reference = if to_slide {
Rect::new(0.0, 0.0, size.width, size.height)
} else {
@@ -453,13 +464,18 @@ fn align(s: &mut Session, p: &Value) -> Result<Value> {
}
fn distribute(s: &mut Session, p: &Value) -> Result<Value> {
let horiz = !str_param(p, "dir").unwrap_or("horizontal").starts_with('v');
let horiz = match p.get("dir").map(Value::as_str) {
None | Some(Some("horizontal")) => true,
Some(Some("vertical")) => false,
Some(_) => return Err(bad("arrange.distribute", "`dir` must be horizontal or vertical")),
};
let to = align_to("arrange.distribute", p)?;
let ids = targets(s, p)?;
let st = s.doc()?;
let size = st.doc.slide_size;
let mut boxes: Vec<(ShapeId, Rect)> =
ids.iter().filter_map(|id| st.shape(*id).map(|x| (*id, xfrm_of(&st.doc, &st.selection, x).bounds()))).collect();
let to_slide = str_param(p, "to") == Some("slide") || boxes.len() < 3;
let to_slide = to == Some(true) || boxes.len() < 3;
if boxes.is_empty() {
return ok();
}
+76
View File
@@ -1184,6 +1184,82 @@ fn distribute_wide_middle_stays_in_selection_bounds() {
assert!(xs.iter().all(|x| (*x - [0.0, 10.0, 110.0][xs.iter().position(|y| y == x).unwrap()]).abs() < 1e-6), "{xs:?}");
}
/// An `edge`, `dir` or `to` that the commands do not name, or no `edge` at all, is refused with
/// the accepted values. Before, such a call reported its shapes as edited and moved nothing,
/// aligned to the selection, or fell back to the left edge or to horizontal.
#[test]
fn align_and_distribute_refuse_values_they_do_not_name() {
let mut s = session();
let mut ids = vec![];
for (x, y) in [(10.0, 10.0), (200.0, 50.0), (500.0, 200.0)] {
ids.push(s.execute("shape.insert", &json!({"preset": "rect", "rect": [x, y, 40, 40]})).unwrap()["id"].as_u64().unwrap());
}
s.execute("edit.select", &json!({"ids": ids})).unwrap();
let before = s.doc().unwrap().revision;
let edges = "`edge` must be left, center, right, top, middle or bottom";
let dirs = "`dir` must be horizontal or vertical";
let tos = "`to` must be slide or selection";
for (cmd, params, want) in [
("arrange.align", json!({"edge": "centre"}), edges),
("arrange.align", json!({"edge": "Left"}), edges),
("arrange.align", json!({"edge": "hcenter"}), edges),
("arrange.align", json!({}), edges),
("arrange.align", json!({"ids": [ids[0]], "edge": "left", "to": "Slide"}), tos),
("arrange.distribute", json!({"dir": "Vertical"}), dirs),
("arrange.distribute", json!({"dir": "columns"}), dirs),
("arrange.distribute", json!({"dir": "v"}), dirs),
("arrange.distribute", json!({"dir": "vertical", "to": "page"}), tos),
] {
let err = s.execute(cmd, &params).unwrap_err().to_string();
assert!(err.contains(want), "{cmd} {params}: {err}");
}
assert_eq!(s.doc().unwrap().revision, before, "a refused call leaves the slide as it was");
let pos = |s: &mut Session, id: u64, k: &str| s.execute("shape.inspect", &json!({"id": id})).unwrap()["box"][k].as_f64().unwrap();
s.execute("arrange.align", &json!({"ids": [ids[1]], "edge": "left", "to": "slide"})).unwrap();
assert!(pos(&mut s, ids[1], "x").abs() < 1e-6);
// Within the selection's span, 10..240: 120 pt of shapes leaves two 55 pt gaps.
s.execute("arrange.distribute", &json!({"ids": ids, "dir": "vertical", "to": "selection"})).unwrap();
assert!((pos(&mut s, ids[1], "y") - 105.0).abs() < 1e-6);
}
/// A `dir` or `to` that is present but is not a string (null, a number, a bool, an object or an
/// array) is refused with the accepted values, and the shapes and the revision stay as they were.
/// Before, such a value counted as left out: `dir` meant horizontal and `to` each command's
/// default, so the call moved the selected shapes.
#[test]
fn align_and_distribute_refuse_dir_and_to_that_are_not_strings() {
let dirs = "`dir` must be horizontal or vertical";
let tos = "`to` must be slide or selection";
let mut failures = vec![];
for v in [json!(null), json!(123), json!(false), json!({}), json!([])] {
for (cmd, params, want) in [
("arrange.distribute", json!({"dir": v.clone()}), dirs),
("arrange.distribute", json!({"dir": "horizontal", "to": v.clone()}), tos),
("arrange.align", json!({"edge": "left", "to": v.clone()}), tos),
] {
let mut s = session();
let mut ids = vec![];
for (x, y) in [(10.0, 10.0), (200.0, 50.0), (500.0, 200.0)] {
ids.push(s.execute("shape.insert", &json!({"preset": "rect", "rect": [x, y, 40, 40]})).unwrap()["id"].as_u64().unwrap());
}
s.execute("edit.select", &json!({"ids": ids})).unwrap();
let boxes = |s: &mut Session| -> Vec<Value> {
ids.iter().map(|id| s.execute("shape.inspect", &json!({"id": id})).unwrap()["box"].clone()).collect()
};
let (rev, before) = (s.doc().unwrap().revision, boxes(&mut s));
match s.execute(cmd, &params) {
Ok(_) => failures.push(format!("{cmd} {params}: accepted")),
Err(e) if !e.to_string().contains(want) => failures.push(format!("{cmd} {params}: {e}")),
Err(_) => {}
}
if s.doc().unwrap().revision != rev || boxes(&mut s) != before {
failures.push(format!("{cmd} {params}: moved the shapes"));
}
}
}
assert!(failures.is_empty(), "{failures:#?}");
}
#[test]
fn pointer_draw_move_resize() {
let mut s = session();
+4 -2
View File
@@ -9,8 +9,10 @@ description = "DeckCraft native file format (.deckcraft: zip of a JSON manifest
workspace = true
[dependencies]
craft-deckcraft-format = { workspace = true }
craft-rtf = { workspace = true }
deckcraft-model = { workspace = true }
serde = { workspace = true }
[dev-dependencies]
serde_json = { workspace = true }
zip = { workspace = true }
thiserror = { workspace = true }
+9 -9
View File
@@ -1,14 +1,14 @@
//! Keep opaque chart payloads out of the JSON manifest and within the media load budget.
use std::collections::HashSet;
use std::io::Cursor;
use std::sync::Arc;
use craft_deckcraft_format::{MAX_ENTRY, Package, chart_part_entry, is_chart_part_entry};
use deckcraft_model::chart::ChartPart;
use deckcraft_model::{Master, Presentation, Shape, ShapeKind};
use crate::{FormatError, MAX_ENTRY, Result, read_entry_max};
use crate::{FormatError, Result};
const PREFIX: &str = "chart-parts/";
type Payload = (String, String, Vec<u8>);
pub(super) fn separate(p: &mut Presentation) -> Result<Vec<Payload>> {
@@ -16,7 +16,7 @@ pub(super) fn separate(p: &mut Presentation) -> Result<Vec<Payload>> {
visit_parts(p, |part| {
// The native namespace is independent of the original OPC names, which may repeat
// when charts from several decks are combined. No user-supplied path is extracted.
let entry = format!("{PREFIX}{}", payloads.len());
let entry = chart_part_entry(payloads.len());
part.native_entry = Some(entry.clone());
payloads.push((entry, part.content_type.clone(), std::mem::take(&mut part.bytes)));
Ok(())
@@ -26,7 +26,7 @@ pub(super) fn separate(p: &mut Presentation) -> Result<Vec<Payload>> {
pub(super) fn restore(
p: &mut Presentation,
z: &mut zip::ZipArchive<Cursor<&[u8]>>,
z: &mut Package<'_>,
left: &mut u64,
mut items: usize,
max_items: usize,
@@ -40,21 +40,21 @@ pub(super) fn restore(
items += 1;
if let Some(entry) = part.native_entry.take() {
// Accept only names produced by separate(), and inflate each member once.
let canonical = entry.strip_prefix(PREFIX).and_then(|s| s.parse::<usize>().ok()).is_some_and(|n| entry == format!("{PREFIX}{n}"));
let canonical = is_chart_part_entry(&entry);
if !canonical || !seen.insert(entry.clone()) || !part.bytes.is_empty() {
return Err(FormatError::Damaged("invalid or ambiguous chart part reference".into()));
}
if z.index_for_name(&entry).is_none() {
if !z.contains(&entry) {
// Missing members consume no inflation work and can be reported for recovery.
damaged.push(format!("{entry}: missing chart part"));
return Ok(());
}
if z.by_name(&entry).is_ok_and(|f| f.size() > *left) {
if z.declared_size(&entry).is_some_and(|size| size > *left) {
return Err(FormatError::Damaged("embedded media and chart parts are larger than DeckCraft can open".into()));
}
// A CRC/decode error may already have inflated bytes. Stop on that first error
// rather than letting later corrupt members reuse the unchanged byte budget.
let bytes = read_entry_max(z, &entry, (*left).min(MAX_ENTRY))?;
let bytes = z.read_max(&entry, (*left).min(MAX_ENTRY))?;
*left -= bytes.len() as u64;
part.bytes = bytes;
} else {
-185
View File
@@ -1,185 +0,0 @@
//! A serde serializer adapter that writes non-finite floats as 0.
//!
//! serde_json writes NaN and ±infinity as `null`, which doesn't read back as a number: a single
//! NaN anywhere in the model (a rotation, a crop, a stroke width) made a saved file fail to open
//! as "damaged". [`Finite`] wraps any `Serialize` value and replaces those floats on the way out;
//! everything else passes through unchanged.
use serde::ser::{self, Serialize, Serializer};
/// `T`, serialized with non-finite floats written as 0.
pub struct Finite<'a, T: ?Sized>(pub &'a T);
impl<T: ?Sized + Serialize> Serialize for Finite<'_, T> {
fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
self.0.serialize(Wrap(s))
}
}
struct Wrap<S>(S);
macro_rules! pass {
($($m:ident($t:ty)),* $(,)?) => {
$(fn $m(self, v: $t) -> Result<S::Ok, S::Error> { self.0.$m(v) })*
};
}
impl<S: Serializer> Serializer for Wrap<S> {
type Ok = S::Ok;
type Error = S::Error;
type SerializeSeq = Wrap<S::SerializeSeq>;
type SerializeTuple = Wrap<S::SerializeTuple>;
type SerializeTupleStruct = Wrap<S::SerializeTupleStruct>;
type SerializeTupleVariant = Wrap<S::SerializeTupleVariant>;
type SerializeMap = Wrap<S::SerializeMap>;
type SerializeStruct = Wrap<S::SerializeStruct>;
type SerializeStructVariant = Wrap<S::SerializeStructVariant>;
pass!(
serialize_bool(bool),
serialize_i8(i8),
serialize_i16(i16),
serialize_i32(i32),
serialize_i64(i64),
serialize_i128(i128),
serialize_u8(u8),
serialize_u16(u16),
serialize_u32(u32),
serialize_u64(u64),
serialize_u128(u128),
serialize_char(char),
serialize_str(&str),
serialize_bytes(&[u8]),
);
fn serialize_f32(self, v: f32) -> Result<S::Ok, S::Error> {
self.0.serialize_f32(if v.is_finite() { v } else { 0.0 })
}
fn serialize_f64(self, v: f64) -> Result<S::Ok, S::Error> {
self.0.serialize_f64(if v.is_finite() { v } else { 0.0 })
}
fn serialize_none(self) -> Result<S::Ok, S::Error> {
self.0.serialize_none()
}
fn serialize_some<T: ?Sized + Serialize>(self, v: &T) -> Result<S::Ok, S::Error> {
self.0.serialize_some(&Finite(v))
}
fn serialize_unit(self) -> Result<S::Ok, S::Error> {
self.0.serialize_unit()
}
fn serialize_unit_struct(self, name: &'static str) -> Result<S::Ok, S::Error> {
self.0.serialize_unit_struct(name)
}
fn serialize_unit_variant(self, name: &'static str, i: u32, variant: &'static str) -> Result<S::Ok, S::Error> {
self.0.serialize_unit_variant(name, i, variant)
}
fn serialize_newtype_struct<T: ?Sized + Serialize>(self, name: &'static str, v: &T) -> Result<S::Ok, S::Error> {
self.0.serialize_newtype_struct(name, &Finite(v))
}
fn serialize_newtype_variant<T: ?Sized + Serialize>(self, name: &'static str, i: u32, variant: &'static str, v: &T) -> Result<S::Ok, S::Error> {
self.0.serialize_newtype_variant(name, i, variant, &Finite(v))
}
fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, S::Error> {
self.0.serialize_seq(len).map(Wrap)
}
fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, S::Error> {
self.0.serialize_tuple(len).map(Wrap)
}
fn serialize_tuple_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeTupleStruct, S::Error> {
self.0.serialize_tuple_struct(name, len).map(Wrap)
}
fn serialize_tuple_variant(self, name: &'static str, i: u32, variant: &'static str, len: usize) -> Result<Self::SerializeTupleVariant, S::Error> {
self.0.serialize_tuple_variant(name, i, variant, len).map(Wrap)
}
fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, S::Error> {
self.0.serialize_map(len).map(Wrap)
}
fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct, S::Error> {
self.0.serialize_struct(name, len).map(Wrap)
}
fn serialize_struct_variant(
self,
name: &'static str,
i: u32,
variant: &'static str,
len: usize,
) -> Result<Self::SerializeStructVariant, S::Error> {
self.0.serialize_struct_variant(name, i, variant, len).map(Wrap)
}
fn is_human_readable(&self) -> bool {
self.0.is_human_readable()
}
}
macro_rules! compound {
($tr:ident, $m:ident) => {
impl<S: ser::$tr> ser::$tr for Wrap<S> {
type Ok = S::Ok;
type Error = S::Error;
fn $m<T: ?Sized + Serialize>(&mut self, v: &T) -> Result<(), S::Error> {
self.0.$m(&Finite(v))
}
fn end(self) -> Result<S::Ok, S::Error> {
self.0.end()
}
}
};
}
compound!(SerializeSeq, serialize_element);
compound!(SerializeTuple, serialize_element);
compound!(SerializeTupleStruct, serialize_field);
compound!(SerializeTupleVariant, serialize_field);
impl<S: ser::SerializeMap> ser::SerializeMap for Wrap<S> {
type Ok = S::Ok;
type Error = S::Error;
fn serialize_key<T: ?Sized + Serialize>(&mut self, k: &T) -> Result<(), S::Error> {
self.0.serialize_key(&Finite(k))
}
fn serialize_value<T: ?Sized + Serialize>(&mut self, v: &T) -> Result<(), S::Error> {
self.0.serialize_value(&Finite(v))
}
fn end(self) -> Result<S::Ok, S::Error> {
self.0.end()
}
}
macro_rules! fields {
($tr:ident) => {
impl<S: ser::$tr> ser::$tr for Wrap<S> {
type Ok = S::Ok;
type Error = S::Error;
fn serialize_field<T: ?Sized + Serialize>(&mut self, key: &'static str, v: &T) -> Result<(), S::Error> {
self.0.serialize_field(key, &Finite(v))
}
fn skip_field(&mut self, key: &'static str) -> Result<(), S::Error> {
self.0.skip_field(key)
}
fn end(self) -> Result<S::Ok, S::Error> {
self.0.end()
}
}
};
}
fields!(SerializeStruct);
fields!(SerializeStructVariant);
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn non_finite_floats_are_written_as_zero_and_nothing_else_changes() {
#[derive(serde::Serialize)]
struct T {
a: f64,
b: Option<f64>,
c: Vec<(f32, f64)>,
d: Option<String>,
e: std::collections::BTreeMap<String, f64>,
}
let t = T { a: f64::NAN, b: Some(f64::INFINITY), c: vec![(f32::NEG_INFINITY, 1.5)], d: None, e: [("k".to_string(), f64::NAN)].into() };
let s = serde_json::to_string(&Finite(&t)).unwrap_or_default();
assert_eq!(s, r#"{"a":0.0,"b":0.0,"c":[[0.0,1.5]],"d":null,"e":{"k":0.0}}"#);
}
}
+118
View File
@@ -0,0 +1,118 @@
//! Byte-for-byte checks on the `.deckcraft` package. The files in `tests/golden` were written by
//! the format code as it was before the package layer moved to `craft-deckcraft-format`
//! (storytold/craft-libs). A save of the same deck must give the same bytes, and a load must give
//! the same presentation and the same damage report.
//! `DECKCRAFT_BLESS_GOLDEN=1` rewrites them. Only do that for a deliberate format change.
use std::path::PathBuf;
use std::sync::Arc;
use deckcraft_model::chart::{Chart, ChartPart, ChartType};
use deckcraft_model::text::TextBody;
use deckcraft_model::{MediaId, MediaItem, Presentation, Shape, ShapeId, ShapeKind, Xfrm, defaults};
use super::{load_checked, save_as};
/// A fixed generator, so the golden bytes don't change with the app's version.
const GENERATOR: &str = "DeckCraft golden";
fn golden(name: &str) -> PathBuf {
PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests").join("golden").join(name)
}
fn media(id: u32, name: &str, content_type: &str, data: &[u8], link: Option<&str>) -> MediaItem {
MediaItem { id: MediaId(id), name: name.into(), content_type: content_type.into(), data: Arc::new(data.to_vec()), link: link.map(Into::into) }
}
/// A deck that reaches every kind of package member: stored and deflated media, linked media
/// without bytes (not written), stored and deflated chart parts, and a non-finite number.
fn deck() -> Presentation {
let mut p = defaults::new_presentation(None);
let slide = Arc::make_mut(&mut p.slides[0]);
if let Some(title) = slide.shapes.first_mut() {
title.text = Some(TextBody::from_text("Golden «deck» ✓"));
}
let mut chart = Chart::sample(ChartType::Bar);
for (i, (content_type, bytes)) in
[("application/zip", vec![80, 75, 3, 4, 1, 2, 3]), ("application/vnd.ms-office.chartstyle+xml", b"<cs:chartStyle id=\"201\"/>".repeat(8))]
.into_iter()
.enumerate()
{
chart.kept.parts.push(ChartPart { name: format!("ppt/charts/part{i}"), content_type: content_type.into(), bytes, native_entry: None });
}
let chart_id = ShapeId(p.alloc_id().unwrap_or(9000));
let odd_id = ShapeId(p.alloc_id().unwrap_or(9001));
let slide = Arc::make_mut(&mut p.slides[0]);
slide.shapes.push(Shape {
id: chart_id,
xfrm: Some(Xfrm::new(10.0, 20.0, 300.0, 200.0)),
kind: ShapeKind::Chart(Box::new(chart)),
..Default::default()
});
// Written as 0 by the NaN-safe writer, then clamped on load.
slide.shapes.push(Shape { id: odd_id, xfrm: Some(Xfrm::new(f64::NAN, 5.0, f64::INFINITY, 7.5)), ..Default::default() });
p.media = vec![
media(1, "image1.png", "image/png", &[0x89, b'P', b'N', b'G', 13, 10, 26, 10, 0, 0, 0, 0], None),
media(
2,
"drawing.svg",
"image/svg+xml",
&b"<svg xmlns=\"http://www.w3.org/2000/svg\"><rect width=\"4\" height=\"4\"/></svg>".repeat(4),
None,
),
media(3, "clip.mp4", "video/mp4", &[0, 0, 0, 24, b'f', b't', b'y', b'p'], Some("https://example.invalid/clip.mp4")),
media(4, "linked.png", "image/png", &[], Some("file:///nowhere/linked.png")),
];
p
}
/// The loaded deck and its damage report, as JSON. Media bytes are not in the model's JSON, so
/// each item's bytes follow it in hex. `with_model: false` leaves the presentation out.
fn loaded_json(bytes: &[u8], with_model: bool) -> String {
let (p, damaged) = load_checked(bytes).unwrap_or_else(|e| panic!("load: {e}"));
let hex = |b: &[u8]| b.iter().map(|x| format!("{x:02x}")).collect::<String>();
let media: Vec<(u32, String)> = p.media.iter().map(|m| (m.id.0, hex(&m.data))).collect();
let mut value = serde_json::json!({ "damaged": damaged, "media": media });
if with_model {
value["presentation"] = serde_json::to_value(&p).unwrap_or_default();
}
serde_json::to_string(&value).unwrap_or_default() + "\n"
}
fn check(name: &str, actual: &[u8]) {
let path = golden(name);
if std::env::var_os("DECKCRAFT_BLESS_GOLDEN").is_some() {
std::fs::write(&path, actual).unwrap_or_else(|e| panic!("{}: {e}", path.display()));
return;
}
let expected = std::fs::read(&path).unwrap_or_else(|e| panic!("{}: {e}", path.display()));
assert!(expected == actual, "{name} changed ({} bytes, golden has {})", actual.len(), expected.len());
}
#[test]
fn a_save_writes_the_golden_package_bytes() {
let bytes = save_as(&deck(), GENERATOR).unwrap_or_else(|e| panic!("save: {e}"));
check("deck.deckcraft", &bytes);
}
#[test]
fn a_load_of_the_golden_package_gives_the_golden_presentation() {
let bytes = std::fs::read(golden("deck.deckcraft")).unwrap_or_else(|e| panic!("{e}"));
check("deck.loaded.json", loaded_json(&bytes, true).as_bytes());
}
#[test]
fn a_load_of_a_damaged_package_gives_the_golden_report() {
// The PNG member and the second chart part removed: both are reported, nothing is refused.
let bytes = std::fs::read(golden("deck.deckcraft")).unwrap_or_else(|e| panic!("{e}"));
let mut z = zip::ZipArchive::new(std::io::Cursor::new(bytes.as_slice())).unwrap_or_else(|e| panic!("{e}"));
let mut out = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
for i in 0..z.len() {
let Ok(f) = z.by_index_raw(i) else { continue };
if f.name() != "media/1" && f.name() != "chart-parts/1" {
out.raw_copy_file(f).unwrap_or_else(|e| panic!("{e}"));
}
}
let damaged = out.finish().unwrap_or_else(|e| panic!("{e}")).into_inner();
check("damaged.loaded.json", loaded_json(&damaged, false).as_bytes());
}
+35 -232
View File
@@ -5,158 +5,63 @@
#![forbid(unsafe_code)]
mod chart_parts;
mod finite;
pub mod rtf;
#[cfg(test)]
mod chart_parts_tests;
#[cfg(test)]
mod golden_tests;
use std::io::{Cursor, Read, Write};
use std::sync::Arc;
use deckcraft_model::text::{Paragraph, TextBody};
use deckcraft_model::{LayoutType, Presentation, ShapeKind, defaults};
pub const MIMETYPE: &str = "application/vnd.storyteller.deckcraft+zip";
/// Files written before the SlideCraft → DeckCraft rename (`.slidecraft`) are still read.
pub const LEGACY_MIMETYPE: &str = concat!("application/vnd.storyteller.", "slide", "craft+zip");
pub const EXTENSION: &str = "deckcraft";
/// Format version written into the manifest.
pub const VERSION: u32 = 1;
/// Largest entry we will inflate (guards against zip bombs).
const MAX_ENTRY: u64 = 2 << 30;
/// All embedded media and chart sidecars together, inflated (#393).
const MAX_TOTAL_MEDIA: u64 = 4 << 30;
/// Media items and chart sidecar parts one file may list.
const MAX_MEDIA_ITEMS: usize = 100_000;
/// Largest `presentation.json` we will inflate. The manifest holds no media bytes, so it is far
/// smaller than a media entry may be; inflating and parsing one is what dominates memory.
const MAX_MANIFEST: u64 = 256 << 20;
/// What one load may inflate.
#[derive(Clone, Copy)]
struct Budget {
total: u64,
items: usize,
manifest: u64,
}
#[cfg(test)]
impl Budget {
/// A media budget with the default manifest limit.
fn media(total: u64, items: usize) -> Self {
Budget { total, items, manifest: MAX_MANIFEST }
}
}
#[derive(Debug, thiserror::Error)]
pub enum FormatError {
#[error("not a DeckCraft file: {0}")]
NotOurs(String),
#[error("damaged file: {0}")]
Damaged(String),
#[error("write failed: {0}")]
Write(String),
}
pub type Result<T> = std::result::Result<T, FormatError>;
#[derive(serde::Serialize, serde::Deserialize)]
struct Manifest {
format: String,
version: u32,
generator: String,
presentation: Presentation,
}
// The package itself (identity, manifest, member names, bounded reads) is shared.
pub use craft_deckcraft_format::{Budget, EXTENSION, FormatError, LEGACY_MIMETYPE, MIMETYPE, Result, VERSION, sniff};
use craft_deckcraft_format::{Member, Package, media_entry};
/// Serialize a presentation.
pub fn save(p: &Presentation) -> Result<Vec<u8>> {
let mut buf = Cursor::new(Vec::new());
{
let mut z = zip::ZipWriter::new(&mut buf);
let stored = zip::write::SimpleFileOptions::default().compression_method(zip::CompressionMethod::Stored);
let deflate = zip::write::SimpleFileOptions::default().compression_method(zip::CompressionMethod::Deflated);
let w = |e: zip::result::ZipError| FormatError::Write(e.to_string());
z.start_file("mimetype", stored).map_err(w)?;
z.write_all(MIMETYPE.as_bytes()).map_err(|e| FormatError::Write(e.to_string()))?;
let mut presentation = p.clone();
let parts = chart_parts::separate(&mut presentation)?;
let m =
Manifest { format: "deckcraft".into(), version: VERSION, generator: format!("DeckCraft {}", env!("CARGO_PKG_VERSION")), presentation };
let json = serde_json::to_vec(&finite::Finite(&m)).map_err(|e| FormatError::Write(e.to_string()))?;
z.start_file("presentation.json", deflate).map_err(w)?;
z.write_all(&json).map_err(|e| FormatError::Write(e.to_string()))?;
for item in &p.media {
if item.link.is_some() && item.data.is_empty() {
continue;
}
// Already-compressed media is stored, not deflated again.
let opts = if is_compressed(&item.content_type) { stored } else { deflate };
z.start_file(format!("media/{}", item.id.0), opts).map_err(w)?;
z.write_all(&item.data).map_err(|e| FormatError::Write(e.to_string()))?;
}
for (name, content_type, bytes) in parts {
let opts = if is_compressed(&content_type) { stored } else { deflate };
z.start_file(name, opts).map_err(w)?;
z.write_all(&bytes).map_err(|e| FormatError::Write(e.to_string()))?;
}
z.finish().map_err(w)?;
}
Ok(buf.into_inner())
save_as(p, &format!("DeckCraft {}", env!("CARGO_PKG_VERSION")))
}
fn is_compressed(ct: &str) -> bool {
ct.starts_with("image/jpeg")
|| ct.starts_with("image/png")
|| ct.starts_with("video/")
|| ct.starts_with("audio/mpeg")
|| ct.starts_with("audio/mp4")
|| ct.contains("zip")
}
/// Does this look like a `.deckcraft` file?
pub fn sniff(bytes: &[u8]) -> bool {
bytes.starts_with(b"PK") && [MIMETYPE, LEGACY_MIMETYPE].iter().any(|m| bytes.windows(m.len()).take(200).any(|w| w == m.as_bytes()))
/// [`save`] naming `generator` in the manifest.
fn save_as(p: &Presentation, generator: &str) -> Result<Vec<u8>> {
let mut presentation = p.clone();
let parts = chart_parts::separate(&mut presentation)?;
// Linked media saved without its bytes has no member.
let media: Vec<(String, &deckcraft_model::MediaItem)> =
p.media.iter().filter(|item| !(item.link.is_some() && item.data.is_empty())).map(|item| (media_entry(item.id.0), item)).collect();
let members: Vec<Member<'_>> = media
.iter()
.map(|(name, item)| Member { name, content_type: &item.content_type, bytes: &item.data })
.chain(parts.iter().map(|(name, content_type, bytes)| Member { name, content_type, bytes }))
.collect();
craft_deckcraft_format::write(&presentation, generator, &members)
}
/// A member of a package a test built or rewrote with `zip`, within `max` bytes.
#[cfg(test)]
fn read_entry(z: &mut zip::ZipArchive<Cursor<&[u8]>>, name: &str) -> Result<Vec<u8>> {
read_entry_max(z, name, MAX_ENTRY)
}
/// Read one member, refusing it before inflating if it declares more than `max` bytes, and
/// stopping at `max` if it inflates further than it declared.
fn read_entry_max(z: &mut zip::ZipArchive<Cursor<&[u8]>>, name: &str, max: u64) -> Result<Vec<u8>> {
read_entry_counted(z, name, max, &mut 0)
}
/// [`read_entry_max`] within `left` (and [`MAX_ENTRY`]), charging `left` for every byte inflated,
/// including those inflated before a decode or CRC error, so a member that fails late still
/// spends the shared budget it used.
fn read_entry_charged(z: &mut zip::ZipArchive<Cursor<&[u8]>>, name: &str, left: &mut u64) -> Result<Vec<u8>> {
let mut spent = 0;
let out = read_entry_counted(z, name, (*left).min(MAX_ENTRY), &mut spent);
*left = left.saturating_sub(spent);
out
}
/// [`read_entry_max`], adding the bytes inflated to `spent` whether or not the read succeeds.
fn read_entry_counted(z: &mut zip::ZipArchive<Cursor<&[u8]>>, name: &str, max: u64, spent: &mut u64) -> Result<Vec<u8>> {
fn read_entry_max(z: &mut zip::ZipArchive<std::io::Cursor<&[u8]>>, name: &str, max: u64) -> Result<Vec<u8>> {
use std::io::Read;
let f = z.by_name(name).map_err(|e| FormatError::Damaged(format!("{name}: {e}")))?;
if f.size() > max {
return Err(FormatError::Damaged(format!("{name} is too large")));
}
let mut out = Vec::with_capacity(f.size().min(64 << 20) as usize);
let mut f = f.take(max.saturating_add(1));
let read = f.read_to_end(&mut out);
*spent = spent.saturating_add(out.len() as u64);
read.map_err(|e| FormatError::Damaged(format!("{name}: {e}")))?;
let mut out = vec![];
f.take(max.saturating_add(1)).read_to_end(&mut out).map_err(|e| FormatError::Damaged(format!("{name}: {e}")))?;
if out.len() as u64 > max {
return Err(FormatError::Damaged(format!("{name} is too large")));
}
Ok(out)
}
#[cfg(test)]
fn read_entry(z: &mut zip::ZipArchive<std::io::Cursor<&[u8]>>, name: &str) -> Result<Vec<u8>> {
read_entry_max(z, name, craft_deckcraft_format::MAX_ENTRY)
}
/// Read a presentation. Missing media/chart parts are left empty; use [`load_checked`] to
/// learn which. A damaged chart member refuses the file before further chart inflation.
pub fn load(bytes: &[u8]) -> Result<Presentation> {
@@ -167,19 +72,11 @@ pub fn load(bytes: &[u8]) -> Result<Presentation> {
/// A chart member that is present but fails decoding, CRC or its entry limit refuses the file.
/// Linked media saved without its bytes isn't damage.
pub fn load_checked(bytes: &[u8]) -> Result<(Presentation, Vec<String>)> {
load_within(bytes, Budget { total: MAX_TOTAL_MEDIA, items: MAX_MEDIA_ITEMS, manifest: MAX_MANIFEST })
load_within(bytes, Budget::default())
}
fn load_within(bytes: &[u8], budget: Budget) -> Result<(Presentation, Vec<String>)> {
let mut z = zip::ZipArchive::new(Cursor::new(bytes)).map_err(|e| FormatError::NotOurs(e.to_string()))?;
if z.index_for_name("presentation.json").is_none() {
return Err(FormatError::NotOurs("no presentation.json".into()));
}
let json = read_entry_max(&mut z, "presentation.json", budget.manifest)?;
let m = parse_manifest(&json)?;
if m.format != "deckcraft" {
return Err(FormatError::NotOurs(m.format));
}
let (m, mut z) = Package::open_manifest::<Presentation>(bytes, budget.manifest)?;
let mut p = m.presentation;
let mut damaged = vec![];
let items = p.media.len();
@@ -192,13 +89,13 @@ fn load_within(bytes: &[u8], budget: Budget) -> Result<(Presentation, Vec<String
p.media.retain(|m| seen.insert(m.id));
let mut left = budget.total;
for item in &mut p.media {
let name = format!("media/{}", item.id.0);
let linked_only = item.link.is_some() && z.index_for_name(&name).is_none();
if z.by_name(&name).is_ok_and(|f| f.size() > left) {
let name = media_entry(item.id.0);
let linked_only = item.link.is_some() && !z.contains(&name);
if z.declared_size(&name).is_some_and(|size| size > left) {
return Err(FormatError::Damaged("embedded media is larger than DeckCraft can open".into()));
}
// A failed read is charged for what it inflated, so later members can't reuse that budget.
match read_entry_charged(&mut z, &name, &mut left) {
match z.read_charged(&name, &mut left) {
Ok(data) => item.data = Arc::new(data),
Err(_) if linked_only => {}
Err(e) => damaged.push(e.to_string()),
@@ -346,100 +243,6 @@ fn add_outline_slides(p: &mut Presentation, slides: OutlineSlides) -> usize {
made
}
/// Most `null`s standing in for numbers that [`parse_manifest`] patches in one file, and the
/// candidates it tries for each.
const MAX_NULL_FIXES: usize = 256;
const MAX_TRIES_PER_FIX: usize = 32;
/// Bytes [`parse_manifest`] may re-parse in all while patching, so a hostile file full of `null`s
/// can't keep it busy: past this the file is reported damaged.
const MAX_REPARSE_BYTES: usize = 256 * 1024 * 1024;
/// Where a parse failed, comparable: later is progress.
fn failure(src: &[u8]) -> std::result::Result<Manifest, (String, (usize, usize))> {
serde_json::from_slice::<Manifest>(src).map_err(|e| (e.to_string(), (e.line(), e.column())))
}
/// Parse `presentation.json`. serde_json writes a NaN or infinite number as `null`, which then
/// fails to read back as a number ("invalid type: null, expected f64"), so DeckCraft could save
/// a file it couldn't open. Each such `null` is read as 0 instead ([`repair`] then brings the
/// value into range); anything else that doesn't parse is damage.
///
/// serde reports the failing `null` exactly, except inside tagged enums (buffered), where it
/// reports the end of the enclosing object: there the `null`s before that point are tried
/// nearest first, and a patch is kept only if the parse then gets further. (Files saved since
/// [`finite::Finite`] never contain such `null`s; this reads older ones.)
fn parse_manifest(json: &[u8]) -> Result<Manifest> {
// Parse the inflated text as it is: only a file that fails on a `null` number is copied for
// patching (the copy is bounded by `MAX_MANIFEST`).
let mut last = match failure(json) {
Ok(m) => return Ok(m),
Err(f) => f,
};
if !is_null_number(&last.0) {
return Err(FormatError::Damaged(last.0));
}
let mut src = json.to_vec();
let mut budget = MAX_REPARSE_BYTES;
'fixes: for _ in 0..MAX_NULL_FIXES {
let (msg, pos) = &last;
if !is_null_number(msg) {
break;
}
let end = offset(&src, pos.0, pos.1).unwrap_or(src.len());
let mut progressed = false;
let candidates: Vec<usize> = value_nulls_before(&src, end + 4).take(MAX_TRIES_PER_FIX).collect();
for at in candidates {
let (Some(head), Some(tail)) = (src.get(..at), src.get(at.saturating_add(4)..)) else { continue };
let Some(left) = budget.checked_sub(src.len()) else { break 'fixes };
budget = left;
let mut next = Vec::with_capacity(src.len());
next.extend_from_slice(head);
next.push(b'0');
next.extend_from_slice(tail);
match failure(&next) {
Ok(m) => return Ok(m),
// The patch shortened the text by 3 bytes before the error: compare positions
// allowing for that.
Err(f) if f.1 > (pos.0, pos.1.saturating_sub(3)) => {
src = next;
last = f;
progressed = true;
break;
}
Err(_) => {}
}
}
if !progressed {
break;
}
}
Err(FormatError::Damaged(last.0))
}
/// Is this parse error a `null` where a number belongs (a NaN or infinity serde_json wrote)?
fn is_null_number(msg: &str) -> bool {
msg.starts_with("invalid type: null, expected f") || msg.starts_with("invalid type: null, expected a number")
}
/// Byte offset of a 1-based `line`:`column`.
fn offset(src: &[u8], line: usize, column: usize) -> Option<usize> {
let mut start = 0;
for _ in 1..line {
start += src.get(start..)?.iter().position(|b| *b == b'\n')? + 1;
}
Some((start + column).min(src.len()))
}
/// Starts of `null` tokens in value position (after `:`, `[` or `,`) before `end`, nearest first.
fn value_nulls_before(src: &[u8], end: usize) -> impl Iterator<Item = usize> + '_ {
let end = end.min(src.len());
(0..end.saturating_sub(3)).rev().filter(move |&i| {
src.get(i..i + 4) == Some(b"null")
&& src[..i].iter().rev().find(|b| !b.is_ascii_whitespace()).is_some_and(|b| matches!(b, b':' | b'[' | b','))
&& src.get(i + 4).is_none_or(|b| !b.is_ascii_alphanumeric())
})
}
/// Largest coordinate or size kept, in points (about 350 m; PowerPoint's own limit is far smaller).
const MAX_COORD: f64 = 1.0e6;
+102 -29
View File
@@ -10,24 +10,24 @@ use deckcraft_model::text::{Paragraph, RunKind};
/// RTF-escape `s` (non-ASCII as `\uN?`, UTF-16, signed as RTF wants).
fn escape(out: &mut String, s: &str) {
for c in s.chars() {
match c {
'\\' | '{' | '}' => {
out.push('\\');
out.push(c);
}
'\t' => out.push_str("\\tab "),
'\u{b}' | '\n' => out.push_str("\\line "),
c if c.is_ascii() && !c.is_ascii_control() => out.push(c),
c if c.is_ascii() => {}
c => {
let mut buf = [0u16; 2];
for u in c.encode_utf16(&mut buf) {
out.push_str(&format!("\\u{}?", *u as i16));
}
}
}
// Keep outline text literal: the shared writer also supports page/column breaks and
// shorthand controls that this app's deliberately small outline reader does not consume.
// Delegate ordinary spans, including UTF-16 escaping, without allocating a second string.
let mut start = 0;
for (i, c) in s.char_indices() {
let replacement = match c {
'\u{000C}' | '\u{000E}' => "",
'\u{00A0}' => "\\u160?",
'\u{00AD}' => "\\u173?",
'\u{2011}' => "\\u8209?",
'\u{2028}' => "\\u8232?",
_ => continue,
};
craft_rtf::push_esc(out, &s[start..i]);
out.push_str(replacement);
start = i + c.len_utf8();
}
craft_rtf::push_esc(out, &s[start..]);
}
fn runs(out: &mut String, p: &Paragraph) {
@@ -276,6 +276,9 @@ impl Outline<'_> {
while k > 0 && self.i < self.b.len() {
if self.b[self.i] == b'\\' && self.b.get(self.i + 1) == Some(&b'\'') {
self.i = advance(self.rtf, self.i, 4);
} else if self.b[self.i] == b'\\' && self.b.get(self.i + 1).is_some_and(|b| !b.is_ascii_alphabetic()) {
// An escaped control symbol counts as one Unicode fallback character.
self.i = advance(self.rtf, self.i + 1, 1);
} else if matches!(self.b[self.i], b'{' | b'}' | b'\\') {
break;
} else {
@@ -294,7 +297,7 @@ impl Outline<'_> {
&& let Some(h) = hex
&& h != 0
{
self.line.push(cp1252(h));
self.line.push(craft_rtf::codepage::cp1252(h));
}
}
@@ -381,22 +384,75 @@ fn finish_surrogates(s: String) -> String {
out
}
fn cp1252(b: u8) -> char {
const HIGH: [char; 32] = [
'€', '\u{81}', '‚', 'ƒ', '„', '…', '†', '‡', 'ˆ', '‰', 'Š', '‹', 'Œ', '\u{8d}', 'Ž', '\u{8f}', '\u{90}', '‘', '’', '“', '”', '•', '–', '—',
'˜', '™', 'š', '›', 'œ', '\u{9d}', 'ž', 'Ÿ',
];
match b {
0x80..=0x9f => HIGH[(b - 0x80) as usize],
_ => b as char,
}
}
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used)]
use super::*;
// Frozen pre-cutover implementations are test oracles, not production parsers.
fn legacy_escape(out: &mut String, s: &str) {
for c in s.chars() {
match c {
'\\' | '{' | '}' => {
out.push('\\');
out.push(c);
}
'\t' => out.push_str("\\tab "),
'\u{b}' | '\n' => out.push_str("\\line "),
c if c.is_ascii() && !c.is_ascii_control() => out.push(c),
c if c.is_ascii() => {}
c => {
let mut buf = [0u16; 2];
for u in c.encode_utf16(&mut buf) {
out.push_str(&format!("\\u{}?", *u as i16));
}
}
}
}
}
fn legacy_cp1252(b: u8) -> char {
const HIGH: [char; 32] = [
'€', '\u{81}', '‚', 'ƒ', '„', '…', '†', '‡', 'ˆ', '‰', 'Š', '‹', 'Œ', '\u{8d}', 'Ž', '\u{8f}', '\u{90}', '‘', '’', '“', '”', '•', '–',
'—', '˜', '™', 'š', '›', 'œ', '\u{9d}', 'ž', 'Ÿ',
];
match b {
0x80..=0x9f => HIGH[(b - 0x80) as usize],
_ => b as char,
}
}
#[test]
fn shared_escape_preserves_every_unicode_scalar() {
for value in 0..=0x10ffff {
let Some(c) = char::from_u32(value) else { continue };
let mut buf = [0; 4];
let text = c.encode_utf8(&mut buf);
let mut expected = String::new();
let mut actual = String::new();
legacy_escape(&mut expected, text);
escape(&mut actual, text);
assert_eq!(actual, expected, "U+{value:04X}");
}
}
#[test]
fn shared_escape_preserves_mixed_spans_and_append() {
let text = "a\t中\u{a0}b\u{ad}c\u{2011}d\u{2028}e\u{c}f\u{e}g\n😀{}\\";
let mut expected = String::from("prefix:");
let mut actual = expected.clone();
legacy_escape(&mut expected, text);
escape(&mut actual, text);
assert_eq!(actual, expected);
}
#[test]
fn shared_cp1252_preserves_all_bytes() {
for b in 0..=u8::MAX {
assert_eq!(craft_rtf::codepage::cp1252(b), legacy_cp1252(b));
}
}
/// A sign in a `\'hh` escape is not a hex digit and must be ignored.
#[test]
fn hex_escape_rejects_sign() {
@@ -422,6 +478,23 @@ mod tests {
assert_eq!(rtf_to_outline(r"{\rtf1 x\u-70000?y\par}"), "x\u{ee90}y\n");
}
#[test]
fn unicode_fallback_control_symbols_are_skipped() {
for (rtf, expected) in [
(r"{\rtf1\uc1 \u92\\X\par}", "\\X\n"),
(r"{\rtf1\uc1 \u123\{X\par}", "{X\n"),
(r"{\rtf1\uc1 \u125\}X\par}", "}X\n"),
(r"{\rtf1\uc2 \u233\{\}X\par}", "éX\n"),
(r"{\rtf1\uc0 \u92\\X\par}", "\\\\X\n"),
(r"{\rtf1 \\ \{ \}X\par}", "\\ { }X\n"),
(r"{\rtf1\uc1 \u233{X}\par}", "éX\n"),
(r"{\rtf1\uc1 \u233\éX\par}", "éX\n"),
(r"{\rtf1\uc1 \u233\", "é\n"),
] {
assert_eq!(rtf_to_outline(rtf), expected, "{rtf:?}");
}
}
#[test]
fn multibyte_control_symbol_keeps_character_and_following_text() {
assert_eq!(rtf_to_outline("{\\rtf1 A\\éB\\par}"), "AéB\n");
+8 -6
View File
@@ -1,4 +1,6 @@
use super::*;
use craft_deckcraft_format::{Manifest, parse_manifest};
use std::io::{Cursor, Read, Write};
#[test]
fn chart_sidecars_are_optional_for_older_native_files() {
@@ -364,7 +366,7 @@ fn reflection_transform_survives_two_native_saves_and_absent_fields_stay_absent(
assert_eq!(reopened.slides[0].shapes.last().and_then(|s| s.effects.as_ref()).and_then(|e| e.reflection.as_ref()), Some(&absent));
}
/// Files written before [`finite::Finite`] (plain serde_json: NaN as `null`) open too,
/// Files written before [`craft_deckcraft_format::Finite`] (plain serde_json: NaN as `null`) open too,
/// including a `null` inside a tagged enum, where serde reports only the enclosing object.
#[test]
fn older_files_with_null_numbers_open() {
@@ -387,7 +389,7 @@ fn older_files_with_null_numbers_open() {
let m = Manifest { format: "deckcraft".into(), version: VERSION, generator: "old".into(), presentation: p };
let json = serde_json::to_vec(&m).unwrap();
assert!(json.windows(4).any(|w| w == b"null"));
let back = parse_manifest(&json).unwrap_or_else(|e| panic!("case {case}: {e}"));
let back = parse_manifest::<Presentation>(&json).unwrap_or_else(|e| panic!("case {case}: {e}"));
assert_eq!(back.presentation.slides[0].shapes.len(), m.presentation.slides[0].shapes.len(), "case {case}");
}
}
@@ -419,14 +421,14 @@ fn a_bare_normautofit_body_round_trips() {
#[test]
fn other_damage_is_still_reported() {
let ok = serde_json::to_vec(&serde_json::json!({"format": "deckcraft", "version": 1, "generator": "t", "presentation": {}})).unwrap();
assert!(parse_manifest(&ok).is_ok());
assert!(parse_manifest::<Presentation>(&ok).is_ok());
let bad = br#"{"format": null, "version": 1, "generator": "t", "presentation": {}}"#;
assert!(parse_manifest(bad).is_err());
assert!(parse_manifest::<Presentation>(bad).is_err());
let truncated = &ok[..ok.len() - 3];
assert!(parse_manifest(truncated).is_err());
assert!(parse_manifest::<Presentation>(truncated).is_err());
// A null number on a later line (pretty-printed by another tool) is found too.
let pretty = b"{\n \"format\": \"deckcraft\",\n \"version\": 1,\n \"generator\": \"t\",\n \"presentation\": {\"slides\": [{\"shapes\": [{\"xfrm\": {\"x\": null, \"y\": 1, \"w\": 2, \"h\": 3}}]}]}\n}";
let m = parse_manifest(pretty).unwrap_or_else(|e| panic!("{e}"));
let m = parse_manifest::<Presentation>(pretty).unwrap_or_else(|e| panic!("{e}"));
assert_eq!(m.presentation.slides[0].shapes[0].xfrm.unwrap().x, 0.0);
}
@@ -0,0 +1,2 @@
# Golden files are compared byte for byte: no line-ending conversion on checkout.
* -text
@@ -0,0 +1 @@
{"damaged":["damaged file: media/1: specified file not found in archive","chart-parts/1: missing chart part"],"media":[[1,""],[2,"3c73766720786d6c6e733d22687474703a2f2f7777772e77332e6f72672f323030302f737667223e3c726563742077696474683d223422206865696768743d2234222f3e3c2f7376673e3c73766720786d6c6e733d22687474703a2f2f7777772e77332e6f72672f323030302f737667223e3c726563742077696474683d223422206865696768743d2234222f3e3c2f7376673e3c73766720786d6c6e733d22687474703a2f2f7777772e77332e6f72672f323030302f737667223e3c726563742077696474683d223422206865696768743d2234222f3e3c2f7376673e3c73766720786d6c6e733d22687474703a2f2f7777772e77332e6f72672f323030302f737667223e3c726563742077696474683d223422206865696768743d2234222f3e3c2f7376673e"],[3,"0000001866747970"],[4,""]]}
Binary file not shown.
File diff suppressed because one or more lines are too long
+6 -2
View File
@@ -10,8 +10,8 @@
/// Cyrillic, CJK…) give `false`. Neutral, weak, and whitespace characters are skipped.
pub fn first_strong_is_rtl(text: &str) -> bool {
for c in text.chars() {
if c == '\u{200F}' {
// Right-to-Left Mark (RLM)
if c == '\u{200F}' || c == '\u{061C}' {
// RLM and ALM are strong RTL controls, although neither is alphabetic.
return true;
}
if c == '\u{200E}' {
@@ -76,6 +76,10 @@ mod tests {
#[test]
fn honours_directional_marks() {
assert!(first_strong_is_rtl("\u{200F}Hello"));
assert!(first_strong_is_rtl("\u{061C}Hello"));
assert!(first_strong_is_rtl("\u{061C}"));
assert!(!first_strong_is_rtl("Hello\u{061C}"));
assert!(!first_strong_is_rtl("\u{200E}\u{061C}"));
assert!(!first_strong_is_rtl("\u{200E}مرحبا"));
}
}
+18 -1
View File
@@ -528,6 +528,12 @@ pub fn change_case(s: &str, mode: &str) -> String {
/// `title` and `sentence` carry their word/sentence state across piece boundaries. Each output
/// piece is the changed form of the matching input piece, even where a character changes length.
pub fn change_case_parts(parts: &[&str], mode: &str) -> Vec<String> {
if mode == "lower" {
let lower = parts.concat().to_lowercase();
let mut chars = lower.chars();
// Context changes sigma's form, while each character's expansion length stays the same.
return parts.iter().map(|s| chars.by_ref().take(s.chars().map(|c| c.to_lowercase().count()).sum()).collect()).collect();
}
let mut start = true;
// All characters of all pieces, so word-final sigma sees neighbours across piece boundaries.
let all: Vec<char> = parts.iter().flat_map(|s| s.chars()).collect();
@@ -536,7 +542,6 @@ pub fn change_case_parts(parts: &[&str], mode: &str) -> Vec<String> {
.iter()
.map(|s| match mode {
"upper" => s.to_uppercase(),
"lower" => s.to_lowercase(),
"toggle" => s.chars().map(|c| if c.is_uppercase() { c.to_lowercase().collect::<String>() } else { c.to_uppercase().collect() }).collect(),
_ => {
// `title` restarts after whitespace, sentence case after sentence punctuation.
@@ -593,6 +598,18 @@ mod tests {
assert_eq!(change_case_parts(&["ΟΔΟΣ", " ΜΟΥ"], "title"), ["Οδος", " Μου"]);
}
#[test]
fn lowercase_keeps_context_and_run_boundaries() {
assert_eq!(change_case_parts(&["ΟΔΟ", "Σ"], "lower"), ["οδο", "ς"]);
assert_eq!(change_case_parts(&["ΟΣ", "Α"], "lower"), ["οσ", "α"]);
assert_eq!(change_case_parts(&["", "ΟΔΟ", "", "Σ", ""], "lower"), ["", "οδο", "", "ς", ""]);
assert_eq!(change_case_parts(&["İΟΔΟ", "Σ"], "lower"), ["i\u{307}οδο", "ς"]);
assert_eq!(change_case_parts(&["Ο", "\u{301}", "Σ"], "lower"), ["ο", "\u{301}", "ς"]);
assert_eq!(change_case_parts(&["ΟΣ", "\u{301}", "Α"], "lower"), ["οσ", "\u{301}", "α"]);
assert_eq!(change_case_parts(&["", "", ""], "lower"), ["", "", ""]);
assert!(change_case_parts(&[], "lower").is_empty());
}
#[test]
fn insert_and_split() {
let mut b = body("Hello");
+22 -5
View File
@@ -234,16 +234,18 @@ fn sci(toks: &[Tok], v: f64, sep: char, dec: char) -> Option<String> {
m *= 10.0;
exp -= 1;
}
// Rounding the mantissa to its digits can reach 10 (9.999 as `0.00`).
if format!("{m:.mant_frac$}").starts_with("10") {
m /= 10.0;
exp += 1;
}
}
let step = mant.iter().take_while(|t| **t != Tok::Dot).filter(|t| matches!(t, Tok::Digit(_))).count().max(1) as i32;
let shift = exp.rem_euclid(step);
exp -= shift;
m *= 10f64.powi(shift);
// Round after forming the engineering mantissa: 999.94 as `##0.0` stays 999.9.
// Carry only when rounding exceeds all of the format's integer placeholders.
let carry = 10f64.powi(step);
if format!("{m:.mant_frac$}").parse::<f64>().is_ok_and(|rounded| rounded >= carry) {
m /= carry;
exp += step;
}
let mantissa = fixed(mant, mfirst, mlast, m, sep, dec);
let sign = if exp < 0 {
"-"
@@ -404,6 +406,21 @@ mod tests {
assert_eq!(format("##0.0E+0", 999.96, None), "1.0E+3");
}
#[test]
fn engineering_formats_round_the_full_mantissa() {
for (code, value, expected) in [
("##0.0E+00", 999.94, "999.9E+00"),
("##0.0E+00", 0.99994, "999.9E-03"),
("##0.0E+00", -999.94, "-999.9E+00"),
("#0.0E+00", 99.94, "99.9E+00"),
("##0.0E+00", 999.96, "1.0E+03"),
("#0.0E+00", 99.96, "1.0E+02"),
] {
assert_eq!(format(code, value, None), expected, "{code}, {value}");
}
assert_eq!(format("##0.0E+00", 999.94, Some("de-DE")), "999,9E+00");
}
#[test]
fn never_panics() {
for code in ["", ";", ";;;", "\"", "[", "\\", "0.", ".", "#,", "%", "_", "*", "@", "0E+00", "[$", "\"unterminated"] {
+3
View File
@@ -9,6 +9,9 @@ description = "DeckCraft PPTX: Office Open XML (PresentationML/DrawingML) import
workspace = true
[dependencies]
craft-opc.workspace = true
craft-xml.workspace = true
craft-cfb.workspace = true
deckcraft-model = { workspace = true }
deckcraft-geom = { workspace = true }
deckcraft-color = { workspace = true }
+16 -94
View File
@@ -1,103 +1,24 @@
//! Just enough of the Compound File Binary (CFB/OLE2) container to tell a password-protected
//! presentation apart: PowerPoint wraps an encrypted `.pptx` in a CFB holding `EncryptionInfo`
//! and `EncryptedPackage` streams (ECMA-376 / [MS-OFFCRYPTO]) instead of a zip. Every read is
//! bounds-checked and every loop bounded. Copied from GridCraft's `crates/xlsx/src/cfb.rs`.
/// The CFB signature at the start of the file.
const SIGNATURE: [u8; 8] = [0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1];
const END_OF_CHAIN: u32 = 0xFFFF_FFFE;
/// Sector ids at or above this are markers (free, end of chain, FAT/DIFAT sector), not sectors.
const MAX_REG_SECT: u32 = 0xFFFF_FFFA;
/// Directory sectors followed at most (4096 entries with 512-byte sectors).
const MAX_DIR_SECTORS: usize = 1024;
/// DIFAT sectors followed at most.
const MAX_DIFAT_SECTORS: usize = 1024;
//! Password-protected presentations. PowerPoint wraps an encrypted `.pptx` in a Compound File
//! Binary (CFB/OLE2) container holding `EncryptionInfo` and `EncryptedPackage` streams
//! (ECMA-376 / [MS-OFFCRYPTO]) instead of a zip. The container's directory is read by the shared
//! `craft-cfb` crate, which bounds every chain and falls back to a UTF-16 name search when a
//! damaged file's directory cannot be followed.
/// Stream names that mark an encrypted (password-protected) OOXML package.
const ENCRYPTED_STREAMS: [&str; 2] = ["EncryptedPackage", "EncryptionInfo"];
fn u16_at(b: &[u8], at: usize) -> Option<u16> {
let s = b.get(at..at.checked_add(2)?)?;
Some(u16::from_le_bytes([*s.first()?, *s.get(1)?]))
/// Directory entries read at most: 1024 directory sectors of 512 bytes, as before the move to
/// `craft-cfb`, so a hostile directory chain stays cheap.
const MAX_DIR_ENTRIES: usize = 4096;
fn limits() -> craft_cfb::Limits {
craft_cfb::Limits { max_dir_entries: MAX_DIR_ENTRIES, ..craft_cfb::Limits::default() }
}
fn u32_at(b: &[u8], at: usize) -> Option<u32> {
let s = b.get(at..at.checked_add(4)?)?;
Some(u32::from_le_bytes([*s.first()?, *s.get(1)?, *s.get(2)?, *s.get(3)?]))
}
/// Whether `bytes` is a compound file holding an encryption stream. Walks the directory through
/// the FAT; when the structure can't be followed (truncated or malformed), falls back to scanning
/// the bytes for the UTF-16LE stream names.
/// Whether `bytes` is a compound file holding an encryption stream.
pub(crate) fn is_encrypted(bytes: &[u8]) -> bool {
if !bytes.starts_with(&SIGNATURE) {
return false;
}
match directory_names(bytes) {
Some(names) => names.iter().any(|n| ENCRYPTED_STREAMS.iter().any(|e| n.eq_ignore_ascii_case(e))),
None => ENCRYPTED_STREAMS.iter().any(|e| contains_utf16(bytes, e)),
}
}
fn contains_utf16(hay: &[u8], needle: &str) -> bool {
let n: Vec<u8> = needle.encode_utf16().flat_map(u16::to_le_bytes).collect();
!n.is_empty() && hay.windows(n.len()).any(|w| w == n.as_slice())
}
/// Names of every directory entry, or `None` when the directory can't be read.
fn directory_names(b: &[u8]) -> Option<Vec<String>> {
if !b.starts_with(&SIGNATURE) {
return None;
}
let shift = u16_at(b, 30)?;
if shift != 9 && shift != 12 {
return None;
}
let size = 1usize << shift;
let per = size / 4;
let sector = |id: u32| -> Option<&[u8]> {
let start = (id as usize).checked_add(1)?.checked_mul(size)?;
b.get(start..start.checked_add(size)?)
};
// The DIFAT: the FAT's sector ids, 109 in the header then chained DIFAT sectors.
let mut difat: Vec<u32> = (0..109).filter_map(|i| u32_at(b, 76 + i * 4)).filter(|&s| s < MAX_REG_SECT).collect();
let mut next = u32_at(b, 68)?;
for _ in 0..MAX_DIFAT_SECTORS {
if next >= MAX_REG_SECT {
break;
}
let s = sector(next)?;
difat.extend((0..per - 1).filter_map(|i| u32_at(s, i * 4)).filter(|&x| x < MAX_REG_SECT));
next = u32_at(s, (per - 1) * 4)?;
}
let fat_next = |id: u32| -> Option<u32> {
let idx = id as usize;
let fat_sector = *difat.get(idx / per)?;
u32_at(sector(fat_sector)?, (idx % per) * 4)
};
let mut names = Vec::new();
let mut id = u32_at(b, 48)?;
for _ in 0..MAX_DIR_SECTORS {
if id == END_OF_CHAIN {
return Some(names);
}
if id >= MAX_REG_SECT {
return None;
}
let s = sector(id)?;
for e in s.as_chunks::<128>().0 {
let len = usize::from(u16_at(e, 64)?);
if !(2..=64).contains(&len) {
continue;
}
let units: Vec<u16> = (0..(len - 2) / 2).filter_map(|i| u16_at(e, i * 2)).collect();
names.push(String::from_utf16_lossy(&units));
}
id = fat_next(id)?;
}
// A directory longer than the bound (or a cyclic chain): report what was read.
Some(names)
let limits = limits();
ENCRYPTED_STREAMS.iter().any(|name| craft_cfb::has_entry_named(bytes, name, &limits))
}
#[cfg(test)]
@@ -105,6 +26,7 @@ mod tests {
#![allow(clippy::unwrap_used)]
use super::*;
use craft_cfb::{ENDOFCHAIN as END_OF_CHAIN, SIGNATURE};
/// A minimal valid compound file (512-byte sectors: FAT at sector 0, directory at sector 1)
/// whose directory holds a root entry plus the given stream names.
@@ -146,7 +68,7 @@ mod tests {
#[test]
fn reads_directory_names() {
let b = build(&["EncryptionInfo", "EncryptedPackage"]);
assert_eq!(directory_names(&b), Some(vec!["Root Entry".into(), "EncryptionInfo".into(), "EncryptedPackage".into()]));
assert_eq!(craft_cfb::directory_names(&b, &limits()), Some(vec!["Root Entry".into(), "EncryptionInfo".into(), "EncryptedPackage".into()]));
assert!(is_encrypted(&b));
// A PowerPoint 97-2003 .ppt is a compound file too, without the encryption streams.
assert!(!is_encrypted(&build(&["PowerPoint Document", "Current User"])));
+24 -38
View File
@@ -255,46 +255,11 @@ pub fn sidecar_part(name: &str) -> bool {
}
pub fn dir_of(part: &str) -> String {
let p = part.trim_start_matches('/');
match p.rfind('/') {
Some(i) => p.get(..i).unwrap_or("").to_string(),
None => String::new(),
}
craft_opc::dir_of(part).to_owned()
}
pub fn file_of(part: &str) -> &str {
part.rsplit('/').next().unwrap_or(part)
}
pub fn rels_path(part: &str) -> String {
let p = part.trim_start_matches('/');
let dir = dir_of(p);
let file = file_of(p);
if dir.is_empty() { format!("_rels/{file}.rels") } else { format!("{dir}/_rels/{file}.rels") }
}
fn percent_decode(s: &str) -> String {
let b = s.as_bytes();
let mut out = Vec::with_capacity(b.len());
let mut i = 0;
while i < b.len() {
let c = b.get(i).copied().unwrap_or(0);
if c == b'%'
&& let Some(h) = b
.get(i + 1..i + 3)
.filter(|h| h.iter().all(u8::is_ascii_hexdigit))
.and_then(|h| std::str::from_utf8(h).ok())
.and_then(|h| u8::from_str_radix(h, 16).ok())
{
out.push(h);
i += 3;
continue;
}
out.push(c);
i += 1;
}
String::from_utf8_lossy(&out).into_owned()
}
use craft_opc::percent_decode;
pub use craft_opc::{file_of, rels_path};
/// Resolve a relative target against a base directory into a part name.
pub fn resolve(base: &str, target: &str) -> String {
@@ -469,6 +434,27 @@ impl PackageOut {
mod tests {
use super::*;
#[test]
fn shared_names_preserve_relationship_wire_policy() {
for (part, dir, file, rels) in [
("", "", "", "_rels/.rels"),
("/", "", "", "_rels/.rels"),
("///ppt/slides/slide1.xml", "ppt/slides", "slide1.xml", "ppt/slides/_rels/slide1.xml.rels"),
("ppt/", "ppt", "", "ppt/_rels/.rels"),
("é/😀.xml", "é", "😀.xml", "é/_rels/😀.xml.rels"),
] {
assert_eq!(dir_of(part), dir);
assert_eq!(file_of(part), file);
assert_eq!(rels_path(part), rels);
}
assert_eq!(percent_decode("a+b%20c%2Fd%23e"), "a+b c/d#e");
assert_eq!(percent_decode("% %1 %zz %+1 %ff"), "% %1 %zz %+1 �");
// Keep Deck's policy: strip the raw fragment first, then decode percent escapes once.
assert_eq!(resolve("ppt/slides", "../media/a%23b.png#ignored"), "ppt/media/a#b.png");
assert_eq!(resolve("ppt/slides", "%252e%252e/a"), "ppt/slides/%2e%2e/a");
assert_eq!(resolve("ppt/slides", "%2e%2e/%2e%2e/%2e%2e/a"), "a");
}
#[test]
fn resolve_keeps_encoded_hash_and_strips_fragment() {
assert_eq!(resolve("ppt/slides", "../media/a%23b.png"), "ppt/media/a#b.png");
+22 -48
View File
@@ -1,59 +1,33 @@
//! A minimal PNG encoder for the placeholder image written when a picture's media is missing.
//! The placeholder image written when a picture's media is missing: a 1×1 fully transparent RGBA
//! PNG, kept as its fixed bytes (signature, IHDR, one stored-deflate IDAT scanline, IEND) so the
//! app carries no PNG encoder of its own.
fn crc32(data: &[u8]) -> u32 {
let mut c = 0xFFFF_FFFFu32;
for b in data {
c ^= *b as u32;
for _ in 0..8 {
c = if c & 1 != 0 { 0xEDB8_8320 ^ (c >> 1) } else { c >> 1 };
}
}
!c
}
fn adler32(data: &[u8]) -> u32 {
let (mut a, mut b) = (1u32, 0u32);
for x in data {
a = (a + *x as u32) % 65521;
b = (b + a) % 65521;
}
(b << 16) | a
}
fn chunk(out: &mut Vec<u8>, kind: &[u8; 4], data: &[u8]) {
out.extend_from_slice(&(data.len() as u32).to_be_bytes());
let mut c = Vec::with_capacity(data.len() + 4);
c.extend_from_slice(kind);
c.extend_from_slice(data);
out.extend_from_slice(&c);
out.extend_from_slice(&crc32(&c).to_be_bytes());
}
/// The PNG file, byte for byte what the former local encoder produced.
const TRANSPARENT_1X1: [u8; 73] = [
0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0x00, 0x00, 0x00, 0x0D, 0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
0x08, 0x06, 0x00, 0x00, 0x00, 0x1F, 0x15, 0xC4, 0x89, 0x00, 0x00, 0x00, 0x10, 0x49, 0x44, 0x41, 0x54, 0x78, 0x01, 0x01, 0x05, 0x00, 0xFA, 0xFF,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x01, 0x64, 0x78, 0x95, 0x38, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4E, 0x44, 0xAE, 0x42, 0x60,
0x82,
];
/// A 1×1 fully transparent RGBA PNG.
pub fn transparent_1x1() -> Vec<u8> {
let mut out = b"\x89PNG\r\n\x1a\n".to_vec();
let mut ihdr = vec![];
ihdr.extend_from_slice(&1u32.to_be_bytes());
ihdr.extend_from_slice(&1u32.to_be_bytes());
ihdr.extend_from_slice(&[8, 6, 0, 0, 0]);
chunk(&mut out, b"IHDR", &ihdr);
// One scanline: filter byte + RGBA, stored (uncompressed) deflate block.
let raw = [0u8, 0, 0, 0, 0];
let mut z = vec![0x78, 0x01, 0x01];
z.extend_from_slice(&(raw.len() as u16).to_le_bytes());
z.extend_from_slice(&(!(raw.len() as u16)).to_le_bytes());
z.extend_from_slice(&raw);
z.extend_from_slice(&adler32(&raw).to_be_bytes());
chunk(&mut out, b"IDAT", &z);
chunk(&mut out, b"IEND", &[]);
out
TRANSPARENT_1X1.to_vec()
}
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used)]
#[test]
fn crc_known() {
assert_eq!(super::crc32(b"IEND"), 0xAE42_6082);
assert!(super::transparent_1x1().starts_with(b"\x89PNG"));
fn placeholder_is_a_transparent_1x1_png() {
let png = super::transparent_1x1();
assert!(png.starts_with(b"\x89PNG\r\n\x1a\n"));
// IHDR: 1×1, 8-bit RGBA, no interlace.
assert_eq!(&png[12..16], b"IHDR");
assert_eq!(&png[16..29], &[0, 0, 0, 1, 0, 0, 0, 1, 8, 6, 0, 0, 0]);
assert!(png.ends_with(b"IEND\xAE\x42\x60\x82"));
// The stored scanline: filter byte 0, then one pixel with zero alpha.
assert_eq!(&png[49..54], &[0, 0, 0, 0, 0]);
}
}
+111
View File
@@ -25,11 +25,24 @@ use crate::PptxError;
use crate::opc::{self, Package, Rels};
use crate::xml::{Doc, El, Node};
/// A snapshot of the import state a discarded read rolls back to.
pub struct Mark {
diagram_xml_bytes: usize,
media: usize,
media_keys: usize,
tag_bytes: usize,
tags_capped: bool,
kept_sidecar_bytes: usize,
kept_chart_keys: usize,
}
/// Import state shared by all parts.
pub struct Imp<'a> {
pub pkg: &'a Package,
pub media: Vec<MediaItem>,
pub media_by_part: HashMap<String, MediaId>,
/// Keys added to `media_by_part`, in order, so a rollback removes only its own.
pub media_keys: Vec<String>,
pub next: u32,
pub slide_by_part: HashMap<String, SlideId>,
pub custom_show_names: HashMap<String, String>,
@@ -45,6 +58,8 @@ pub struct Imp<'a> {
pub chart_points_cap: usize,
/// Cached kept sidecars by normalized chart part name.
pub kept_charts: HashMap<String, deckcraft_model::chart::ChartKept>,
/// Keys added to `kept_charts`, in order, for rollback.
pub kept_chart_keys: Vec<String>,
/// Chart parts whose sidecar capture was refused, with the retained-byte total it started from:
/// the same start gives the same refusal, so the copy is not repeated.
pub rejected_kept: HashMap<String, usize>,
@@ -56,6 +71,12 @@ pub struct Imp<'a> {
pub tag_bytes: usize,
/// The tag budget ran out and the warning was given.
pub tags_capped: bool,
/// Bytes of preserved theme XML kept by the masters read so far.
pub theme_extra_bytes: usize,
/// Shapes read from SmartArt drawings so far (see `shapes::MAX_SMARTART_SHAPES`).
pub smartart_shapes: usize,
/// Bytes of SmartArt layout, style and colour definitions copied into diagrams so far.
pub diagram_xml_bytes: usize,
/// Whether a part has relationships of its own, by normalized part name: looked up once
/// however many embedded objects point at the part.
pub has_rels: HashMap<String, bool>,
@@ -77,9 +98,41 @@ impl Imp<'_> {
let content_type = self.pkg.content_type(part).filter(|c| !c.is_empty()).unwrap_or_else(|| crate::mime_for(&name).to_string());
let id = MediaId(self.alloc());
self.media.push(MediaItem { id, name, content_type, data: Arc::new(data), link: None });
self.media_keys.push(key.clone());
self.media_by_part.insert(key, id);
Some(id)
}
/// What a discarded read must give back: the budgets it charged and the media and kept-chart
/// entries it added (see [`Imp::rollback`]).
pub fn mark(&self) -> Mark {
Mark {
diagram_xml_bytes: self.diagram_xml_bytes,
media: self.media.len(),
media_keys: self.media_keys.len(),
tag_bytes: self.tag_bytes,
tags_capped: self.tags_capped,
kept_sidecar_bytes: self.kept_sidecar_bytes,
kept_chart_keys: self.kept_chart_keys.len(),
}
}
/// Undo everything since `m`: only the entries added since are removed, so the cost follows
/// what the discarded read added, not the size of the caches.
pub fn rollback(&mut self, m: &Mark) {
self.diagram_xml_bytes = m.diagram_xml_bytes;
self.tag_bytes = m.tag_bytes;
self.tags_capped = m.tags_capped;
self.kept_sidecar_bytes = m.kept_sidecar_bytes;
self.media.truncate(m.media);
for k in self.media_keys.drain(m.media_keys..) {
self.media_by_part.remove(&k);
}
for k in self.kept_chart_keys.drain(m.kept_chart_keys..) {
self.kept_charts.remove(&k);
}
// Chart decode work (`chart_decode_bytes`, `chart_points`) stays charged: it was done, and
// giving it back would let a discarded read repeat it. `rejected_kept` is keyed by the
// retained total a refusal started from, so it stays valid after the rollback.
}
/// Media item for an external link.
pub fn media_link(&mut self, url: &str) -> MediaId {
if let Some(m) = self.media.iter().find(|m| m.link.as_deref() == Some(url)) {
@@ -529,6 +582,7 @@ pub fn import_theme(bytes: &[u8]) -> Result<(deckcraft_model::theme::Theme, Vec<
pkg: &pkg,
media: vec![],
media_by_part: HashMap::new(),
media_keys: vec![],
next: 0,
slide_by_part: HashMap::new(),
custom_show_names: HashMap::new(),
@@ -538,11 +592,15 @@ pub fn import_theme(bytes: &[u8]) -> Result<(deckcraft_model::theme::Theme, Vec<
chart_points: 0,
chart_points_cap: chart::MAX_PRESENTATION_CHART_POINTS,
kept_charts: HashMap::new(),
kept_chart_keys: vec![],
rejected_kept: HashMap::new(),
chart_decode_bytes: 0,
tags_by_part: HashMap::new(),
tag_bytes: 0,
tags_capped: false,
theme_extra_bytes: 0,
smartart_shapes: 0,
diagram_xml_bytes: 0,
has_rels: HashMap::new(),
};
let part = Part::new(&pkg, &theme_path, &doc);
@@ -589,6 +647,7 @@ pub(crate) fn import_with_chart_points(bytes: &[u8], chart_points_cap: usize) ->
pkg: &pkg,
media: vec![],
media_by_part: HashMap::new(),
media_keys: vec![],
next: max_id.max(1),
slide_by_part: HashMap::new(),
custom_show_names: HashMap::new(),
@@ -598,11 +657,15 @@ pub(crate) fn import_with_chart_points(bytes: &[u8], chart_points_cap: usize) ->
chart_points: 0,
chart_points_cap,
kept_charts: HashMap::new(),
kept_chart_keys: vec![],
rejected_kept: HashMap::new(),
chart_decode_bytes: 0,
tags_by_part: HashMap::new(),
tag_bytes: 0,
tags_capped: false,
theme_extra_bytes: 0,
smartart_shapes: 0,
diagram_xml_bytes: 0,
has_rels: HashMap::new(),
};
// Slide ids first so hyperlinks anywhere can point at slides.
@@ -1545,6 +1608,54 @@ fn header_footer(p: &Presentation) -> HeaderFooter {
hf
}
#[cfg(test)]
mod rollback_tests {
use super::*;
/// A rolled-back read gives back its budgets and removes only the media and kept-chart entries it added.
#[test]
fn rollback_restores_budgets_and_removes_only_what_was_added() {
let bytes = crate::export(&deckcraft_model::Presentation::default()).expect("export");
let pkg = Package::open(&bytes).expect("package");
let mut imp = Imp {
pkg: &pkg,
media: vec![],
media_by_part: HashMap::new(),
media_keys: vec![],
next: 0,
slide_by_part: HashMap::new(),
custom_show_names: HashMap::new(),
table_style_ids: Vec::new(),
vml_previews: HashMap::new(),
kept_sidecar_bytes: 0,
chart_points: 0,
chart_points_cap: chart::MAX_PRESENTATION_CHART_POINTS,
kept_charts: HashMap::new(),
kept_chart_keys: vec![],
rejected_kept: HashMap::new(),
chart_decode_bytes: 0,
tags_by_part: HashMap::new(),
tag_bytes: 0,
tags_capped: false,
theme_extra_bytes: 0,
smartart_shapes: 0,
diagram_xml_bytes: 0,
has_rels: HashMap::new(),
};
let kept_before = imp.media_for("ppt/presentation.xml").expect("media");
let (m, items) = (imp.mark(), imp.media.len());
assert!(imp.media_for("ppt/presProps.xml").is_some());
imp.kept_chart_keys.push("ppt/charts/chart1.xml".into());
imp.kept_charts.insert("ppt/charts/chart1.xml".into(), Default::default());
(imp.diagram_xml_bytes, imp.tag_bytes, imp.tags_capped, imp.kept_sidecar_bytes) = (7, 5, true, 9);
imp.rollback(&m);
assert_eq!(imp.media.len(), items);
assert_eq!(imp.media_by_part.get("ppt/presentation.xml"), Some(&kept_before));
assert!(!imp.media_by_part.contains_key("ppt/presprops.xml") && imp.kept_charts.is_empty() && imp.kept_chart_keys.is_empty());
assert_eq!((imp.diagram_xml_bytes, imp.tag_bytes, imp.tags_capped, imp.kept_sidecar_bytes), (0, 0, false, 0));
}
}
#[cfg(test)]
mod tests {
use super::*;
+1
View File
@@ -600,6 +600,7 @@ pub(crate) fn capture_kept(imp: &mut super::Imp, chart_part: &str) -> deckcraft_
return ChartKept::default();
}
imp.kept_sidecar_bytes += rel_total;
imp.kept_chart_keys.push(key.clone());
imp.kept_charts.insert(key, kept.clone());
kept
}
+92 -21
View File
@@ -474,20 +474,54 @@ fn frame(imp: &mut Imp, part: &Part, ctx: &mut IdCtx, e: &El, depth: usize) -> S
};
// Keep the parts it points to so a save writes it back whole (#203). A part with relationships
// of its own, or an external link, can't be carried: the save then falls back to the preview.
let parts = super::rel_refs(e)
.into_iter()
.map(|id| {
let rel = part.rels.get(&id).filter(|r| !r.external)?;
let pkg = imp.pkg;
if *imp.has_rels.entry(crate::opc::norm(&rel.target)).or_insert_with(|| !pkg.rels(&rel.target).items.is_empty()) {
return None;
// Validate every relationship (and charge the budget) before copying anything, so a fallback
// that cannot be kept whole copies no part at all.
let mark = imp.mark();
let mut planned = Vec::new();
let mut spent = imp.diagram_xml_bytes;
let mut ok = true;
for id in super::rel_refs(e) {
let Some(rel) = part.rels.get(&id).filter(|r| !r.external) else {
ok = false;
break;
};
let pkg = imp.pkg;
if *imp.has_rels.entry(crate::opc::norm(&rel.target)).or_insert_with(|| !pkg.rels(&rel.target).items.is_empty()) {
ok = false;
break;
}
// A diagram's definition parts copied here count against the same presentation-wide budget.
if rel.kind.starts_with("diagram") && !imp.media_by_part.contains_key(&crate::opc::norm(&rel.target)) {
let len = pkg.get(&rel.target).map_or(0, |b| b.len());
if len > MAX_DIAGRAM_PART_BYTES || spent.saturating_add(len) > MAX_DIAGRAM_XML_BYTES {
ok = false;
break;
}
let (kind, target) = (rel.ty.clone(), rel.target.clone());
let media = if rel.kind == "diagramData" { diagram_data(imp, &target) } else { imp.media_for(&target) };
Some((id, kind, media?))
})
.collect::<Option<Vec<_>>>()
.unwrap_or_default();
spent += len;
}
if pkg.get(&rel.target).is_none() {
ok = false;
break;
}
planned.push((id, rel.ty.clone(), rel.target.clone(), rel.kind == "diagramData"));
}
let parts = if ok {
imp.diagram_xml_bytes = spent;
let copied: Option<Vec<_>> = planned
.into_iter()
.map(|(id, kind, target, data)| {
let media = if data { diagram_data(imp, &target) } else { imp.media_for(&target) };
Some((id, kind, media?))
})
.collect();
if copied.is_none() {
imp.rollback(&mark);
}
copied
} else {
None
};
let parts = parts.unwrap_or_default();
s.kind = ShapeKind::Opaque { xml: part.keep(e), preview, label, parts };
s
}
@@ -558,13 +592,28 @@ fn diagram_data(imp: &mut Imp, target: &str) -> Option<deckcraft_model::MediaId>
data: std::sync::Arc::new(xml.into_bytes()),
link: None,
});
imp.media_keys.push(norm_target.clone());
imp.media_by_part.insert(norm_target, id);
Some(id)
}
/// Shapes all SmartArt drawings of one presentation may add; a frame read after that is left as a
/// placeholder. Each frame that references a drawing reads it again.
const MAX_SMARTART_SHAPES: usize = 250_000;
/// SmartArt definition XML (layout, style, colours) all diagrams of one presentation may copy.
const MAX_DIAGRAM_XML_BYTES: usize = 32 << 20;
/// The largest single diagram definition part copied.
const MAX_DIAGRAM_PART_BYTES: usize = 4 << 20;
fn count_shapes(shapes: &[Shape]) -> usize {
shapes.iter().map(|s| 1 + count_shapes(s.children())).sum()
}
/// SmartArt: read the pre-drawn shapes of its drawing part as a group.
fn smartart(imp: &mut Imp, part: &Part, gd: &El, frame: &Shape, depth: usize) -> Option<Shape> {
if depth > 8 {
if depth > 8 || imp.smartart_shapes >= MAX_SMARTART_SHAPES {
return None;
}
let rel_ids = gd.child("relIds")?;
@@ -576,10 +625,21 @@ fn smartart(imp: &mut Imp, part: &Part, gd: &El, frame: &Shape, depth: usize) ->
let dpart = Part::new(imp.pkg, &drawing_rel, &d);
let tree = d.root.child("spTree")?;
let mut sub = IdCtx { fresh: true, ..Default::default() };
let before = imp.smartart_shapes;
let mark = imp.mark();
let children = sp_tree(imp, &dpart, &mut sub, tree, depth + 1);
if children.is_empty() {
return None;
}
// Counted once here, nested SmartArt included: a drawing that frames reuse counts every time it is read.
let total = before.saturating_add(count_shapes(&children));
if total > MAX_SMARTART_SHAPES {
// Over the presentation's remaining budget: a placeholder, and nothing charged, nested SmartArt included.
imp.smartart_shapes = before;
imp.rollback(&mark);
return None;
}
imp.smartart_shapes = total;
let children = smartart_text_rects(imp, &mut sub, tree, children, depth + 1);
let mut g = frame.clone();
let x = frame.xfrm.unwrap_or_default();
@@ -668,10 +728,11 @@ fn text_on_rect(imp: &mut Imp, ctx: &mut IdCtx, s: &mut Shape, t: Xfrm) -> Optio
return None;
}
}
if ctx.count >= MAX_SHAPES {
if ctx.count >= MAX_SHAPES || imp.smartart_shapes >= MAX_SMARTART_SHAPES {
return None;
}
ctx.count += 1;
imp.smartart_shapes += 1;
let text = s.text.take();
// No fill, outline or effects; the style keeps only the text colour and font.
let style = s.style.clone().map(|mut st| {
@@ -707,15 +768,22 @@ fn text_area(geom: &Geom, w: f64, h: f64) -> deckcraft_geom::Rect {
/// The outline of a SmartArt graphic (for the Text Pane), with its layout, quick style and colour
/// parts kept to be written back.
fn diagram_outline(imp: &Imp, part: &Part, rel_ids: &El, data: &El) -> Option<deckcraft_model::Diagram> {
fn diagram_outline(imp: &mut Imp, part: &Part, rel_ids: &El, data: &El) -> Option<deckcraft_model::Diagram> {
let nodes = crate::dgm::outline(data);
if nodes.is_empty() {
return None;
}
let (pkg, spent) = (imp.pkg, std::cell::Cell::new(imp.diagram_xml_bytes));
let raw = |attr: &str| -> Option<String> {
let rel = part.rels.get(rel_ids.attr(attr)?)?;
let bytes = imp.pkg.get(&rel.target)?;
(bytes.len() <= 4 << 20).then(|| String::from_utf8(bytes.to_vec()).ok()).flatten()
let bytes = pkg.get(&rel.target)?;
// Every diagram copies its definitions, so the copies share one presentation-wide budget.
if bytes.len() > MAX_DIAGRAM_PART_BYTES || spent.get().saturating_add(bytes.len()) > MAX_DIAGRAM_XML_BYTES {
return None;
}
let xml = String::from_utf8(bytes.to_vec()).ok()?;
spent.set(spent.get() + xml.len());
Some(xml)
};
let layout_xml = raw("r:lo");
let (layout_id, cat) = layout_xml
@@ -736,16 +804,19 @@ fn diagram_outline(imp: &Imp, part: &Part, rel_ids: &El, data: &El) -> Option<de
let pr = data.path(&["ptLst"]).and_then(|l| l.children_named("pt").find(|p| p.attr("type") == Some("doc"))).and_then(|p| p.child("prSet"));
let style = crate::dgm::style_for(pr.and_then(|p| p.attr("qsTypeId")).unwrap_or("")).to_string();
let colors = crate::dgm::colors_for(pr.and_then(|p| p.attr("csTypeId")).unwrap_or(""));
let (style_xml, colors_xml) = (raw("r:qs"), raw("r:cs"));
imp.diagram_xml_bytes = spent.get();
Some(deckcraft_model::Diagram {
kind: crate::dgm::kind_for(&id, &cat).to_string(),
nodes,
style,
colors,
imported: true,
layout_id: id,
// Without the layout part the writer generates one for `kind`; empty keeps data's loTypeId in step with it.
layout_id: if layout_xml.is_some() { id } else { String::new() },
layout_xml,
style_xml: raw("r:qs"),
colors_xml: raw("r:cs"),
style_xml,
colors_xml,
})
}
+10 -1
View File
@@ -20,6 +20,10 @@ fn font_set(e: Option<&El>) -> FontSet {
FontSet { latin: tf("latin"), ea: tf("ea"), cs: tf("cs"), scripts }
}
/// Bytes of preserved theme XML (object defaults and extra colour schemes) all masters of one
/// presentation may keep.
const MAX_THEME_EXTRA_BYTES: usize = 16 << 20;
pub fn read_theme(imp: &mut Imp, part: &Part, root: &El) -> Theme {
let mut t = Theme { name: root.attr("name").unwrap_or("Theme").to_string(), ..Default::default() };
let Some(te) = root.child("themeElements") else { return t };
@@ -89,8 +93,13 @@ pub fn read_theme(imp: &mut Imp, part: &Part, root: &El) -> Theme {
.filter(|e| !super::has_rel_refs(e))
.map(|e| part.keep(e))
.collect();
if !extra.is_empty() {
// Every master that references this theme keeps its own copy of the preserved XML, so the
// copies share one budget for the presentation.
if !extra.is_empty() && imp.theme_extra_bytes.saturating_add(extra.len()) <= MAX_THEME_EXTRA_BYTES {
imp.theme_extra_bytes += extra.len();
t.raw_extra = Some(extra);
} else if !extra.is_empty() {
log::warn!("pptx: theme object defaults not kept; the preserved-XML budget is spent");
}
t
}
+33 -39
View File
@@ -354,45 +354,8 @@ fn decode_utf16(bytes: &[u8]) -> String {
}
}
/// Is `c` allowed in XML 1.0 text?
fn xml_char(c: char) -> bool {
matches!(c, '\t' | '\n' | '\r') || (c >= ' ' && c != '\u{FFFE}' && c != '\u{FFFF}')
}
/// Escape text content (and drop characters XML 1.0 forbids).
pub fn esc(s: &str) -> String {
let mut o = String::with_capacity(s.len());
for c in s.chars() {
match c {
'&' => o.push_str("&amp;"),
'<' => o.push_str("&lt;"),
'>' => o.push_str("&gt;"),
'\r' => o.push_str("&#13;"),
c if xml_char(c) => o.push(c),
_ => {}
}
}
o
}
/// Escape an attribute value.
pub fn esc_attr(s: &str) -> String {
let mut o = String::with_capacity(s.len());
for c in s.chars() {
match c {
'&' => o.push_str("&amp;"),
'<' => o.push_str("&lt;"),
'>' => o.push_str("&gt;"),
'"' => o.push_str("&quot;"),
'\n' => o.push_str("&#10;"),
'\r' => o.push_str("&#13;"),
'\t' => o.push_str("&#9;"),
c if xml_char(c) => o.push(c),
_ => {}
}
}
o
}
// Preserve the public writer helpers while sharing the XML 1.0 escaping rules.
pub use craft_xml::{esc, esc_attr};
/// A string builder for XML parts.
#[derive(Default)]
@@ -542,6 +505,37 @@ mod tests {
assert_eq!(esc_attr("\"x\"\n"), "&quot;x&quot;&#10;");
}
#[test]
fn shared_escaping_preserves_xml_wire_bytes() {
let text = "&<>\"'\t\n\r\0\u{b}\u{fffe}\u{ffff}é😀&#13;";
assert_eq!(esc(text), "&amp;&lt;&gt;\"'\t\n&#13;é😀&amp;#13;");
assert_eq!(esc_attr(text), "&amp;&lt;&gt;&quot;'&#9;&#10;&#13;é😀&amp;#13;");
assert_eq!(esc(""), "");
assert_eq!(esc_attr(""), "");
for code in 0..32 {
let c = char::from_u32(code).unwrap();
let text = c.to_string();
match c {
'\t' => {
assert_eq!(esc(&text), "\t");
assert_eq!(esc_attr(&text), "&#9;");
}
'\n' => {
assert_eq!(esc(&text), "\n");
assert_eq!(esc_attr(&text), "&#10;");
}
'\r' => {
assert_eq!(esc(&text), "&#13;");
assert_eq!(esc_attr(&text), "&#13;");
}
_ => {
assert_eq!(esc(&text), "");
assert_eq!(esc_attr(&text), "");
}
}
}
}
#[test]
fn roundtrip_serialize() {
let d = parse(b"<p:sp a=\"1\"><p:t>x &amp; y</p:t><e/></p:sp>").unwrap();
+19 -9
View File
@@ -32,16 +32,11 @@ Coordinates are slide points (1/72 inch; a 16:9 slide is 960 × 540) unless note
| `engine.execute` / `ui.menu.invoke` / `command` | `{command, params}` | Run any command (see `engine.commands`; `deckcraft-cli describe COMMAND` documents one) |
| `engine.commands` | — | Every command: id, label, menu path, shortcut, params doc, enabled / disabled reason |
| `document.inspect` | — | Slides, sections, layouts, shapes, selection |
| `slide.actions` | `{index?}` | Actions on one slide; returns `{index, slideId, actions}`. Each action has an `owner` (shape id/name and group path; text actions also include paragraph/run indexes and run text, plus table row/cell indexes for table text), `event` (`click`, `hover`, `textLink`, or `textHover`), action `type`, `target`, and the full `hyperlink`. Listing is read-only and never executes an action. An empty slide returns `"actions": []`. |
| `ui.inspect` | — | UI state, active tool, window/canvas/slide rects, dialog, `home` (the File tab open over a presentation), `backstage` (its page, also the start screen), slide show state (`grid`, `zoomArm`, `zoom`, `blank`, `presenterPaused`, `presenterSecs`, `notesPx`, `custom`, `goto`; `cells` while See All Slides is open), documents, perf (fps, render ms) |
| `ui.inspect` | — | UI state, active tool, window/canvas/slide rects, dialog, `home` (the File tab open over a presentation), `backstage` (its page, also the start screen), slide show state, `animPreview` (canvas playback: slide, time, duration), documents, perf (fps, render ms) |
| `ui.inspect` | — | UI state, active tool, window/canvas/slide rects, dialog, `home` (the File tab over an open presentation), `backstage` (the current File page, including the start screen), slide show state (`grid`, `zoomArm`, `zoom`, `blank`, `presenterPaused`, `presenterSecs`, `notesPx`, `custom`, `goto`; `cells` when See All Slides is open), `animPreview` (canvas playback: slide, time, duration), documents, perf (fps, render ms) |
| `ui.tool.select` | `{tool, preset?}` | `select`, `text`, `shape` + preset, any preset name, `curve`, `freeform`, `scribble`, `pen`, `highlighter`, `eraser` |
| `ui.pointer` | `{events: [{kind: down\|drag\|up\|move\|doubleclick\|tripleclick\|contextclick, x, y, mods?}], mods?}` | Drive the active tool in slide points through the same code path as the mouse (`contextclick`: the right-button press that selects before the context menu) |
| `ui.key` / `ui.text` | `{key, shift?, alt?, cmd?}` / `{text}` | Keyboard input (also drives a running slide show: digits then Enter go to that slide, G is See All Slides, Z arms zoom, T pauses the presenter timer, R resets it, `[` and `]` change notes size, Esc clears a slide number, the grid and zoom before it leaves the show) |
| `ui.pointer` | `{events: [{kind: down\|drag\|up\|move\|doubleclick\|tripleclick, x, y, mods?}], mods?}` | Drive the active tool in slide points through the same code path as the mouse |
| `ui.key` / `ui.text` | `{key, shift?, alt?, cmd?}` / `{text}` | Keyboard input (also drives a running slide show; Escape stops the canvas animation preview) |
| `ui.pointer` | `{events: [{kind: down\|drag\|up\|move\|doubleclick\|tripleclick, x, y, mods?, pressure?}], mods?}` | Drive the active tool in slide points through the same code path as the mouse. `pressure` is `0..=1` for a pen; omit it for a mouse |
| `ui.key` / `ui.text` | `{key, shift?, alt?, cmd?}` / `{text}` | Keyboard input (also drives a running slide show) |
| `ui.pointer` | `{events: [{kind: down\|drag\|up\|move\|doubleclick\|tripleclick\|contextclick, x, y, mods?, pressure?}], mods?}` | Send slide-point pointer events through the active tool's mouse path. `contextclick` performs the right-click selection used by context menus; `pressure` is `0..=1` for a pen and can be omitted for a mouse |
| `ui.key` | `{key, shift?, alt?, cmd?}` | Send a key press. During an active slide show, digits followed by Enter jump to that slide; G opens See All Slides, Z arms zoom, T toggles the presenter timer's pause, R resets it, and `[` / `]` resize notes. Esc clears a typed slide number or backs out of the grid/zoom before ending the active show. Close See All Slides with Esc or G before using the other listed show shortcuts. Slide-show keys ignore modifier flags; use `show.end` to leave the end-of-show screen. Outside a show, Escape stops canvas animation preview |
| `ui.text` | `{text}` | Insert into the current text edit. With one shape selected and no active text edit, begin editing and replace the shape's existing text |
| `ui.ime` | `{preedit, active?: [start, end]}` / `{commit}` | An input method's composition through egui, as a real one arrives: shown in place on the slide or in a focused field; `{"preedit": ""}` cancels |
| `ui.move` / `ui.click` / `ui.drag` | screen points | Real egui pointer input — reaches every widget, menu and pane |
| `ui.set` | `{tab?, view?, pane?, notes?, zoom?, brightness?, ruler?, gridlines?, guides?, …}` | UI state (returns the full state) |
@@ -54,3 +49,18 @@ Coordinates are slide points (1/72 inch; a 16:9 slide is 960 × 540) unless note
The MCP server (`deckcraft-cli mcp`, see [mcp.md](mcp.md)) wraps the same methods for Claude
and other agents; `deckcraft-cli app --method METHOD [PARAMS]` sends one request from a shell.
## Inspecting slide actions
Run the `slide.actions` engine command through `engine.execute`:
```json
{"id": 2, "method": "engine.execute", "params": {"command": "slide.actions", "params": {"index": 0}}}
```
`index` is zero-based and optional; omitting it inspects the selected slide. The reply's `result`
contains `{index, slideId, actions}`. Each action includes an `owner` with the shape id/name and
its group path; text actions also identify the paragraph/run and run text, plus the table row/cell
for table text. Actions report their `event` (`click`, `hover`, `textLink`, or `textHover`),
`type`, `target`, and full `hyperlink`. Inspection never runs an action. A slide without actions
returns `"actions": []`.
+4 -2
View File
@@ -1,6 +1,6 @@
# Slide show and presenter view: parity with PowerPoint
> **Last reviewed:** 2026-10-14 · **Last updated:** 2026-11-02 · **Change:** minor (deleting slides removes them from custom shows; previous: minor, Presenter View only with a second display on Linux and the BSDs, #1156; previous: minor, Set Up Slide Show ▸ Keep mouse cursor visible, #1445; previous: minor, Ctrl+wheel zooms the show around the pointer, #1286; previous: major, community PR wave 2026-10-14: interactive decks, laser pointer, See All Slides and zoom, go-to-slide number, custom show playback, presenter timer, clock, notes size and keyboard, Show Media Controls, swipe; breadth 68%; duplicated rows and headers folded; previous: major, created) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
> **Last reviewed:** 2026-10-14 · **Last updated:** 2026-11-14 · **Change:** minor (a slide the show advances to again plays its animations again, #2090; previous: minor, deleting slides removes them from custom shows; previous: minor, Presenter View only with a second display on Linux and the BSDs, #1156; previous: minor, Set Up Slide Show ▸ Keep mouse cursor visible, #1445; previous: minor, Ctrl+wheel zooms the show around the pointer, #1286; previous: major, community PR wave 2026-10-14: interactive decks, laser pointer, See All Slides and zoom, go-to-slide number, custom show playback, presenter timer, clock, notes size and keyboard, Show Media Controls, swipe; breadth 68%; duplicated rows and headers folded; previous: major, created) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
Presenting is the job PowerPoint is hired for. This doc covers the show window, presenter view,
rehearsal and recording. Transition and animation playback are in
@@ -23,7 +23,8 @@ ready** (estimated), **10–16 h** to parity.
| Hidden slides skipped | yes | yes | |
| Hyperlinks and action settings followed (slides, web, mail, End Show, Last Viewed) | yes | yes | Only `http(s)` and `mailto` open outside the show, by design (`safe_url`) |
| A shape with a triggered animation plays it when clicked; shapes an animation has hidden cannot be clicked; a shape without an action on top of one with an action blocks it; the pointer is a hand over what can be clicked | yes | yes | Click boxes are bounding boxes; "play sound" actions (`ppaction://media`) do nothing yet |
| A slide the show returns to (link, arrow keys) looks as it was left; a triggered animation goes on where it stopped | yes | yes | A main-sequence step still playing when the show leaves is finished |
| A slide the show returns to by a link or Back looks as it was left; a triggered animation goes on where it stopped | yes | yes | A main-sequence step still playing when the show leaves is finished |
| A slide the show advances to again (click, →, Space, automatic advance, loop) starts over and plays its animations again | yes | yes | Its triggered animations start over too (#2090) |
| "Advance on click" off: a click never leaves the slide (animation steps still play, keys still move on) | yes | yes | |
| Hyperlinks and action settings followed (slides, web, mail, End Show, Last Viewed, Custom Show) | yes | yes | Only `http(s)` and `mailto` open outside the show, by design (`safe_url`). A Custom Show action plays that show |
| Media playback with controls, play across slides, full-screen video, Play/Pause/Stop in the click sequence | yes | yes | WMA/WMV not decodable. Click sequence since #116. Slide Show ▸ Show Media Controls (on by default) hides the playback bar. Seeks and loops preserve new-generation video frames and end-of-stream; queue regression and repeated seeks across H.264/HEVC/VP9/AV1 in `crates/media` |
@@ -96,4 +97,5 @@ Reading View in a window with navigation: present (checklist row done).
| 2026-10-14 | minor | See All Slides (G) and click-to-zoom (Z) during the show. Presenter view opens that grid and sets black, white and zoom. Checklist breadth stays 66% |
| 2026-10-24 | minor | Ctrl+wheel (Cmd+wheel on a Mac) zooms the show in and out around the pointer, up to 4×; the plain wheel still turns the page (#1286) |
| 2026-10-23 | trivial | Presenter view draws the notes with their formatting (bullets, numbers, indents, bold/italic) instead of plain text (#1128) |
| 2026-11-14 | minor | A slide the show advances to again starts over, so its entrance effects play again; Back and links still show it as it was left (#2090) |
| 2026-10-10 | major | Created: show, presenter view, rehearse and record, compared with PowerPoint 16.113's Slide Show tab and menu |
+24 -3
View File
@@ -45,11 +45,20 @@ pub fn validate(v: &str) -> Result<(), String> {
None => (v, None),
};
let nums: Vec<&str> = core.split('.').collect();
if nums.len() != 3 || nums.iter().any(|n| n.is_empty() || !n.bytes().all(|b| b.is_ascii_digit()) || (n.len() > 1 && n.starts_with('0'))) {
if nums.len() != 3
|| nums
.iter()
.any(|n| n.is_empty() || !n.bytes().all(|b| b.is_ascii_digit()) || n.parse::<u64>().is_err() || (n.len() > 1 && n.starts_with('0')))
{
return bad();
}
if let Some(p) = pre
&& (p.is_empty() || p.split('.').any(|id| id.is_empty() || !id.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'-')))
&& (p.is_empty()
|| p.split('.').any(|id| {
id.is_empty()
|| !id.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'-')
|| (id.len() > 1 && id.starts_with('0') && id.bytes().all(|b| b.is_ascii_digit()))
}))
{
return bad();
}
@@ -138,12 +147,24 @@ mod tests {
for ok in ["0.1.0", "1.20.300", "1.0.0-rc.1", "1.0.0-alpha", "1.0.0-x-y.2"] {
assert!(validate(ok).is_ok(), "{ok}");
}
for bad in ["1.0", "1.0.0.0", "v1.0.0", "01.0.0", "1.0.0-", "1.0.0-a..b", "1.0.0+meta", "1.a.0", ""] {
for bad in ["1.0", "1.0.0.0", "v1.0.0", "01.0.0", "1.0.0-", "1.0.0-a..b", "1.0.0+meta", "1.a.0", "18446744073709551616.0.0", ""] {
assert!(validate(bad).is_err(), "{bad}");
}
assert!(replace(MANIFEST, "nope").is_err());
}
#[test]
fn numeric_prerelease_identifiers_have_no_leading_zeroes() {
for bad in ["1.0.0-00", "1.0.0-01", "1.0.0-rc.01"] {
assert!(validate(bad).is_err(), "{bad}");
assert!(replace(MANIFEST, bad).is_err(), "{bad} must not reach the manifest");
}
for ok in ["1.0.0-0", "1.0.0-rc.0", "1.0.0-01a", "1.0.0-0-1"] {
assert!(validate(ok).is_ok(), "{ok}");
assert_eq!(read(&replace(MANIFEST, ok).unwrap()).unwrap(), ok);
}
}
#[test]
fn the_real_manifest_has_a_valid_version() {
let text = std::fs::read_to_string(crate::root().join("Cargo.toml")).unwrap();