docxdriver 0.2.7__tar.gz → 0.3.0__tar.gz

{docxdriver-0.2.7 → docxdriver-0.3.0}/Cargo.lock

@@ -416,7 +416,7 @@ dependencies = [
 
 [[package]]
 name = "docxdriver-cli"
-version = "0.2.7"
+version = "0.3.0"
 dependencies = [
  "clap",
  "docxdriver-core",
@@ -427,7 +427,7 @@ dependencies = [
 
 [[package]]
 name = "docxdriver-core"
-version = "0.2.7"
+version = "0.3.0"
 dependencies = [
  "hex",
  "latex2mathml",
@@ -444,7 +444,7 @@ dependencies = [
 
 [[package]]
 name = "docxdriver-mcp"
-version = "0.2.7"
+version = "0.3.0"
 dependencies = [
  "axum",
  "cap-std",
@@ -462,7 +462,7 @@ dependencies = [
 
 [[package]]
 name = "docxdriver-python"
-version = "0.2.7"
+version = "0.3.0"
 dependencies = [
  "docxdriver-core",
  "pyo3",
@@ -471,7 +471,7 @@ dependencies = [
 
 [[package]]
 name = "docxdriver-wasm"
-version = "0.2.7"
+version = "0.3.0"
 dependencies = [
  "docxdriver-core",
  "js-sys",

{docxdriver-0.2.7 → docxdriver-0.3.0}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/docxdriver-python"]
 
 [workspace.package]
-version = "0.2.7"
+version = "0.3.0"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/jhnoel/docxdriver"

{docxdriver-0.2.7 → docxdriver-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docxdriver
-Version: 0.2.7
+Version: 0.3.0
 Summary: Python SDK for the native Rust DOCX engine
 License-Expression: MIT
 Requires-Python: >=3.10

docxdriver-0.3.0/crates/docxdriver-core/examples/plan_scaling.rs

@@ -0,0 +1,43 @@
+//! Plan review scaling probe: `cargo run --release -p docxdriver-core --example plan_scaling -- PARAS OPS`.
+use std::io::Write;
+use std::time::Instant;
+
+use docxdriver_core::{execute_plan, ChangeMode, EditOp, ParagraphAddress, Plan, PlanRequest, PlanResult, SourceHash};
+
+fn package(body: &str) -> Vec<u8> {
+    let mut w = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
+    let o = zip::write::SimpleFileOptions::default();
+    let parts = [
+        ("[Content_Types].xml", "<?xml version=\"1.0\" encoding=\"UTF-8\"?><Types xmlns=\"http://schemas.openxmlformats.org/package/2006/content-types\"><Default Extension=\"rels\" ContentType=\"application/vnd.openxmlformats-package.relationships+xml\"/><Default Extension=\"xml\" ContentType=\"application/xml\"/><Override PartName=\"/word/document.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml\"/></Types>".to_string()),
+        ("_rels/.rels", "<?xml version=\"1.0\" encoding=\"UTF-8\"?><Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\"><Relationship Id=\"rId1\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument\" Target=\"word/document.xml\"/></Relationships>".to_string()),
+        ("word/document.xml", body.to_string()),
+        ("word/_rels/document.xml.rels", "<?xml version=\"1.0\" encoding=\"UTF-8\"?><Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\"></Relationships>".to_string()),
+    ];
+    for (n, c) in parts {
+        w.start_file(n, o).unwrap();
+        w.write_all(c.as_bytes()).unwrap();
+    }
+    w.finish().unwrap().into_inner()
+}
+
+fn main() {
+    let args: Vec<usize> = std::env::args().skip(1).map(|a| a.parse().unwrap()).collect();
+    let (paras, ops) = (args.first().copied().unwrap_or(1500), args.get(1).copied().unwrap_or(300));
+    let body: String = (0..paras)
+        .map(|i| format!("<w:p w14:paraId=\"{:08X}\"><w:r><w:t>Paragraph {i} says the tenant shall pay rent within thirty days of notice.</w:t></w:r></w:p>", i + 1))
+        .collect();
+    let bytes = package(&format!("<?xml version=\"1.0\" encoding=\"UTF-8\"?><w:document xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" xmlns:w14=\"http://schemas.microsoft.com/office/word/2010/wordml\"><w:body>{body}</w:body></w:document>"));
+    let operations = (0..ops)
+        .map(|i| EditOp::ReplaceText {
+            at: ParagraphAddress::id(format!("{:08X}", (i * paras / ops) + 1)),
+            select: "thirty days".into(),
+            with: "sixty days".into(),
+            occurrence: None,
+        })
+        .collect();
+    let plan = Plan { base: SourceHash::from_bytes(&bytes), author: "bench".into(), change_mode: ChangeMode::Track, ops: operations };
+    let t = Instant::now();
+    let result = execute_plan(&bytes, &PlanRequest { plan, preview_key: None });
+    let ok = matches!(result, PlanResult::Previewed { .. });
+    println!("paras={paras} ops={ops} previewed={ok} elapsed={:?}", t.elapsed());
+}

{docxdriver-0.2.7 → docxdriver-0.3.0}/crates/docxdriver-core/src/api.rs

@@ -342,6 +342,19 @@ pub enum EditOp {
         #[serde(default)]
         occurrence: Option<u32>,
     },
+    /// Several exact replacements inside one bounded scope: the paragraph
+    /// `at`, the unique `within` span (in `at`, or anywhere in the body when
+    /// `at` is omitted), or the whole body. Every edit resolves against the
+    /// scope as it stands when this operation starts.
+    ReviseText {
+        #[serde(default)]
+        at: Option<ParagraphAddress>,
+        #[serde(default)]
+        within: Option<String>,
+        #[serde(default)]
+        occurrence: Option<u32>,
+        edits: Vec<TextEdit>,
+    },
     ReplaceParagraph {
         at: ParagraphAddress,
         with: String,
@@ -474,6 +487,20 @@ pub enum EditOp {
     },
 }
 
+/// One replacement inside a `revise_text` scope.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, JsonSchema)]
+#[serde(deny_unknown_fields)]
+pub struct TextEdit {
+    pub select: String,
+    pub with: String,
+    /// 1-based match within the scope; omit when `select` is unique there.
+    #[serde(default)]
+    pub occurrence: Option<u32>,
+    /// Replace every match within the scope.
+    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
+    pub all: bool,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, JsonSchema)]
 #[serde(deny_unknown_fields)]
 pub struct CreateCommand {
@@ -970,6 +997,10 @@ fn validation_field(message: &str) -> Option<&'static str> {
         "mathml"
     } else if message.contains("equation must") {
         "equation"
+    } else if message.contains("edits") {
+        "edits"
+    } else if message.contains("within") {
+        "within"
     } else if message.contains("select") {
         "select"
     } else if message.contains("occurrence") {
@@ -1030,6 +1061,38 @@ fn normalize_op(op: &mut EditOp) -> Result<(), String> {
                 return Err("occurrence must be positive".into());
             }
         }
+        EditOp::ReviseText {
+            within,
+            occurrence,
+            edits,
+            ..
+        } => {
+            if within.as_deref() == Some("") {
+                return Err("within must be non-empty when given".into());
+            }
+            if occurrence == &Some(0) {
+                return Err("occurrence must be positive".into());
+            }
+            if occurrence.is_some() && within.is_none() {
+                return Err("occurrence picks a within match; it requires within".into());
+            }
+            if edits.is_empty() {
+                return Err("edits must list at least one replacement".into());
+            }
+            for (index, edit) in edits.iter().enumerate() {
+                if edit.select.is_empty() {
+                    return Err(format!("edits[{index}].select must be non-empty"));
+                }
+                if edit.occurrence == Some(0) {
+                    return Err(format!("edits[{index}].occurrence must be positive"));
+                }
+                if edit.all && edit.occurrence.is_some() {
+                    return Err(format!(
+                        "edits[{index}] sets both all and occurrence; choose one"
+                    ));
+                }
+            }
+        }
         EditOp::ReplaceParagraph { .. } => {}
         EditOp::FormatText {
             select,
@@ -1431,6 +1494,8 @@ fn fold_typed(
     }
     let mut aliases: BTreeMap<String, Value> = BTreeMap::new();
     let mut reports = Vec::new();
+    let mut affected_ids: Vec<Vec<String>> = Vec::new();
+    let plan_seed = crate::commands::plan_seed(plan);
     let mut allocated_ids = Vec::new();
     let ctx = crate::commands::ExecCtx {
         dry_run: !commit,
@@ -1459,33 +1524,27 @@ fn fold_typed(
             plan.change_mode,
             index,
             &seed,
-            plan,
+            &plan_seed,
             &ctx,
         );
-        let mut report_value = outcome.result_json();
-        report_value = crate::commands::attach_affected_markup(&state, report_value);
+        let report_value = outcome.result_json();
         let applied = outcome.status == crate::outcome::Status::Ok;
-        let affected = report_value
-            .get("markup")
-            .and_then(Value::as_str)
-            .map(|markup| {
-                let para_id = report_value
-                    .get("result")
-                    .and_then(|r| r.get("paraId"))
-                    .and_then(Value::as_str)
-                    .unwrap_or("");
-                vec![serde_json::json!({"para_id": para_id, "markup": markup})]
-            })
-            .unwrap_or_default();
+        affected_ids.push(crate::commands::affected_para_ids(&report_value));
         reports.push(OperationReport {
             index,
             op: name,
             outcome: if applied { "applied" } else { "rejected" }.into(),
             summary: outcome.summary.clone(),
-            affected,
+            affected: Vec::new(),
             context_truncated: false,
         });
         if !applied {
+            if let Some(note) = explain_selector_drift(input, plan, &resolved, index, &affected_ids) {
+                if let Some(report) = reports.last_mut() {
+                    report.summary.push_str(&note);
+                }
+            }
+            attach_affected(&state, &mut reports, &affected_ids);
             let report = PlanReport {
                 completed: index,
                 stopped_at: Some(index),
@@ -1494,15 +1553,12 @@ fn fold_typed(
                 allocated_ids: allocated_ids.clone(),
                 aliases: aliases.clone().into_iter().collect(),
             };
+            let message = report.ops[index].summary.clone();
             return (
                 report.clone(),
                 None,
                 Some((
-                    diag(
-                        "operation_rejected",
-                        outcome.summary,
-                        Some(format!("ops[{index}]")),
-                    ),
+                    diag("operation_rejected", message, Some(format!("ops[{index}]"))),
                     report,
                 )),
             );
@@ -1512,6 +1568,7 @@ fn fold_typed(
         } = op
         {
             if aliases.contains_key(alias) {
+                attach_affected(&state, &mut reports, &affected_ids);
                 let report = PlanReport {
                     completed: index,
                     stopped_at: Some(index),
@@ -1544,6 +1601,7 @@ fn fold_typed(
             }
         }
     }
+    attach_affected(&state, &mut reports, &affected_ids);
     let report = PlanReport {
         completed: plan.ops.len(),
         stopped_at: None,
@@ -1559,6 +1617,89 @@ fn fold_typed(
     );
     (report, out.bytes, None)
 }
+/// When a selector matched nothing but matches the same paragraph as it was
+/// before the plan, name the earlier operations that changed that text:
+/// selectors address the text left by preceding operations, not the read.
+fn explain_selector_drift(
+    input: &[u8],
+    plan: &Plan,
+    op: &EditOp,
+    index: usize,
+    affected_ids: &[Vec<String>],
+) -> Option<String> {
+    let (at, selects): (&ParagraphAddress, Vec<&str>) = match op {
+        EditOp::ReplaceText { at, select, .. } | EditOp::FormatText { at, select, .. } => {
+            (at, vec![select.as_str()])
+        }
+        EditOp::CommentAdd {
+            at,
+            select: Some(select),
+            ..
+        } => (at, vec![select.as_str()]),
+        EditOp::ReviseText {
+            at: Some(at),
+            within,
+            edits,
+            ..
+        } => (
+            at,
+            within
+                .iter()
+                .map(String::as_str)
+                .chain(edits.iter().map(|e| e.select.as_str()))
+                .collect(),
+        ),
+        _ => return None,
+    };
+    if index == 0 {
+        return None;
+    }
+    let ParagraphAddress::Id(id) = at else {
+        return None;
+    };
+    let id = id.to_uppercase();
+    let base = crate::commands::base_visible_text(input, &id)?;
+    if !selects.iter().all(|select| base.contains(select)) {
+        return None;
+    }
+    let earlier: Vec<String> = plan.ops[..index]
+        .iter()
+        .enumerate()
+        .filter(|(i, earlier)| {
+            matches!(earlier, EditOp::RevisionSettle { .. })
+                || affected_ids[*i].iter().any(|touched| touched.eq_ignore_ascii_case(&id))
+        })
+        .map(|(i, earlier)| format!("ops[{i}] {}", operation_name(earlier)))
+        .collect();
+    if earlier.is_empty() {
+        return None;
+    }
+    Some(format!(
+        "; it matches this paragraph as it was before the plan, but {} changed the text first — selectors address the text left by preceding operations (combine edits to one paragraph in a single revise_text, or settle revisions in a separate plan and re-read)",
+        earlier.join(", ")
+    ))
+}
+
+/// Fill each operation report with the rendered markup of the paragraphs it
+/// affected, as they stand in `state`, from one render of the document.
+fn attach_affected(
+    state: &crate::commands::WorkState,
+    reports: &mut [OperationReport],
+    affected_ids: &[Vec<String>],
+) {
+    let wanted = affected_ids.iter().flatten().cloned().collect();
+    let markup = crate::commands::affected_markup(state, &wanted);
+    for (report, ids) in reports.iter_mut().zip(affected_ids) {
+        report.affected = ids
+            .iter()
+            .filter_map(|id| {
+                markup
+                    .get(id)
+                    .map(|m| serde_json::json!({"para_id": id, "markup": m}))
+            })
+            .collect();
+    }
+}
 fn empty_report(_plan: &Plan) -> PlanReport {
     PlanReport {
         completed: 0,
@@ -1574,6 +1715,7 @@ fn operation_name(op: &EditOp) -> &'static str {
         EditOp::ReplaceEquation { .. } => "replace_equation",
         EditOp::DeleteEquation { .. } => "delete_equation",
         EditOp::ReplaceText { .. } => "replace_text",
+        EditOp::ReviseText { .. } => "revise_text",
         EditOp::ReplaceParagraph { .. } => "replace_paragraph",
         EditOp::FormatText { .. } => "format_text",
         EditOp::FormatParagraph { .. } => "format_paragraph",
@@ -1618,6 +1760,7 @@ fn resolve_typed_aliases(
         | EditOp::FormatText { at, .. }
         | EditOp::FormatParagraph { at, .. }
         | EditOp::CommentAdd { at, .. } => resolve(at)?,
+        EditOp::ReviseText { at: Some(at), .. } => resolve(at)?,
         EditOp::InsertParagraph { at, .. } => {
             if let InsertAnchor::Paragraph(addr) = at {
                 resolve(addr)?;

{docxdriver-0.2.7 → docxdriver-0.3.0}/crates/docxdriver-core/src/bin/generate_typed_schema.rs

@@ -96,6 +96,7 @@ export type EditOp =
   | { op: 'replace_equation'; at: ParagraphAddress; mathml: string; equation?: number; display?: boolean }
   | { op: 'delete_equation'; at: ParagraphAddress; equation?: number }
   | { op: 'replace_text'; at: ParagraphAddress; select: string; with: string; occurrence?: number }
+  | { op: 'revise_text'; at?: ParagraphAddress; within?: string; occurrence?: number; edits: [TextEdit, ...TextEdit[]] }
   | { op: 'replace_paragraph'; at: ParagraphAddress; with: string }
   | { op: 'format_text'; at: ParagraphAddress; select: string; occurrence?: number; bold?: boolean; italic?: boolean; underline?: boolean; strike?: boolean; superscript?: boolean; subscript?: boolean; color?: string; font_size?: Point; clear?: string[] }
   | { op: 'format_paragraph'; at: ParagraphAddress; style?: string; alignment?: 'left'|'center'|'right'|'justify'; indent_left?: Point; indent_right?: Point; space_before?: Point; space_after?: Point; line_spacing?: LineSpacing; clear?: string[] }
@@ -112,6 +113,7 @@ export type EditOp =
   | { op: 'comment_set_status'; comment_id: string; status: 'open'|'resolved' }
   | { op: 'comment_delete'; comment_id: string }
   | { op: 'revision_settle'; target: string; action: 'accept'|'reject' };
+export type TextEdit = { select: string; with: string; occurrence?: number; all?: boolean };
 export type CreateCommand = { kind: 'create'; paragraphs?: string[]; html?: string };
 export type ReadCommand = { kind: 'read'; read_kind?: 'document'|'document_ui'|'styles'|'comments'|'revisions'|'assets'; view?: 'markup'|'final'|'original' };
 export type FindCommand = { kind: 'find'; query: string; ignore_case?: boolean; view?: 'markup'|'final'|'original' };

{docxdriver-0.2.7 → docxdriver-0.3.0}/crates/docxdriver-core/src/commands/headers.rs

@@ -193,7 +193,23 @@ fn chrome_part_xml(scope: &str, inner: &str) -> String {
 fn ensure_title_pg(xml: &mut DocxXml, sect: NodeId) {
     if xml.child_w(sect, "titlePg").is_none() {
         let node = xml.doc.create_element("w:titlePg");
-        xml.doc.append_child(sect, node);
+        // CT_SectPr is a sequence; titlePg precedes these.
+        const SUCCESSORS: &[&str] = &[
+            "textDirection",
+            "bidi",
+            "rtlGutter",
+            "docGrid",
+            "printerSettings",
+            "sectPrChange",
+        ];
+        let successor = xml
+            .doc
+            .children(sect)
+            .find(|&child| SUCCESSORS.iter().any(|local| xml.is_w(child, local)));
+        match successor {
+            Some(next) => xml.doc.insert_before(next, node),
+            None => xml.doc.append_child(sect, node),
+        }
     }
 }
 
@@ -251,7 +267,14 @@ fn set_chrome_typed(
     let ref_node = xml.doc.create_element(&format!("w:{ref_tag}"));
     xml.doc.set_attribute(ref_node, "w:type", kind_str);
     xml.doc.set_attribute(ref_node, "r:id", &rid);
-    xml.doc.append_child(sect, ref_node);
+    // Header and footer references lead CT_SectPr: insert after the last one.
+    let successor = xml.doc.children(sect).find(|&child| {
+        !xml.is_w(child, "headerReference") && !xml.is_w(child, "footerReference")
+    });
+    match successor {
+        Some(next) => xml.doc.insert_before(next, ref_node),
+        None => xml.doc.append_child(sect, ref_node),
+    }
 
     Ok((
         format!("section {section} {kind_str} {scope} set"),
@@ -345,7 +368,34 @@ pub fn set_even_and_odd_headers_typed(
     match (even_odd, existing) {
         (true, None) => {
             let node = settings.doc.create_element("w:evenAndOddHeaders");
-            settings.doc.append_child(root, node);
+            // CT_Settings is a sequence: insert before the first later element.
+            const SUCCESSORS: &[&str] = &[
+                "bookFoldRevPrinting", "bookFoldPrinting", "bookFoldPrintingSheets",
+                "drawingGridHorizontalSpacing", "drawingGridVerticalSpacing",
+                "displayHorizontalDrawingGridEvery", "displayVerticalDrawingGridEvery",
+                "doNotUseMarginsForDrawingGridOrigin", "drawingGridHorizontalOrigin",
+                "drawingGridVerticalOrigin", "doNotShadeFormData", "noPunctuationKerning",
+                "characterSpacingControl", "printTwoOnOne", "strictFirstAndLastChars",
+                "noLineBreaksAfter", "noLineBreaksBefore", "savePreviewPicture",
+                "doNotValidateAgainstSchema", "saveInvalidXml", "ignoreMixedContent",
+                "alwaysShowPlaceholderText", "doNotDemarcateInvalidXml", "saveXmlDataOnly",
+                "useXSLTWhenSaving", "saveThroughXslt", "showXMLTags",
+                "alwaysMergeEmptyNamespace", "updateFields", "hdrShapeDefaults", "footnotePr",
+                "endnotePr", "compat", "docVars", "rsids", "mathPr", "attachedSchema",
+                "themeFontLang", "clrSchemeMapping", "doNotIncludeSubdocsInStats",
+                "doNotAutoCompressPictures", "forceUpgrade", "captions", "readModeInkLockDown",
+                "smartTagType", "schemaLibrary", "shapeDefaults", "doNotEmbedSmartTags",
+                "decimalSymbol", "listSeparator",
+            ];
+            let successor = settings.doc.children(root).find(|&child| {
+                settings
+                    .local_name(child)
+                    .is_some_and(|local| SUCCESSORS.contains(&local))
+            });
+            match successor {
+                Some(next) => settings.doc.insert_before(next, node),
+                None => settings.doc.append_child(root, node),
+            }
         }
         (true, Some(node)) => {
             if settings

{docxdriver-0.2.7 → docxdriver-0.3.0}/crates/docxdriver-core/src/commands/layout.rs

@@ -32,6 +32,19 @@ fn ensure_pg_mar(sect: NodeId, xml: &mut DocxXml) -> NodeId {
         return node;
     }
     let node = xml.doc.create_element("w:pgMar");
+    // CT_PageMar requires all seven attributes; start from Word's defaults
+    // (1in margins, 0.5in header/footer, no gutter) before applying values.
+    for (attr, twips) in [
+        ("top", 1440),
+        ("right", 1440),
+        ("bottom", 1440),
+        ("left", 1440),
+        ("header", 720),
+        ("footer", 720),
+        ("gutter", 0),
+    ] {
+        set_twips_attr(xml, node, attr, twips);
+    }
     if let Some(successor) = xml.doc.children(sect).find(|&child| {
         [
             "pgBorders",
@@ -42,6 +55,7 @@ fn ensure_pg_mar(sect: NodeId, xml: &mut DocxXml) -> NodeId {
             "formProtection",
             "vAlign",
             "noEndnote",
+            "titlePg",
             "textDirection",
             "bidi",
             "rtlGutter",
@@ -125,49 +139,62 @@ pub(crate) fn ensure_ppr(xml: &mut DocxXml, paragraph: NodeId) -> NodeId {
     ppr
 }
 
+/// `CT_PPr` child sequence (`CT_PPrBase` followed by `rPr`, `sectPr`,
+/// `pPrChange`).
+const PPR_SEQUENCE: &[&str] = &[
+    "pStyle",
+    "keepNext",
+    "keepLines",
+    "pageBreakBefore",
+    "framePr",
+    "widowControl",
+    "numPr",
+    "suppressLineNumbers",
+    "pBdr",
+    "shd",
+    "tabs",
+    "suppressAutoHyphens",
+    "kinsoku",
+    "wordWrap",
+    "overflowPunct",
+    "topLinePunct",
+    "autoSpaceDE",
+    "autoSpaceDN",
+    "bidi",
+    "adjustRightInd",
+    "snapToGrid",
+    "spacing",
+    "ind",
+    "contextualSpacing",
+    "mirrorIndents",
+    "suppressOverlap",
+    "jc",
+    "textDirection",
+    "textAlignment",
+    "textboxTightWrap",
+    "outlineLvl",
+    "divId",
+    "cnfStyle",
+    "rPr",
+    "sectPr",
+    "pPrChange",
+];
+
+/// Return the `w:pPr` child `local`, creating it at its schema sequence
+/// position.
 pub(crate) fn ensure_ppr_child(xml: &mut DocxXml, ppr: NodeId, local: &str) -> NodeId {
     if let Some(node) = xml.child_w(ppr, local) {
         return node;
     }
-    let successors: &[&str] = match local {
-        "pStyle" => &["*"],
-        "spacing" => &[
-            "ind",
-            "contextualSpacing",
-            "mirrorIndents",
-            "suppressOverlap",
-            "jc",
-            "textDirection",
-            "textAlignment",
-            "textboxTightWrap",
-            "outlineLvl",
-        ],
-        "ind" => &[
-            "contextualSpacing",
-            "mirrorIndents",
-            "suppressOverlap",
-            "jc",
-            "textDirection",
-            "textAlignment",
-            "textboxTightWrap",
-            "outlineLvl",
-        ],
-        "jc" => &[
-            "textDirection",
-            "textAlignment",
-            "textboxTightWrap",
-            "outlineLvl",
-        ],
-        _ => &[],
-    };
     let node = xml.doc.create_element(&format!("w:{local}"));
-    let successor = if successors.contains(&"*") {
-        xml.doc.children(ppr).next()
-    } else {
-        xml.doc
-            .children(ppr)
-            .find(|&child| successors.iter().any(|name| xml.is_w(child, name)))
-    };
+    let successors = PPR_SEQUENCE
+        .iter()
+        .position(|name| *name == local)
+        .map_or(&[][..], |index| &PPR_SEQUENCE[index + 1..]);
+    let successor = xml
+        .doc
+        .children(ppr)
+        .find(|&child| successors.iter().any(|name| xml.is_w(child, name)));
     if let Some(next) = successor {
         xml.doc.insert_before(next, node);
     } else {