Skip to content

AI turns documents or topics into real, native PowerPoint decks—with native shapes, transitions and animations, data-backed charts and tables on demand, audio narration from speaker notes, and support for your own .pptx templates. · by Hugo He

feat(svg-pipeline): add explicit SVG picture extraction

hugohe3f418d990e2a9
diff --git a/skills/ppt-master/scripts/extract_svg_pictures.py b/skills/ppt-master/scripts/extract_svg_pictures.py
new file mode 100644
index 00000000..571933fa
--- /dev/null
+++ b/skills/ppt-master/scripts/extract_svg_pictures.py
@@ -0,0 +1,992 @@
+#!/usr/bin/env python3
+"""
+PPT Master - Explicit SVG Picture Asset Extractor
+
+Extract explicitly selected ``<g id>`` elements from one SVG into tight,
+self-contained SVG picture assets. Each selected group is replaced in place by
+one ``<image>`` at the same parent index, so native export produces one
+PowerPoint ``p:pic`` instead of a DrawingML group.
+
+This tool is intentionally selection-only. It does not discover repeated
+objects, infer Master/Layout structure, or change the native-shape semantics of
+``extract_svg_assets.py``.
+
+Usage:
+ python3 scripts/extract_svg_pictures.py page.svg --select emblem \
+ --images-dir project/images -o project/svg_output/page.svg
+
+Examples:
+ python3 scripts/extract_svg_pictures.py imported/slide_01.svg \
+ --select shape-15 --resource-root imported \
+ --images-dir imported/images --inplace
+ python3 scripts/extract_svg_pictures.py source.svg --select complex-art \
+ --bounds complex-art=80,120,320,240 --images-dir work/images \
+ -o work/normalized.svg
+
+Dependencies:
+ Standard library. Playwright is optional for targets without an explicit
+ ``--bounds`` value or imported ``data-pptx-frame`` metadata.
+
+See workflows/create-template.md and scripts/docs/svg-pipeline.md.
+"""
+
+from __future__ import annotations
+
+import argparse
+import base64
+import copy
+import hashlib
+import json
+import math
+import mimetypes
+import os
+import re
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from urllib.parse import unquote, urlsplit, urlunsplit
+from xml.etree import ElementTree as ET
+
+from console_encoding import configure_utf8_stdio
+
+configure_utf8_stdio()
+
+SVG_NS = "http://www.w3.org/2000/svg"
+XLINK_NS = "http://www.w3.org/1999/xlink"
+GEOMETRY_ROOT_ATTRS = {"viewBox", "width", "height", "x", "y", "transform"}
+PRESERVED_IMAGE_ATTRS = {
+ "aria-label",
+ "data-name",
+ "data-pptx-layer",
+ "data-pptx-role",
+ "data-pptx-shape-name",
+ "id",
+}
+SEMANTIC_MARKERS = {
+ "data-icon",
+ "data-pptx-authoring",
+ "data-pptx-import-source",
+ "data-pptx-placeholder",
+ "data-pptx-replace-with",
+}
+SEMANTIC_PREFIXES = (
+ "data-pptx-fallback-",
+ "data-pptx-native",
+ "data-pptx-placeholder-",
+ "data-pptx-replace",
+)
+VISUAL_TAGS = {
+ "circle",
+ "ellipse",
+ "image",
+ "line",
+ "path",
+ "polygon",
+ "polyline",
+ "rect",
+ "svg",
+ "text",
+ "use",
+}
+UNSAFE_PICTURE_TAGS = {
+ "animate",
+ "animateMotion",
+ "animateTransform",
+ "foreignObject",
+ "script",
+ "set",
+}
+_URL_RE = re.compile(r"url\(\s*(['\"]?)([^)'\"]+)\1\s*\)", re.IGNORECASE)
+_FRAME_SPLIT_RE = re.compile(r"[\s,]+")
+
+ET.register_namespace("", SVG_NS)
+ET.register_namespace("xlink", XLINK_NS)
+
+
+class SvgPictureError(RuntimeError):
+ """Raised when an explicit picture extraction cannot be completed safely."""
+
+
+@dataclass(frozen=True)
+class Bounds:
+ """One positive rectangle in source-root user coordinates."""
+
+ x: float
+ y: float
+ width: float
+ height: float
+
+@dataclass
+class ExtractionPlan:
+ """Prepared output for one selected source group."""
+
+ selector: str
+ asset_path: Path
+ href: str
+ bounds: Bounds
+ bounds_source: str
+ asset_bytes: bytes
+ dependency_ids: list[str]
+ embedded_resources: list[str]
+
+
+def _local(tag: object) -> str:
+ return tag.rsplit("}", 1)[-1] if isinstance(tag, str) else ""
+
+
+def _fmt(value: float) -> str:
+ rounded = round(value, 6)
+ if rounded == 0:
+ rounded = 0.0
+ return f"{rounded:.6f}".rstrip("0").rstrip(".")
+
+
+def _padded_bounds(bounds: Bounds, padding: float) -> Bounds:
+ return Bounds(
+ bounds.x - padding,
+ bounds.y - padding,
+ bounds.width + 2 * padding,
+ bounds.height + 2 * padding,
+ )
+
+
+def _parse_svg(path: Path) -> tuple[ET.ElementTree, ET.Element]:
+ parser = ET.XMLParser(target=ET.TreeBuilder(insert_comments=True))
+ try:
+ tree = ET.parse(path, parser=parser)
+ except (ET.ParseError, OSError) as exc:
+ raise SvgPictureError(f"Cannot parse SVG {path}: {exc}") from exc
+ root = tree.getroot()
+ if _local(root.tag) != "svg":
+ raise SvgPictureError(f"Expected an SVG root in {path}")
+ return tree, root
+
+
+def _parent_map(root: ET.Element) -> dict[ET.Element, ET.Element]:
+ return {child: parent for parent in root.iter() for child in parent}
+
+
+def _index_ids(root: ET.Element) -> dict[str, ET.Element]:
+ by_id: dict[str, ET.Element] = {}
+ duplicates: list[str] = []
+ for elem in root.iter():
+ elem_id = (elem.get("id") or "").strip()
+ if not elem_id:
+ continue
+ if elem_id in by_id:
+ duplicates.append(elem_id)
+ by_id[elem_id] = elem
+ if duplicates:
+ raise SvgPictureError("Duplicate SVG id(s): " + ", ".join(sorted(set(duplicates))))
+ return by_id
+
+
+def _is_descendant(container: ET.Element, candidate: ET.Element) -> bool:
+ return any(elem is candidate for elem in container.iter())
+
+
+def _validate_source(root: ET.Element) -> None:
+ if root.get("transform"):
+ raise SvgPictureError("Root-level SVG transform is unsupported; normalize it before extraction")
+ if any(_local(elem.tag) == "script" for elem in root.iter()):
+ raise SvgPictureError("SVG scripts are not allowed in extracted picture assets")
+ for elem in root.iter():
+ if _local(elem.tag) == "style" and "@import" in (elem.text or "").lower():
+ raise SvgPictureError("CSS @import is not allowed in extracted picture assets")
+
+
+def _validate_resource_value(value: str, *, allow_fragment: bool) -> None:
+ raw = value.strip()
+ if not raw or raw.startswith("data:"):
+ return
+ if allow_fragment and raw.startswith("#"):
+ return
+ parsed = urlsplit(raw)
+ if parsed.scheme or parsed.netloc:
+ raise SvgPictureError(f"Remote or scheme-based SVG resource is not allowed: {raw}")
+ if parsed.fragment and parsed.path.lower().endswith(".svg"):
+ raise SvgPictureError(f"External SVG fragment references are not supported: {raw}")
+
+
+def _validate_target(selector: str, target: ET.Element) -> None:
+ if _local(target.tag) != "g":
+ raise SvgPictureError(f"Selector {selector!r} must identify one <g> element")
+ object_kind = (target.get("data-pptx-object") or "").strip()
+ if object_kind and object_kind != "group":
+ raise SvgPictureError(
+ f"Selector {selector!r} is one imported {object_kind!r} object, not a complex group"
+ )
+ if not any(_local(elem.tag) in VISUAL_TAGS for elem in target.iter()):
+ raise SvgPictureError(f"Selector {selector!r} has no visual SVG content")
+ for elem in target.iter():
+ if _local(elem.tag) in UNSAFE_PICTURE_TAGS:
+ raise SvgPictureError(
+ f"Selector {selector!r} contains unsupported <{_local(elem.tag)}> content"
+ )
+ markers = _semantic_markers(elem)
+ if markers:
+ raise SvgPictureError(
+ f"Selector {selector!r} contains {markers[0]}; preserve its existing semantic route"
+ )
+
+
+def _semantic_markers(elem: ET.Element) -> list[str]:
+ return sorted(
+ _local(name)
+ for name in elem.attrib
+ if _local(name) in SEMANTIC_MARKERS
+ or _local(name).startswith(SEMANTIC_PREFIXES)
+ )
+
+
+def _parse_bounds(raw: str, context: str) -> Bounds:
+ tokens = [token for token in _FRAME_SPLIT_RE.split(raw.strip()) if token]
+ if len(tokens) != 4:
+ raise SvgPictureError(f"{context} must contain x,y,width,height")
+ try:
+ values = [float(token) for token in tokens]
+ except ValueError as exc:
+ raise SvgPictureError(f"{context} contains a non-numeric coordinate") from exc
+ if not all(math.isfinite(value) for value in values):
+ raise SvgPictureError(f"{context} must contain finite coordinates")
+ bounds = Bounds(*values)
+ if bounds.width <= 0 or bounds.height <= 0:
+ raise SvgPictureError(f"{context} width and height must be positive")
+ return bounds
+
+
+def _parse_key_values(values: list[str], option: str) -> dict[str, str]:
+ parsed: dict[str, str] = {}
+ for raw in values:
+ key, separator, value = raw.partition("=")
+ key = key.strip()
+ if not separator or not key or not value.strip():
+ raise SvgPictureError(f"{option} expects ID=value, got {raw!r}")
+ if key in parsed:
+ raise SvgPictureError(f"{option} repeats selector {key!r}")
+ parsed[key] = value.strip()
+ return parsed
+
+
+def _measure_bounds(source: Path, selectors: list[str]) -> dict[str, Bounds]:
+ try:
+ from playwright.sync_api import Error as PlaywrightError
+ from playwright.sync_api import sync_playwright
+ except ImportError as exc:
+ raise SvgPictureError(
+ "Playwright is required to measure this target; install it or pass --bounds ID=x,y,w,h"
+ ) from exc
+
+ script = """
+ (ids) => Object.fromEntries(ids.map((id) => {
+ const element = document.getElementById(id);
+ const root = element && element.ownerSVGElement;
+ const rootMatrix = root && root.getScreenCTM();
+ if (!element || !root || !rootMatrix) throw new Error(`Cannot measure ${id}`);
+ const rect = element.getBoundingClientRect();
+ const inverse = rootMatrix.inverse();
+ const points = [
+ new DOMPoint(rect.left, rect.top), new DOMPoint(rect.right, rect.top),
+ new DOMPoint(rect.right, rect.bottom), new DOMPoint(rect.left, rect.bottom),
+ ].map((point) => point.matrixTransform(inverse));
+ const xs = points.map((point) => point.x);
+ const ys = points.map((point) => point.y);
+ return [id, {
+ x: Math.min(...xs), y: Math.min(...ys),
+ width: Math.max(...xs) - Math.min(...xs),
+ height: Math.max(...ys) - Math.min(...ys),
+ }];
+ }))
+ """
+ try:
+ with sync_playwright() as playwright:
+ browser = playwright.chromium.launch(headless=True)
+ page = browser.new_page(viewport={"width": 1920, "height": 1080})
+ page.route("http://**/*", lambda route: route.abort())
+ page.route("https://**/*", lambda route: route.abort())
+ page.goto(source.resolve().as_uri(), wait_until="load")
+ page.evaluate("document.fonts ? document.fonts.ready : Promise.resolve()")
+ measured = page.evaluate(script, selectors)
+ browser.close()
+ except (PlaywrightError, OSError, RuntimeError) as exc:
+ raise SvgPictureError(
+ "Browser measurement failed; pass explicit --bounds ID=x,y,w,h if needed: "
+ f"{exc}"
+ ) from exc
+
+ return {
+ selector: _parse_bounds(
+ ",".join(str(measured[selector][field]) for field in ("x", "y", "width", "height")),
+ f"measured bounds for {selector}",
+ )
+ for selector in selectors
+ }
+
+
+def _resolve_bounds(
+ source: Path,
+ targets: dict[str, ET.Element],
+ overrides: dict[str, str],
+ mode: str,
+ padding: float,
+) -> dict[str, tuple[Bounds, str]]:
+ resolved: dict[str, tuple[Bounds, str]] = {}
+ measure: list[str] = []
+ for selector, target in targets.items():
+ if selector in overrides:
+ resolved[selector] = (_parse_bounds(overrides[selector], f"--bounds {selector}"), "explicit")
+ continue
+ frame = target.get("data-pptx-frame")
+ if mode != "measure" and frame:
+ resolved[selector] = (_parse_bounds(frame, f"{selector} data-pptx-frame"), "data-pptx-frame")
+ continue
+ if mode == "frame":
+ raise SvgPictureError(
+ f"Selector {selector!r} has no data-pptx-frame; pass --bounds or use --bounds-mode measure"
+ )
+ measure.append(selector)
+
+ for selector, bounds in _measure_bounds(source, measure).items() if measure else []:
+ resolved[selector] = (bounds, "browser")
+ return {
+ selector: (_padded_bounds(bounds, padding), source_name)
+ for selector, (bounds, source_name) in resolved.items()
+ }
+
+
+def _referenced_ids(elem: ET.Element) -> set[str]:
+ refs: set[str] = set()
+ for item in elem.iter():
+ for attr_name, value in item.attrib.items():
+ refs.update(
+ match.group(2)[1:]
+ for match in _URL_RE.finditer(value)
+ if match.group(2).startswith("#")
+ )
+ if _local(attr_name) == "href" and value.startswith("#") and len(value) > 1:
+ refs.add(value[1:])
+ if item.text:
+ refs.update(
+ match.group(2)[1:]
+ for match in _URL_RE.finditer(item.text)
+ if match.group(2).startswith("#")
+ )
+ return refs
+
+
+def _visual_clone(
+ root: ET.Element,
+ target: ET.Element,
+ parents: dict[ET.Element, ET.Element],
+) -> tuple[ET.Element, set[ET.Element]]:
+ clone = copy.deepcopy(target)
+ included = {target}
+ cursor = target
+ while parents.get(cursor) is not root:
+ ancestor = parents.get(cursor)
+ if ancestor is None or _local(ancestor.tag) != "g":
+ raise SvgPictureError("Selected group is not in the visible SVG tree")
+ unsafe_attrs = [
+ _local(name)
+ for name in ancestor.attrib
+ if not (
+ _local(name) == "id"
+ or _local(name) == "role"
+ or _local(name).startswith("data-")
+ or _local(name).startswith("aria-")
+ )
+ ]
+ semantic_attrs = _semantic_markers(ancestor)
+ if unsafe_attrs or semantic_attrs:
+ details = ", ".join(sorted(set(unsafe_attrs + semantic_attrs)))
+ raise SvgPictureError(
+ "Selected group has a non-neutral ancestor "
+ f"{ancestor.get('id') or '<g>'} ({details}); select that outer group instead"
+ )
+ shell = ET.Element(ancestor.tag, dict(ancestor.attrib))
+ shell.append(clone)
+ clone = shell
+ included.add(ancestor)
+ cursor = ancestor
+ return clone, included
+
+
+def _dependency_elements(
+ root: ET.Element,
+ target: ET.Element,
+ visual: ET.Element,
+ included: set[ET.Element],
+ parents: dict[ET.Element, ET.Element],
+) -> list[ET.Element]:
+ by_id = _index_ids(root)
+ queue = sorted(_referenced_ids(visual))
+ dependencies: list[ET.Element] = []
+ seen: set[str] = set()
+ while queue:
+ ref_id = queue.pop(0)
+ if ref_id in seen:
+ continue
+ seen.add(ref_id)
+ dependency = by_id.get(ref_id)
+ if dependency is None:
+ raise SvgPictureError(f"Referenced SVG definition #{ref_id} does not exist")
+ if dependency in included or _is_descendant(target, dependency):
+ continue
+ dependencies.append(dependency)
+ queue.extend(sorted(_referenced_ids(dependency) - seen))
+
+ dependency_set = set(dependencies)
+ return [
+ dependency
+ for dependency in dependencies
+ if not any(ancestor in dependency_set for ancestor in _ancestors(dependency, parents))
+ ]
+
+
+def _ancestors(
+ elem: ET.Element,
+ parents: dict[ET.Element, ET.Element],
+) -> list[ET.Element]:
+ found: list[ET.Element] = []
+ cursor = elem
+ while cursor in parents:
+ cursor = parents[cursor]
+ found.append(cursor)
+ return found
+
+
+def _data_uri(resource: Path) -> str:
+ try:
+ payload = resource.read_bytes()
+ except OSError as exc:
+ raise SvgPictureError(f"Cannot embed local SVG resource {resource}: {exc}") from exc
+ mime = mimetypes.guess_type(resource.name)[0] or "application/octet-stream"
+ encoded = base64.b64encode(payload).decode("ascii")
+ return f"data:{mime};base64,{encoded}"
+
+
+def _embed_reference(
+ value: str,
+ source_dir: Path,
+ resource_root: Path,
+ embedded: list[str],
+) -> str:
+ raw = value.strip()
+ if not raw or raw.startswith(("#", "data:")):
+ return value
+ parsed = urlsplit(raw)
+ _validate_resource_value(raw, allow_fragment=True)
+ resource = (source_dir / unquote(parsed.path)).resolve()
+ try:
+ relative_resource = resource.relative_to(resource_root)
+ except ValueError as exc:
+ raise SvgPictureError(f"Local SVG resource escapes --resource-root: {raw}") from exc
+ if not resource.is_file():
+ raise SvgPictureError(f"Local SVG resource does not exist: {raw}")
+ embedded.append(relative_resource.as_posix())
+ return _data_uri(resource)
+
+
+def _embed_css_urls(
+ value: str,
+ source_dir: Path,
+ resource_root: Path,
+ embedded: list[str],
+) -> str:
+ def replace(match: re.Match[str]) -> str:
+ reference = match.group(2)
+ if reference.startswith(("#", "data:")):
+ return match.group(0)
+ embedded_reference = _embed_reference(
+ reference,
+ source_dir,
+ resource_root,
+ embedded,
+ )
+ return f'url("{embedded_reference}")'
+
+ return _URL_RE.sub(replace, value)
+
+
+def _embed_external_resources(
+ asset_root: ET.Element,
+ source_dir: Path,
+ resource_root: Path,
+) -> list[str]:
+ embedded: list[str] = []
+ for elem in asset_root.iter():
+ tag = _local(elem.tag)
+ for attr_name, value in list(elem.attrib.items()):
+ rewritten = _embed_css_urls(value, source_dir, resource_root, embedded)
+ if _local(attr_name) == "href" and tag in {"image", "feImage"}:
+ rewritten = _embed_reference(
+ rewritten,
+ source_dir,
+ resource_root,
+ embedded,
+ )
+ elif _local(attr_name) == "href" and tag == "use" and not rewritten.startswith("#"):
+ raise SvgPictureError(f"External <use> is unsupported in a picture asset: {rewritten}")
+ if rewritten != value:
+ elem.set(attr_name, rewritten)
+ if elem.text:
+ elem.text = _embed_css_urls(
+ elem.text,
+ source_dir,
+ resource_root,
+ embedded,
+ )
+ return sorted(set(embedded))
+
+
+def _rebase_reference(
+ value: str,
+ source_dir: Path,
+ output_dir: Path,
+ resource_root: Path,
+) -> str:
+ raw = value.strip()
+ if not raw or raw.startswith(("#", "data:")):
+ return value
+ parsed = urlsplit(raw)
+ if parsed.scheme or parsed.netloc or not parsed.path:
+ return value
+ resource = (source_dir / unquote(parsed.path)).resolve()
+ try:
+ resource.relative_to(resource_root)
+ except ValueError as exc:
+ raise SvgPictureError(f"Local page resource escapes --resource-root: {raw}") from exc
+ relative = Path(os.path.relpath(resource, output_dir)).as_posix()
+ return urlunsplit(("", "", relative, parsed.query, parsed.fragment))
+
+
+def _rebase_css_urls(
+ value: str,
+ source_dir: Path,
+ output_dir: Path,
+ resource_root: Path,
+) -> str:
+ def replace(match: re.Match[str]) -> str:
+ reference = match.group(2)
+ rewritten = _rebase_reference(
+ reference,
+ source_dir,
+ output_dir,
+ resource_root,
+ )
+ if rewritten == reference:
+ return match.group(0)
+ quote = match.group(1)
+ return f"url({quote}{rewritten}{quote})"
+
+ return _URL_RE.sub(replace, value)
+
+
+def _rebase_page_resources(
+ root: ET.Element,
+ source_dir: Path,
+ output_dir: Path,
+ resource_root: Path,
+) -> None:
+ if source_dir == output_dir:
+ return
+ for elem in root.iter():
+ tag = _local(elem.tag)
+ for attr_name, value in list(elem.attrib.items()):
+ rewritten = _rebase_css_urls(
+ value,
+ source_dir,
+ output_dir,
+ resource_root,
+ )
+ if _local(attr_name) == "href" and tag in {"image", "feImage", "use"}:
+ rewritten = _rebase_reference(
+ rewritten,
+ source_dir,
+ output_dir,
+ resource_root,
+ )
+ if rewritten != value:
+ elem.set(attr_name, rewritten)
+ if elem.text:
+ elem.text = _rebase_css_urls(
+ elem.text,
+ source_dir,
+ output_dir,
+ resource_root,
+ )
+
+
+def _asset_root_attributes(source_root: ET.Element, bounds: Bounds) -> dict[str, str]:
+ attrs = {
+ name: value
+ for name, value in source_root.attrib.items()
+ if _local(name) not in GEOMETRY_ROOT_ATTRS
+ }
+ attrs.update(
+ {
+ "viewBox": f"0 0 {_fmt(bounds.width)} {_fmt(bounds.height)}",
+ "width": _fmt(bounds.width),
+ "height": _fmt(bounds.height),
+ }
+ )
+ return attrs
+
+
+def _build_asset(
+ source: Path,
+ resource_root: Path,
+ root: ET.Element,
+ target: ET.Element,
+ bounds: Bounds,
+ parents: dict[ET.Element, ET.Element],
+) -> tuple[bytes, list[str], list[str]]:
+ visual, included = _visual_clone(root, target, parents)
+ dependencies = _dependency_elements(root, target, visual, included, parents)
+ styles = [
+ elem
+ for elem in root.iter()
+ if _local(elem.tag) == "style"
+ and not _is_descendant(target, elem)
+ and not any(_is_descendant(dependency, elem) for dependency in dependencies)
+ ]
+ asset_root = ET.Element(root.tag, _asset_root_attributes(root, bounds))
+ if styles or dependencies:
+ defs = ET.SubElement(asset_root, f"{{{SVG_NS}}}defs")
+ for style in styles:
+ defs.append(copy.deepcopy(style))
+ for dependency in dependencies:
+ if _local(dependency.tag) != "style":
+ defs.append(copy.deepcopy(dependency))
+ translated = ET.SubElement(
+ asset_root,
+ f"{{{SVG_NS}}}g",
+ {"transform": f"translate({_fmt(-bounds.x)} {_fmt(-bounds.y)})"},
+ )
+ translated.append(visual)
+ embedded = _embed_external_resources(asset_root, source.parent, resource_root)
+ ET.indent(asset_root, space=" ")
+ payload = ET.tostring(asset_root, encoding="utf-8", xml_declaration=True)
+ dependency_ids = sorted(filter(None, (elem.get("id") for elem in dependencies)))
+ return payload, dependency_ids, embedded
+
+
+def _safe_asset_name(source: Path, selector: str) -> str:
+ safe_id = re.sub(r"[^A-Za-z0-9._-]+", "-", selector).strip(".-") or "asset"
+ safe_stem = re.sub(r"[^A-Za-z0-9._-]+", "-", source.stem).strip(".-") or "source"
+ return f"{safe_stem}__{safe_id}.svg"
+
+
+def _validate_asset_name(name: str, selector: str) -> str:
+ path = Path(name)
+ if path.name != name or path.suffix.lower() != ".svg":
+ raise SvgPictureError(f"Asset name for {selector!r} must be one .svg basename")
+ return name
+
+
+def _replacement_image(target: ET.Element, bounds: Bounds, href: str) -> ET.Element:
+ attrs = {
+ name: value
+ for name, value in target.attrib.items()
+ if _local(name) in PRESERVED_IMAGE_ATTRS
+ }
+ attrs.update(
+ {
+ "href": href,
+ "x": _fmt(bounds.x),
+ "y": _fmt(bounds.y),
+ "width": _fmt(bounds.width),
+ "height": _fmt(bounds.height),
+ "preserveAspectRatio": "none",
+ }
+ )
+ return ET.Element(f"{{{SVG_NS}}}image", attrs)
+
+
+def _prepare_plans(
+ source: Path,
+ resource_root: Path,
+ output: Path,
+ images_dir: Path,
+ root: ET.Element,
+ targets: dict[str, ET.Element],
+ resolved_bounds: dict[str, tuple[Bounds, str]],
+ names: dict[str, str],
+ parents: dict[ET.Element, ET.Element],
+) -> list[ExtractionPlan]:
+ plans: list[ExtractionPlan] = []
+ for selector, target in targets.items():
+ bounds, bounds_source = resolved_bounds[selector]
+ name = _validate_asset_name(
+ names.get(selector, _safe_asset_name(source, selector)),
+ selector,
+ )
+ asset_path = images_dir / name
+ href = Path(os.path.relpath(asset_path, output.parent)).as_posix()
+ payload, dependency_ids, embedded = _build_asset(
+ source,
+ resource_root,
+ root,
+ target,
+ bounds,
+ parents,
+ )
+ plans.append(
+ ExtractionPlan(
+ selector=selector,
+ asset_path=asset_path,
+ href=href,
+ bounds=bounds,
+ bounds_source=bounds_source,
+ asset_bytes=payload,
+ dependency_ids=dependency_ids,
+ embedded_resources=embedded,
+ )
+ )
+ asset_paths = [plan.asset_path for plan in plans]
+ if len(set(asset_paths)) != len(asset_paths):
+ raise SvgPictureError("Generated or overridden asset filenames must be unique")
+ return plans
+
+
+def _check_outputs(
+ source: Path,
+ output: Path,
+ inventory: Path,
+ plans: list[ExtractionPlan],
+ overwrite: bool,
+) -> None:
+ if output != source and output.exists() and not overwrite:
+ raise SvgPictureError(f"Output SVG exists; pass --overwrite to replace it: {output}")
+ if inventory.exists() and not overwrite:
+ raise SvgPictureError(f"Inventory exists; pass --overwrite to replace it: {inventory}")
+ for plan in plans:
+ if not plan.asset_path.exists():
+ continue
+ if plan.asset_path.read_bytes() != plan.asset_bytes and not overwrite:
+ raise SvgPictureError(
+ f"Picture asset exists with different bytes; pass --overwrite: {plan.asset_path}"
+ )
+
+
+def _replace_targets(
+ targets: dict[str, ET.Element],
+ plans: list[ExtractionPlan],
+ parents: dict[ET.Element, ET.Element],
+) -> None:
+ for plan in plans:
+ target = targets[plan.selector]
+ parent = parents[target]
+ index = list(parent).index(target)
+ parent.remove(target)
+ parent.insert(index, _replacement_image(target, plan.bounds, plan.href))
+
+
+def _inventory_payload(
+ source: Path,
+ resource_root: Path,
+ output: Path,
+ images_dir: Path,
+ plans: list[ExtractionPlan],
+) -> bytes:
+ payload = {
+ "schema": "svg_picture_asset_inventory.v1",
+ "sourceSvg": str(source),
+ "resourceRoot": str(resource_root),
+ "rewrittenSvg": str(output),
+ "imagesDir": str(images_dir),
+ "items": [
+ {
+ "selector": plan.selector,
+ "asset": str(plan.asset_path),
+ "href": plan.href,
+ "bounds": [
+ plan.bounds.x,
+ plan.bounds.y,
+ plan.bounds.width,
+ plan.bounds.height,
+ ],
+ "boundsSource": plan.bounds_source,
+ "sha256": hashlib.sha256(plan.asset_bytes).hexdigest(),
+ "dependencyIds": plan.dependency_ids,
+ "embeddedResources": plan.embedded_resources,
+ }
+ for plan in plans
+ ],
+ }
+ return (json.dumps(payload, ensure_ascii=False, indent=2) + "\n").encode("utf-8")
+
+
+def _write_outputs(
+ tree: ET.ElementTree,
+ output: Path,
+ inventory: Path,
+ images_dir: Path,
+ plans: list[ExtractionPlan],
+ inventory_bytes: bytes,
+) -> None:
+ images_dir.mkdir(parents=True, exist_ok=True)
+ output.parent.mkdir(parents=True, exist_ok=True)
+ inventory.parent.mkdir(parents=True, exist_ok=True)
+ for plan in plans:
+ plan.asset_path.write_bytes(plan.asset_bytes)
+ ET.indent(tree, space=" ")
+ output.write_bytes(ET.tostring(tree.getroot(), encoding="utf-8", xml_declaration=True))
+ inventory.write_bytes(inventory_bytes)
+
+
+def build_parser() -> argparse.ArgumentParser:
+ parser = argparse.ArgumentParser(
+ description="Extract explicitly selected SVG groups as standalone SVG picture assets.",
+ formatter_class=argparse.RawDescriptionHelpFormatter,
+ )
+ parser.add_argument("svg_file", type=Path, help="Source SVG file")
+ parser.add_argument(
+ "--select",
+ action="append",
+ required=True,
+ metavar="ID",
+ help="Exact <g id> to extract; repeat for multiple groups",
+ )
+ parser.add_argument("--images-dir", required=True, type=Path, help="Destination image asset directory")
+ parser.add_argument(
+ "--resource-root",
+ type=Path,
+ help="Allowed root for local SVG dependencies (default: source directory)",
+ )
+ output = parser.add_mutually_exclusive_group(required=True)
+ output.add_argument("-o", "--output", type=Path, help="Rewritten SVG path")
+ output.add_argument("--inplace", action="store_true", help="Rewrite the source SVG")
+ parser.add_argument(
+ "--bounds",
+ action="append",
+ default=[],
+ metavar="ID=X,Y,W,H",
+ help="Explicit tight bounds for one selector; repeat as needed",
+ )
+ parser.add_argument(
+ "--bounds-mode",
+ choices=("auto", "frame", "measure"),
+ default="auto",
+ help="Bounds source when --bounds is absent (default: auto)",
+ )
+ parser.add_argument("--padding", type=float, default=0.0, help="Non-negative padding in SVG units")
+ parser.add_argument(
+ "--asset-name",
+ action="append",
+ default=[],
+ metavar="ID=NAME.svg",
+ help="Override one generated asset filename",
+ )
+ parser.add_argument("--inventory", type=Path, help="Explicit JSON inventory path")
+ parser.add_argument("--overwrite", action="store_true", help="Replace existing non-identical outputs")
+ return parser
+
+
+def _run(args: argparse.Namespace) -> dict[str, object]:
+ source = args.svg_file.resolve()
+ if not source.is_file():
+ raise SvgPictureError(f"Source SVG does not exist: {source}")
+ if args.padding < 0 or not math.isfinite(args.padding):
+ raise SvgPictureError("--padding must be a finite non-negative number")
+ selectors = [selector.strip() for selector in args.select]
+ if any(not selector for selector in selectors) or len(set(selectors)) != len(selectors):
+ raise SvgPictureError("--select values must be non-empty and unique")
+ print(
+ f"Preparing {len(selectors)} explicit SVG picture asset(s) from {source.name}",
+ file=sys.stderr,
+ )
+
+ output = source if args.inplace else args.output.resolve()
+ if not args.inplace and output == source:
+ raise SvgPictureError("Use --inplace explicitly when the output is the source SVG")
+ images_dir = args.images_dir.resolve()
+ resource_root = args.resource_root.resolve() if args.resource_root else source.parent
+ if not resource_root.is_dir():
+ raise SvgPictureError(f"--resource-root is not a directory: {resource_root}")
+ try:
+ source.relative_to(resource_root)
+ except ValueError as exc:
+ raise SvgPictureError("Source SVG must be inside --resource-root") from exc
+ inventory = (
+ args.inventory.resolve()
+ if args.inventory
+ else output.with_name(f"{output.stem}_picture_asset_inventory.json")
+ )
+ if inventory in {source, output}:
+ raise SvgPictureError("Inventory path must differ from the source and rewritten SVG")
+ bounds_overrides = _parse_key_values(args.bounds, "--bounds")
+ asset_names = _parse_key_values(args.asset_name, "--asset-name")
+ unknown_options = (set(bounds_overrides) | set(asset_names)) - set(selectors)
+ if unknown_options:
+ raise SvgPictureError("Options reference unselected id(s): " + ", ".join(sorted(unknown_options)))
+
+ tree, root = _parse_svg(source)
+ _validate_source(root)
+ ids = _index_ids(root)
+ missing = [selector for selector in selectors if selector not in ids]
+ if missing:
+ raise SvgPictureError("Selected SVG id(s) do not exist: " + ", ".join(missing))
+ targets = {selector: ids[selector] for selector in selectors}
+ for selector, target in targets.items():
+ _validate_target(selector, target)
+ for outer_id, outer in targets.items():
+ for inner_id, inner in targets.items():
+ if outer_id != inner_id and _is_descendant(outer, inner):
+ raise SvgPictureError(f"Nested selections are not allowed: {outer_id!r} contains {inner_id!r}")
+
+ parents = _parent_map(root)
+ resolved = _resolve_bounds(
+ source,
+ targets,
+ bounds_overrides,
+ args.bounds_mode,
+ args.padding,
+ )
+ plans = _prepare_plans(
+ source,
+ resource_root,
+ output,
+ images_dir,
+ root,
+ targets,
+ resolved,
+ asset_names,
+ parents,
+ )
+ occupied = {source, output, inventory}
+ if any(plan.asset_path in occupied for plan in plans):
+ raise SvgPictureError("Picture asset paths must differ from SVG and inventory paths")
+ _check_outputs(source, output, inventory, plans, args.overwrite)
+ _rebase_page_resources(root, source.parent, output.parent, resource_root)
+ _replace_targets(targets, plans, parents)
+ inventory_bytes = _inventory_payload(
+ source,
+ resource_root,
+ output,
+ images_dir,
+ plans,
+ )
+ _write_outputs(tree, output, inventory, images_dir, plans, inventory_bytes)
+ print(f"Wrote rewritten SVG and {len(plans)} picture asset(s)", file=sys.stderr)
+ return {
+ "source": str(source),
+ "output": str(output),
+ "inventory": str(inventory),
+ "assets": [str(plan.asset_path) for plan in plans],
+ }
+
+
+def main(argv: list[str] | None = None) -> int:
+ parser = build_parser()
+ try:
+ result = _run(parser.parse_args(argv))
+ except (OSError, SvgPictureError) as exc:
+ print(f"ERROR: {exc}", file=sys.stderr)
+ return 1
+ print(json.dumps(result, ensure_ascii=False))
+ return 0
+
+
+if __name__ == "__main__":
+ raise SystemExit(main())
diff --git a/skills/ppt-master/scripts/pptx_to_svg/ooxml_loader.py b/skills/ppt-master/scripts/pptx_to_svg/ooxml_loader.py
index ae8d986c..47ae6cd4 100644
--- a/skills/ppt-master/scripts/pptx_to_svg/ooxml_loader.py
+++ b/skills/ppt-master/scripts/pptx_to_svg/ooxml_loader.py
@@ -87,6 +87,28 @@ def _load_xml(zf: zipfile.ZipFile, part_path: str) -> ET.Element | None:
raise RuntimeError(f"Invalid OOXML part {part_path}: {exc}") from exc
+def blip_embed_relationship_ids(blip: ET.Element) -> tuple[str, ...]:
+ """Return embedded image relationships in fidelity-preferred order.
+
+ Modern Office stores an editable SVG relationship in ``asvg:svgBlip``
+ while keeping a raster fallback on the owning ``a:blip``. Consumers must
+ try the SVG relationship first and retain the raster relationship only as
+ a compatibility fallback.
+ """
+ embed_attr = f"{{{NS['r']}}}embed"
+ candidates = [
+ node.attrib.get(embed_attr)
+ for node in blip.findall(".//asvg:svgBlip", NS)
+ ]
+ candidates.append(blip.attrib.get(embed_attr))
+
+ ordered: list[str] = []
+ for rel_id in candidates:
+ if rel_id and rel_id not in ordered:
+ ordered.append(rel_id)
+ return tuple(ordered)
+
+
# ---------------------------------------------------------------------------
# Data classes for navigable parts
# ---------------------------------------------------------------------------
diff --git a/skills/ppt-master/scripts/pptx_to_svg/pic_to_svg.py b/skills/ppt-master/scripts/pptx_to_svg/pic_to_svg.py
index 5d9c27b3..83795fac 100644
--- a/skills/ppt-master/scripts/pptx_to_svg/pic_to_svg.py
+++ b/skills/ppt-master/scripts/pptx_to_svg/pic_to_svg.py
@@ -5,7 +5,9 @@ Reverse of svg_to_pptx convert_image.
DrawingML structure:
<p:pic>
<p:blipFill>
- <a:blip r:embed="rIdN"/>
+ <a:blip r:embed="rIdRaster">
+ <a:extLst>...<asvg:svgBlip r:embed="rIdSvg"/>...</a:extLst>
+ </a:blip>
<a:srcRect l/t/r/b="1/100000"/> (optional crop)
<a:stretch><a:fillRect/></a:stretch> (default: fill the shape)
</p:blipFill>
@@ -16,6 +18,8 @@ DrawingML structure:
</p:pic>
Strategy:
+- Prefer the editable SVG relationship in asvg:svgBlip when Office also stores
+ a raster compatibility preview on a:blip; retain the raster as fallback.
- Default (no srcRect, plain stretch) -> a single <image> filling the box,
preserveAspectRatio="none".
- With srcRect -> wrap the <image> in a nested <svg viewBox> in the unit
@@ -45,7 +49,7 @@ except ImportError: # pragma: no cover - optional visual enhancement dependency
ImageEnhance = None
from .emu_units import NS, Xfrm, fmt_num, format_ooxml_alpha
-from .ooxml_loader import OoxmlPackage, PartRef
+from .ooxml_loader import OoxmlPackage, PartRef, blip_embed_relationship_ids
@dataclass
@@ -82,23 +86,38 @@ def convert_blip_fill(
if blip is None:
return PictureResult()
- rid = blip.attrib.get(f"{{{NS['r']}}}embed")
+ relationship_ids = blip_embed_relationship_ids(blip)
linked_rid = blip.attrib.get(f"{{{NS['r']}}}link")
- if not rid:
+ if not relationship_ids:
if linked_rid:
raise MediaResolutionError(
"Linked image relationships are not supported; embed the image in PowerPoint first"
)
return PictureResult()
- target = slide_part.resolve_rel(rid)
- if not target:
- raise MediaResolutionError(f"Image relationship {rid} cannot be resolved in {slide_part.path}")
-
- # Read the bytes
- img_bytes = pkg.read_media(target)
- if img_bytes is None:
- raise MediaResolutionError(f"Embedded image part is missing: {target}")
+ target: str | None = None
+ img_bytes: bytes | None = None
+ failures: list[str] = []
+ for rel_id in relationship_ids:
+ candidate = slide_part.resolve_rel(rel_id)
+ if not candidate:
+ failures.append(f"{rel_id}: unresolved")
+ continue
+ candidate_bytes = pkg.read_media(candidate)
+ if candidate_bytes is None:
+ failures.append(f"{rel_id}: missing {candidate}")
+ continue
+ if Path(candidate).suffix.lower() == ".svg" and not _is_valid_svg_media(candidate_bytes):
+ failures.append(f"{rel_id}: invalid SVG media {candidate}")
+ continue
+ target = candidate
+ img_bytes = candidate_bytes
+ break
+ if target is None or img_bytes is None:
+ details = "; ".join(failures)
+ raise MediaResolutionError(
+ f"No embedded image relationship can be read in {slide_part.path}: {details}"
+ )
filename = (asset_name_map or {}).get(target, pkg.media_filename(target))
filename, img_bytes = _normalize_office_media(filename, img_bytes)
@@ -187,6 +206,15 @@ def _blip_opacity_attr(blip: ET.Element) -> str:
_OFFICE_VECTOR_EXTS = {".emf", ".wmf"}
+def _is_valid_svg_media(data: bytes) -> bool:
+ """Return whether one media part is a namespaced SVG document."""
+ try:
+ root = ET.fromstring(data)
+ except ET.ParseError:
+ return False
+ return root.tag == "{http://www.w3.org/2000/svg}svg"
+
+
def _normalize_office_media(filename: str, img_bytes: bytes) -> tuple[str, bytes]:
"""Convert Office-only vector image formats to browser-renderable PNG.
diff --git a/skills/ppt-master/scripts/template_import/manifest.py b/skills/ppt-master/scripts/template_import/manifest.py
index 018700ec..efd47bc0 100644
--- a/skills/ppt-master/scripts/template_import/manifest.py
+++ b/skills/ppt-master/scripts/template_import/manifest.py
@@ -31,7 +31,10 @@ from pathlib import Path, PurePosixPath
from typing import Any
from xml.etree import ElementTree as ET
-from pptx_to_svg.ooxml_loader import parse_ooxml_boolean
+from pptx_to_svg.ooxml_loader import (
+ blip_embed_relationship_ids,
+ parse_ooxml_boolean,
+)
NS = {
@@ -357,20 +360,26 @@ def extract_image_targets(root: ET.Element | None, rels: dict[str, dict[str, str
targets: list[str] = []
seen: set[str] = set()
for blip in root.findall(".//a:blip", NS):
- rel_id = blip.attrib.get(f"{{{NS['r']}}}embed")
- if not rel_id:
- continue
- rel = rels.get(rel_id)
- if not rel or rel["type"] != IMAGE_REL:
- continue
- target = rel["target"]
- if target in seen:
+ target = _preferred_image_target(blip, rels)
+ if target is None or target in seen:
continue
seen.add(target)
targets.append(target)
return targets
+def _preferred_image_target(
+ blip: ET.Element,
+ rels: dict[str, dict[str, str]],
+) -> str | None:
+ """Resolve an Office SVG relationship before its raster fallback."""
+ for rel_id in blip_embed_relationship_ids(blip):
+ rel = rels.get(rel_id)
+ if rel and rel["type"] == IMAGE_REL:
+ return rel["target"]
+ return None
+
+
def detect_background_asset(root: ET.Element | None, rels: dict[str, dict[str, str]]) -> str | None:
if root is None:
return None
@@ -385,13 +394,7 @@ def detect_background_asset(root: ET.Element | None, rels: dict[str, dict[str, s
if blip is None:
return None
- rel_id = blip.attrib.get(f"{{{NS['r']}}}embed")
- if not rel_id:
- return None
- rel = rels.get(rel_id)
- if not rel or rel["type"] != IMAGE_REL:
- return None
- return rel["target"]
+ return _preferred_image_target(blip, rels)
def count_slide_shapes(root: ET.Element | None) -> int: