@superdoc-dev/cli 0.3.0-next.26 → 0.3.0-next.28

package/dist/index.js

@@ -2218,15 +2218,15 @@ var init_operation_definitions = __esm(() => {
     },
     "lists.create": {
       memberPath: "lists.create",
-      description: "Create a new list from one or more paragraphs, or convert existing paragraphs into a new list.",
+      description: 'Create a new list from one or more paragraphs. Supports optional preset or style for new sequences. When sequence.mode is "continuePrevious", preset and style are not allowed — the new items inherit formatting from the previous sequence.',
       expectedResult: "Returns a ListsCreateResult with the new listId and the first item address.",
       requiresDocumentContext: true,
       metadata: mutationOperation({
         idempotency: "non-idempotent",
         supportsDryRun: true,
         supportsTrackedMode: false,
-        possibleFailureCodes: ["INVALID_TARGET", "LEVEL_OUT_OF_RANGE"],
-        throws: [...T_NOT_FOUND_CAPABLE, "INVALID_TARGET"]
+        possibleFailureCodes: ["INVALID_TARGET", "LEVEL_OUT_OF_RANGE", "INVALID_INPUT", "NO_COMPATIBLE_PREVIOUS"],
+        throws: [...T_NOT_FOUND_CAPABLE, "INVALID_TARGET", "INVALID_INPUT"]
       }),
       referenceDocPath: "lists/create.mdx",
       referenceGroup: "lists",
@@ -2437,7 +2437,7 @@ var init_operation_definitions = __esm(() => {
     },
     "lists.applyTemplate": {
       memberPath: "lists.applyTemplate",
-      description: "Apply a captured ListTemplate to the target list, optionally filtered to specific levels.",
+      description: "Advanced alias for lists.applyStyle. Apply a captured ListTemplate to the target list (abstract-scoped, no clone-on-write).",
       expectedResult: "Returns a ListsMutateItemResult receipt; reports NO_OP if all levels already match.",
       requiresDocumentContext: true,
       metadata: mutationOperation({
@@ -2484,7 +2484,7 @@ var init_operation_definitions = __esm(() => {
     },
     "lists.captureTemplate": {
       memberPath: "lists.captureTemplate",
-      description: "Capture the formatting of a list as a reusable ListTemplate.",
+      description: "Advanced alias for lists.getStyle. Capture list formatting from the abstract definition only (does not merge lvlOverride formatting).",
       expectedResult: "Returns a ListsCaptureTemplateResult containing the captured template.",
       requiresDocumentContext: true,
       metadata: readOperation({
@@ -2497,7 +2497,7 @@ var init_operation_definitions = __esm(() => {
     },
     "lists.setLevelNumbering": {
       memberPath: "lists.setLevelNumbering",
-      description: "Set the numbering format, pattern, and optional start value for a specific list level.",
+      description: "Advanced alias for lists.setLevelNumberStyle/setLevelText/setLevelStart. Set format, pattern, and start in one call (abstract-scoped, no clone-on-write).",
       expectedResult: "Returns a ListsMutateItemResult receipt; reports NO_OP if the level already matches.",
       requiresDocumentContext: true,
       metadata: mutationOperation({
@@ -2622,6 +2622,109 @@ var init_operation_definitions = __esm(() => {
       referenceDocPath: "lists/clear-level-overrides.mdx",
       referenceGroup: "lists"
     },
+    "lists.getStyle": {
+      memberPath: "lists.getStyle",
+      description: "Read the effective reusable style of a list, including instance-level overrides. Returns a ListStyle that can be applied to other lists via lists.applyStyle.",
+      expectedResult: "Returns a ListsGetStyleResult containing the captured style.",
+      requiresDocumentContext: true,
+      metadata: readOperation({
+        idempotency: "idempotent",
+        throws: ["TARGET_NOT_FOUND", "INVALID_TARGET", "INVALID_INPUT"],
+        possibleFailureCodes: ["INVALID_TARGET", "INVALID_INPUT", "LEVEL_OUT_OF_RANGE"]
+      }),
+      referenceDocPath: "lists/get-style.mdx",
+      referenceGroup: "lists"
+    },
+    "lists.applyStyle": {
+      memberPath: "lists.applyStyle",
+      description: "Apply a reusable list style to the target list. Sequence-local: if the abstract definition is shared with other lists, it is cloned first to avoid affecting them.",
+      expectedResult: "Returns a ListsMutateItemResult receipt; reports NO_OP if all levels already match.",
+      requiresDocumentContext: true,
+      metadata: mutationOperation({
+        idempotency: "conditional",
+        supportsDryRun: true,
+        supportsTrackedMode: false,
+        possibleFailureCodes: ["NO_OP", "INVALID_TARGET", "INVALID_INPUT", "LEVEL_OUT_OF_RANGE"],
+        throws: [...T_NOT_FOUND_CAPABLE, "INVALID_TARGET", "INVALID_INPUT"]
+      }),
+      referenceDocPath: "lists/apply-style.mdx",
+      referenceGroup: "lists"
+    },
+    "lists.restartAt": {
+      memberPath: "lists.restartAt",
+      description: "Restart numbering at the target list item with a specific value. If the item is mid-sequence, it is separated first.",
+      expectedResult: "Returns a ListsMutateItemResult receipt.",
+      requiresDocumentContext: true,
+      metadata: mutationOperation({
+        idempotency: "non-idempotent",
+        supportsDryRun: true,
+        supportsTrackedMode: false,
+        possibleFailureCodes: ["NO_OP", "INVALID_TARGET", "INVALID_INPUT"],
+        throws: [...T_NOT_FOUND_CAPABLE, "INVALID_TARGET", "INVALID_INPUT"]
+      }),
+      referenceDocPath: "lists/restart-at.mdx",
+      referenceGroup: "lists"
+    },
+    "lists.setLevelNumberStyle": {
+      memberPath: "lists.setLevelNumberStyle",
+      description: 'Set the numbering style (e.g. decimal, lowerLetter, upperRoman) for a specific list level. Rejects "bullet" — use setLevelBullet instead. Sequence-local: clones shared definitions.',
+      expectedResult: "Returns a ListsMutateItemResult receipt; reports NO_OP if the value already matches.",
+      requiresDocumentContext: true,
+      metadata: mutationOperation({
+        idempotency: "conditional",
+        supportsDryRun: true,
+        supportsTrackedMode: false,
+        possibleFailureCodes: ["NO_OP", "INVALID_TARGET", "INVALID_INPUT", "LEVEL_OUT_OF_RANGE", "LEVEL_NOT_FOUND"],
+        throws: [...T_NOT_FOUND_CAPABLE, "INVALID_TARGET", "INVALID_INPUT"]
+      }),
+      referenceDocPath: "lists/set-level-number-style.mdx",
+      referenceGroup: "lists"
+    },
+    "lists.setLevelText": {
+      memberPath: "lists.setLevelText",
+      description: 'Set the level text pattern (e.g. "%1.", "(%1)") for a specific list level. Uses OOXML level-placeholder syntax. Sequence-local: clones shared definitions.',
+      expectedResult: "Returns a ListsMutateItemResult receipt; reports NO_OP if the value already matches.",
+      requiresDocumentContext: true,
+      metadata: mutationOperation({
+        idempotency: "conditional",
+        supportsDryRun: true,
+        supportsTrackedMode: false,
+        possibleFailureCodes: ["NO_OP", "INVALID_TARGET", "INVALID_INPUT", "LEVEL_OUT_OF_RANGE", "LEVEL_NOT_FOUND"],
+        throws: [...T_NOT_FOUND_CAPABLE, "INVALID_TARGET"]
+      }),
+      referenceDocPath: "lists/set-level-text.mdx",
+      referenceGroup: "lists"
+    },
+    "lists.setLevelStart": {
+      memberPath: "lists.setLevelStart",
+      description: "Set the start value for a specific list level. Rejects bullet levels and non-positive values. Sequence-local: clones shared definitions.",
+      expectedResult: "Returns a ListsMutateItemResult receipt; reports NO_OP if the value already matches.",
+      requiresDocumentContext: true,
+      metadata: mutationOperation({
+        idempotency: "conditional",
+        supportsDryRun: true,
+        supportsTrackedMode: false,
+        possibleFailureCodes: ["NO_OP", "INVALID_TARGET", "INVALID_INPUT", "LEVEL_OUT_OF_RANGE", "LEVEL_NOT_FOUND"],
+        throws: [...T_NOT_FOUND_CAPABLE, "INVALID_TARGET", "INVALID_INPUT"]
+      }),
+      referenceDocPath: "lists/set-level-start.mdx",
+      referenceGroup: "lists"
+    },
+    "lists.setLevelLayout": {
+      memberPath: "lists.setLevelLayout",
+      description: "Set the layout properties (alignment, indentation, trailing character, tab stop) for a specific list level. Accepts partial updates — omitted fields are left unchanged. Sequence-local: clones shared definitions.",
+      expectedResult: "Returns a ListsMutateItemResult receipt; reports NO_OP if all values already match.",
+      requiresDocumentContext: true,
+      metadata: mutationOperation({
+        idempotency: "conditional",
+        supportsDryRun: true,
+        supportsTrackedMode: false,
+        possibleFailureCodes: ["NO_OP", "INVALID_TARGET", "INVALID_INPUT", "LEVEL_OUT_OF_RANGE", "LEVEL_NOT_FOUND"],
+        throws: [...T_NOT_FOUND_CAPABLE, "INVALID_TARGET", "INVALID_INPUT"]
+      }),
+      referenceDocPath: "lists/set-level-layout.mdx",
+      referenceGroup: "lists"
+    },
     "comments.create": {
       memberPath: "comments.create",
       description: "Create a new comment thread (or reply when parentCommentId is given).",
@@ -9477,13 +9580,65 @@ var init_schemas = __esm(() => {
           at: ref("BlockAddress"),
           target: ref("BlockAddressOrRange"),
           kind: listKindSchema,
-          level: { type: "integer", minimum: 0, maximum: 8 }
+          level: { type: "integer", minimum: 0, maximum: 8 },
+          preset: {
+            enum: [
+              "decimal",
+              "decimalParenthesis",
+              "lowerLetter",
+              "upperLetter",
+              "lowerRoman",
+              "upperRoman",
+              "disc",
+              "circle",
+              "square",
+              "dash"
+            ]
+          },
+          style: objectSchema({
+            version: { const: 1 },
+            levels: arraySchema(objectSchema({
+              level: { type: "integer", minimum: 0, maximum: 8 },
+              numFmt: { type: "string" },
+              lvlText: { type: "string" },
+              start: { type: "integer" },
+              alignment: { enum: ["left", "center", "right"] },
+              indents: objectSchema({
+                left: { type: "integer" },
+                hanging: { type: "integer" },
+                firstLine: { type: "integer" }
+              }),
+              trailingCharacter: { enum: ["tab", "space", "nothing"] },
+              markerFont: { type: "string" },
+              pictureBulletId: { type: "integer" },
+              tabStopAt: { type: ["integer", "null"] }
+            }, ["level"]))
+          }, ["version", "levels"]),
+          sequence: {
+            oneOf: [
+              objectSchema({ mode: { const: "new" }, startAt: { type: "integer", minimum: 1 } }, ["mode"]),
+              objectSchema({ mode: { const: "continuePrevious" } }, ["mode"])
+            ]
+          }
         },
-        required: ["mode", "kind"],
+        required: ["mode"],
         additionalProperties: false,
-        if: { properties: { mode: { const: "empty" } } },
-        then: { required: ["mode", "kind", "at"] },
-        else: { required: ["mode", "kind", "target"] }
+        allOf: [
+          {
+            if: { properties: { mode: { const: "empty" } } },
+            then: { required: ["mode", "at"] },
+            else: { required: ["mode", "target"] }
+          },
+          {
+            if: {
+              properties: { sequence: { properties: { mode: { const: "continuePrevious" } }, required: ["mode"] } },
+              required: ["sequence"]
+            },
+            then: {
+              not: { anyOf: [{ required: ["preset"] }, { required: ["style"] }] }
+            }
+          }
+        ]
       },
       output: {
         oneOf: [
@@ -9831,6 +9986,124 @@ var init_schemas = __esm(() => {
       success: listsMutateItemSuccessSchema,
       failure: listsFailureSchemaFor("lists.clearLevelOverrides")
     },
+    "lists.getStyle": (() => {
+      const listLevelTemplateSchema = objectSchema({
+        level: { type: "integer", minimum: 0, maximum: 8 },
+        numFmt: { type: "string" },
+        lvlText: { type: "string" },
+        start: { type: "integer" },
+        alignment: { enum: ["left", "center", "right"] },
+        indents: objectSchema({
+          left: { type: "integer" },
+          hanging: { type: "integer" },
+          firstLine: { type: "integer" }
+        }),
+        trailingCharacter: { enum: ["tab", "space", "nothing"] },
+        markerFont: { type: "string" },
+        pictureBulletId: { type: "integer" },
+        tabStopAt: { type: ["integer", "null"] }
+      }, ["level"]);
+      const styleSchema = objectSchema({
+        version: { const: 1 },
+        levels: arraySchema(listLevelTemplateSchema)
+      }, ["version", "levels"]);
+      const successSchema = objectSchema({
+        success: { const: true },
+        style: styleSchema
+      }, ["success", "style"]);
+      return {
+        input: objectSchema({
+          target: listItemAddressSchema,
+          levels: arraySchema({ type: "integer", minimum: 0, maximum: 8 })
+        }, ["target"]),
+        output: { oneOf: [successSchema, listsFailureSchemaFor("lists.getStyle")] },
+        success: successSchema,
+        failure: listsFailureSchemaFor("lists.getStyle")
+      };
+    })(),
+    "lists.applyStyle": {
+      input: objectSchema({
+        target: listItemAddressSchema,
+        style: objectSchema({
+          version: { const: 1 },
+          levels: arraySchema(objectSchema({
+            level: { type: "integer", minimum: 0, maximum: 8 },
+            numFmt: { type: "string" },
+            lvlText: { type: "string" },
+            start: { type: "integer" },
+            alignment: { enum: ["left", "center", "right"] },
+            indents: objectSchema({
+              left: { type: "integer" },
+              hanging: { type: "integer" },
+              firstLine: { type: "integer" }
+            }),
+            trailingCharacter: { enum: ["tab", "space", "nothing"] },
+            markerFont: { type: "string" },
+            pictureBulletId: { type: "integer" },
+            tabStopAt: { type: ["integer", "null"] }
+          }, ["level"]))
+        }, ["version", "levels"]),
+        levels: arraySchema({ type: "integer", minimum: 0, maximum: 8 })
+      }, ["target", "style"]),
+      output: listsMutateItemResultSchemaFor("lists.applyStyle"),
+      success: listsMutateItemSuccessSchema,
+      failure: listsFailureSchemaFor("lists.applyStyle")
+    },
+    "lists.restartAt": {
+      input: objectSchema({
+        target: listItemAddressSchema,
+        startAt: { type: "integer", minimum: 1 }
+      }, ["target", "startAt"]),
+      output: listsMutateItemResultSchemaFor("lists.restartAt"),
+      success: listsMutateItemSuccessSchema,
+      failure: listsFailureSchemaFor("lists.restartAt")
+    },
+    "lists.setLevelNumberStyle": {
+      input: objectSchema({
+        target: listItemAddressSchema,
+        level: { type: "integer", minimum: 0, maximum: 8 },
+        numberStyle: { type: "string" }
+      }, ["target", "level", "numberStyle"]),
+      output: listsMutateItemResultSchemaFor("lists.setLevelNumberStyle"),
+      success: listsMutateItemSuccessSchema,
+      failure: listsFailureSchemaFor("lists.setLevelNumberStyle")
+    },
+    "lists.setLevelText": {
+      input: objectSchema({
+        target: listItemAddressSchema,
+        level: { type: "integer", minimum: 0, maximum: 8 },
+        text: { type: "string" }
+      }, ["target", "level", "text"]),
+      output: listsMutateItemResultSchemaFor("lists.setLevelText"),
+      success: listsMutateItemSuccessSchema,
+      failure: listsFailureSchemaFor("lists.setLevelText")
+    },
+    "lists.setLevelStart": {
+      input: objectSchema({
+        target: listItemAddressSchema,
+        level: { type: "integer", minimum: 0, maximum: 8 },
+        startAt: { type: "integer", minimum: 1 }
+      }, ["target", "level", "startAt"]),
+      output: listsMutateItemResultSchemaFor("lists.setLevelStart"),
+      success: listsMutateItemSuccessSchema,
+      failure: listsFailureSchemaFor("lists.setLevelStart")
+    },
+    "lists.setLevelLayout": {
+      input: objectSchema({
+        target: listItemAddressSchema,
+        level: { type: "integer", minimum: 0, maximum: 8 },
+        layout: objectSchema({
+          alignment: { enum: ["left", "center", "right"] },
+          alignedAt: { type: "integer" },
+          textIndentAt: { type: "integer" },
+          followCharacter: { enum: ["tab", "space", "nothing"] },
+          tabStopAt: { type: ["integer", "null"] }
+        })
+      }, ["target", "level", "layout"]),
+      output: listsMutateItemResultSchemaFor("lists.setLevelLayout"),
+      success: listsMutateItemSuccessSchema,
+      failure: listsFailureSchemaFor("lists.setLevelLayout")
+    },
     "comments.create": {
       input: objectSchema({
         text: { type: "string" },
@@ -13212,6 +13485,34 @@ function executeListsSetType(adapter, input, options) {
   validateListTarget(input, "lists.setType");
   return adapter.setType(input, normalizeMutationOptions(options));
 }
+function executeListsGetStyle(adapter, input) {
+  validateListTarget(input, "lists.getStyle");
+  return adapter.getStyle(input);
+}
+function executeListsApplyStyle(adapter, input, options) {
+  validateListTarget(input, "lists.applyStyle");
+  return adapter.applyStyle(input, normalizeMutationOptions(options));
+}
+function executeListsRestartAt(adapter, input, options) {
+  validateListTarget(input, "lists.restartAt");
+  return adapter.restartAt(input, normalizeMutationOptions(options));
+}
+function executeListsSetLevelNumberStyle(adapter, input, options) {
+  validateListTarget(input, "lists.setLevelNumberStyle");
+  return adapter.setLevelNumberStyle(input, normalizeMutationOptions(options));
+}
+function executeListsSetLevelText(adapter, input, options) {
+  validateListTarget(input, "lists.setLevelText");
+  return adapter.setLevelText(input, normalizeMutationOptions(options));
+}
+function executeListsSetLevelStart(adapter, input, options) {
+  validateListTarget(input, "lists.setLevelStart");
+  return adapter.setLevelStart(input, normalizeMutationOptions(options));
+}
+function executeListsSetLevelLayout(adapter, input, options) {
+  validateListTarget(input, "lists.setLevelLayout");
+  return adapter.setLevelLayout(input, normalizeMutationOptions(options));
+}
 var init_lists = __esm(() => {
   init_errors2();
 });
@@ -13673,6 +13974,13 @@ function buildDispatchTable(api) {
     "lists.setLevelTrailingCharacter": (input, options) => api.lists.setLevelTrailingCharacter(input, options),
     "lists.setLevelMarkerFont": (input, options) => api.lists.setLevelMarkerFont(input, options),
     "lists.clearLevelOverrides": (input, options) => api.lists.clearLevelOverrides(input, options),
+    "lists.getStyle": (input) => api.lists.getStyle(input),
+    "lists.applyStyle": (input, options) => api.lists.applyStyle(input, options),
+    "lists.restartAt": (input, options) => api.lists.restartAt(input, options),
+    "lists.setLevelNumberStyle": (input, options) => api.lists.setLevelNumberStyle(input, options),
+    "lists.setLevelText": (input, options) => api.lists.setLevelText(input, options),
+    "lists.setLevelStart": (input, options) => api.lists.setLevelStart(input, options),
+    "lists.setLevelLayout": (input, options) => api.lists.setLevelLayout(input, options),
     "sections.list": (input) => api.sections.list(input),
     "sections.get": (input) => api.sections.get(input),
     "sections.setBreakType": (input, options) => api.sections.setBreakType(input, options),
@@ -15944,6 +16252,27 @@ function createDocumentApi(adapters) {
       },
       setType(input, options) {
         return executeListsSetType(adapters.lists, input, options);
+      },
+      getStyle(input) {
+        return executeListsGetStyle(adapters.lists, input);
+      },
+      applyStyle(input, options) {
+        return executeListsApplyStyle(adapters.lists, input, options);
+      },
+      restartAt(input, options) {
+        return executeListsRestartAt(adapters.lists, input, options);
+      },
+      setLevelNumberStyle(input, options) {
+        return executeListsSetLevelNumberStyle(adapters.lists, input, options);
+      },
+      setLevelText(input, options) {
+        return executeListsSetLevelText(adapters.lists, input, options);
+      },
+      setLevelStart(input, options) {
+        return executeListsSetLevelStart(adapters.lists, input, options);
+      },
+      setLevelLayout(input, options) {
+        return executeListsSetLevelLayout(adapters.lists, input, options);
       }
     },
     sections: {
@@ -39004,7 +39333,7 @@ var init_remark_gfm_z_sDF4ss_es = __esm(() => {
   emptyOptions2 = {};
 });
 
-// ../../packages/superdoc/dist/chunks/SuperConverter-BcBeadrv.es.js
+// ../../packages/superdoc/dist/chunks/SuperConverter-hOU3ez7P.es.js
 function getExtensionConfigField(extension$1, field, context = { name: "" }) {
   const fieldValue = extension$1.config[field];
   if (typeof fieldValue === "function")
@@ -42390,6 +42719,34 @@ function executeListsSetType2(adapter, input, options) {
   validateListTarget2(input, "lists.setType");
   return adapter.setType(input, normalizeMutationOptions2(options));
 }
+function executeListsGetStyle2(adapter, input) {
+  validateListTarget2(input, "lists.getStyle");
+  return adapter.getStyle(input);
+}
+function executeListsApplyStyle2(adapter, input, options) {
+  validateListTarget2(input, "lists.applyStyle");
+  return adapter.applyStyle(input, normalizeMutationOptions2(options));
+}
+function executeListsRestartAt2(adapter, input, options) {
+  validateListTarget2(input, "lists.restartAt");
+  return adapter.restartAt(input, normalizeMutationOptions2(options));
+}
+function executeListsSetLevelNumberStyle2(adapter, input, options) {
+  validateListTarget2(input, "lists.setLevelNumberStyle");
+  return adapter.setLevelNumberStyle(input, normalizeMutationOptions2(options));
+}
+function executeListsSetLevelText2(adapter, input, options) {
+  validateListTarget2(input, "lists.setLevelText");
+  return adapter.setLevelText(input, normalizeMutationOptions2(options));
+}
+function executeListsSetLevelStart2(adapter, input, options) {
+  validateListTarget2(input, "lists.setLevelStart");
+  return adapter.setLevelStart(input, normalizeMutationOptions2(options));
+}
+function executeListsSetLevelLayout2(adapter, input, options) {
+  validateListTarget2(input, "lists.setLevelLayout");
+  return adapter.setLevelLayout(input, normalizeMutationOptions2(options));
+}
 function isStructuralReplaceInput2(input) {
   return "content" in input && input.content !== undefined;
 }
@@ -42760,6 +43117,13 @@ function buildDispatchTable2(api) {
     "lists.setLevelTrailingCharacter": (input, options) => api.lists.setLevelTrailingCharacter(input, options),
     "lists.setLevelMarkerFont": (input, options) => api.lists.setLevelMarkerFont(input, options),
     "lists.clearLevelOverrides": (input, options) => api.lists.clearLevelOverrides(input, options),
+    "lists.getStyle": (input) => api.lists.getStyle(input),
+    "lists.applyStyle": (input, options) => api.lists.applyStyle(input, options),
+    "lists.restartAt": (input, options) => api.lists.restartAt(input, options),
+    "lists.setLevelNumberStyle": (input, options) => api.lists.setLevelNumberStyle(input, options),
+    "lists.setLevelText": (input, options) => api.lists.setLevelText(input, options),
+    "lists.setLevelStart": (input, options) => api.lists.setLevelStart(input, options),
+    "lists.setLevelLayout": (input, options) => api.lists.setLevelLayout(input, options),
     "sections.list": (input) => api.sections.list(input),
     "sections.get": (input) => api.sections.get(input),
     "sections.setBreakType": (input, options) => api.sections.setBreakType(input, options),
@@ -44775,6 +45139,27 @@ function createDocumentApi2(adapters) {
       },
       setType(input, options) {
         return executeListsSetType2(adapters.lists, input, options);
+      },
+      getStyle(input) {
+        return executeListsGetStyle2(adapters.lists, input);
+      },
+      applyStyle(input, options) {
+        return executeListsApplyStyle2(adapters.lists, input, options);
+      },
+      restartAt(input, options) {
+        return executeListsRestartAt2(adapters.lists, input, options);
+      },
+      setLevelNumberStyle(input, options) {
+        return executeListsSetLevelNumberStyle2(adapters.lists, input, options);
+      },
+      setLevelText(input, options) {
+        return executeListsSetLevelText2(adapters.lists, input, options);
+      },
+      setLevelStart(input, options) {
+        return executeListsSetLevelStart2(adapters.lists, input, options);
+      },
+      setLevelLayout(input, options) {
+        return executeListsSetLevelLayout2(adapters.lists, input, options);
       }
     },
     sections: {
@@ -82488,7 +82873,7 @@ var isRegExp = (value) => {
       state.kern = kernNode.attributes["w:val"];
   }
 }, SuperConverter;
-var init_SuperConverter_BcBeadrv_es = __esm(() => {
+var init_SuperConverter_hOU3ez7P_es = __esm(() => {
   init_rolldown_runtime_B2q5OVn9_es();
   init_jszip_ChlR43oI_es();
   init_xml_js_BtmJ6bNs_es();
@@ -86540,15 +86925,24 @@ var init_SuperConverter_BcBeadrv_es = __esm(() => {
     },
     "lists.create": {
       memberPath: "lists.create",
-      description: "Create a new list from one or more paragraphs, or convert existing paragraphs into a new list.",
+      description: 'Create a new list from one or more paragraphs. Supports optional preset or style for new sequences. When sequence.mode is "continuePrevious", preset and style are not allowed — the new items inherit formatting from the previous sequence.',
       expectedResult: "Returns a ListsCreateResult with the new listId and the first item address.",
       requiresDocumentContext: true,
       metadata: mutationOperation2({
         idempotency: "non-idempotent",
         supportsDryRun: true,
         supportsTrackedMode: false,
-        possibleFailureCodes: ["INVALID_TARGET", "LEVEL_OUT_OF_RANGE"],
-        throws: [...T_NOT_FOUND_CAPABLE2, "INVALID_TARGET"]
+        possibleFailureCodes: [
+          "INVALID_TARGET",
+          "LEVEL_OUT_OF_RANGE",
+          "INVALID_INPUT",
+          "NO_COMPATIBLE_PREVIOUS"
+        ],
+        throws: [
+          ...T_NOT_FOUND_CAPABLE2,
+          "INVALID_TARGET",
+          "INVALID_INPUT"
+        ]
       }),
       referenceDocPath: "lists/create.mdx",
       referenceGroup: "lists",
@@ -86783,7 +87177,7 @@ var init_SuperConverter_BcBeadrv_es = __esm(() => {
     },
     "lists.applyTemplate": {
       memberPath: "lists.applyTemplate",
-      description: "Apply a captured ListTemplate to the target list, optionally filtered to specific levels.",
+      description: "Advanced alias for lists.applyStyle. Apply a captured ListTemplate to the target list (abstract-scoped, no clone-on-write).",
       expectedResult: "Returns a ListsMutateItemResult receipt; reports NO_OP if all levels already match.",
       requiresDocumentContext: true,
       metadata: mutationOperation2({
@@ -86856,7 +87250,7 @@ var init_SuperConverter_BcBeadrv_es = __esm(() => {
     },
     "lists.captureTemplate": {
       memberPath: "lists.captureTemplate",
-      description: "Capture the formatting of a list as a reusable ListTemplate.",
+      description: "Advanced alias for lists.getStyle. Capture list formatting from the abstract definition only (does not merge lvlOverride formatting).",
       expectedResult: "Returns a ListsCaptureTemplateResult containing the captured template.",
       requiresDocumentContext: true,
       metadata: readOperation2({
@@ -86877,7 +87271,7 @@ var init_SuperConverter_BcBeadrv_es = __esm(() => {
     },
     "lists.setLevelNumbering": {
       memberPath: "lists.setLevelNumbering",
-      description: "Set the numbering format, pattern, and optional start value for a specific list level.",
+      description: "Advanced alias for lists.setLevelNumberStyle/setLevelText/setLevelStart. Set format, pattern, and start in one call (abstract-scoped, no clone-on-write).",
       expectedResult: "Returns a ListsMutateItemResult receipt; reports NO_OP if the level already matches.",
       requiresDocumentContext: true,
       metadata: mutationOperation2({
@@ -87045,6 +87439,170 @@ var init_SuperConverter_BcBeadrv_es = __esm(() => {
       referenceDocPath: "lists/clear-level-overrides.mdx",
       referenceGroup: "lists"
     },
+    "lists.getStyle": {
+      memberPath: "lists.getStyle",
+      description: "Read the effective reusable style of a list, including instance-level overrides. Returns a ListStyle that can be applied to other lists via lists.applyStyle.",
+      expectedResult: "Returns a ListsGetStyleResult containing the captured style.",
+      requiresDocumentContext: true,
+      metadata: readOperation2({
+        idempotency: "idempotent",
+        throws: [
+          "TARGET_NOT_FOUND",
+          "INVALID_TARGET",
+          "INVALID_INPUT"
+        ],
+        possibleFailureCodes: [
+          "INVALID_TARGET",
+          "INVALID_INPUT",
+          "LEVEL_OUT_OF_RANGE"
+        ]
+      }),
+      referenceDocPath: "lists/get-style.mdx",
+      referenceGroup: "lists"
+    },
+    "lists.applyStyle": {
+      memberPath: "lists.applyStyle",
+      description: "Apply a reusable list style to the target list. Sequence-local: if the abstract definition is shared with other lists, it is cloned first to avoid affecting them.",
+      expectedResult: "Returns a ListsMutateItemResult receipt; reports NO_OP if all levels already match.",
+      requiresDocumentContext: true,
+      metadata: mutationOperation2({
+        idempotency: "conditional",
+        supportsDryRun: true,
+        supportsTrackedMode: false,
+        possibleFailureCodes: [
+          "NO_OP",
+          "INVALID_TARGET",
+          "INVALID_INPUT",
+          "LEVEL_OUT_OF_RANGE"
+        ],
+        throws: [
+          ...T_NOT_FOUND_CAPABLE2,
+          "INVALID_TARGET",
+          "INVALID_INPUT"
+        ]
+      }),
+      referenceDocPath: "lists/apply-style.mdx",
+      referenceGroup: "lists"
+    },
+    "lists.restartAt": {
+      memberPath: "lists.restartAt",
+      description: "Restart numbering at the target list item with a specific value. If the item is mid-sequence, it is separated first.",
+      expectedResult: "Returns a ListsMutateItemResult receipt.",
+      requiresDocumentContext: true,
+      metadata: mutationOperation2({
+        idempotency: "non-idempotent",
+        supportsDryRun: true,
+        supportsTrackedMode: false,
+        possibleFailureCodes: [
+          "NO_OP",
+          "INVALID_TARGET",
+          "INVALID_INPUT"
+        ],
+        throws: [
+          ...T_NOT_FOUND_CAPABLE2,
+          "INVALID_TARGET",
+          "INVALID_INPUT"
+        ]
+      }),
+      referenceDocPath: "lists/restart-at.mdx",
+      referenceGroup: "lists"
+    },
+    "lists.setLevelNumberStyle": {
+      memberPath: "lists.setLevelNumberStyle",
+      description: 'Set the numbering style (e.g. decimal, lowerLetter, upperRoman) for a specific list level. Rejects "bullet" — use setLevelBullet instead. Sequence-local: clones shared definitions.',
+      expectedResult: "Returns a ListsMutateItemResult receipt; reports NO_OP if the value already matches.",
+      requiresDocumentContext: true,
+      metadata: mutationOperation2({
+        idempotency: "conditional",
+        supportsDryRun: true,
+        supportsTrackedMode: false,
+        possibleFailureCodes: [
+          "NO_OP",
+          "INVALID_TARGET",
+          "INVALID_INPUT",
+          "LEVEL_OUT_OF_RANGE",
+          "LEVEL_NOT_FOUND"
+        ],
+        throws: [
+          ...T_NOT_FOUND_CAPABLE2,
+          "INVALID_TARGET",
+          "INVALID_INPUT"
+        ]
+      }),
+      referenceDocPath: "lists/set-level-number-style.mdx",
+      referenceGroup: "lists"
+    },
+    "lists.setLevelText": {
+      memberPath: "lists.setLevelText",
+      description: 'Set the level text pattern (e.g. "%1.", "(%1)") for a specific list level. Uses OOXML level-placeholder syntax. Sequence-local: clones shared definitions.',
+      expectedResult: "Returns a ListsMutateItemResult receipt; reports NO_OP if the value already matches.",
+      requiresDocumentContext: true,
+      metadata: mutationOperation2({
+        idempotency: "conditional",
+        supportsDryRun: true,
+        supportsTrackedMode: false,
+        possibleFailureCodes: [
+          "NO_OP",
+          "INVALID_TARGET",
+          "INVALID_INPUT",
+          "LEVEL_OUT_OF_RANGE",
+          "LEVEL_NOT_FOUND"
+        ],
+        throws: [...T_NOT_FOUND_CAPABLE2, "INVALID_TARGET"]
+      }),
+      referenceDocPath: "lists/set-level-text.mdx",
+      referenceGroup: "lists"
+    },
+    "lists.setLevelStart": {
+      memberPath: "lists.setLevelStart",
+      description: "Set the start value for a specific list level. Rejects bullet levels and non-positive values. Sequence-local: clones shared definitions.",
+      expectedResult: "Returns a ListsMutateItemResult receipt; reports NO_OP if the value already matches.",
+      requiresDocumentContext: true,
+      metadata: mutationOperation2({
+        idempotency: "conditional",
+        supportsDryRun: true,
+        supportsTrackedMode: false,
+        possibleFailureCodes: [
+          "NO_OP",
+          "INVALID_TARGET",
+          "INVALID_INPUT",
+          "LEVEL_OUT_OF_RANGE",
+          "LEVEL_NOT_FOUND"
+        ],
+        throws: [
+          ...T_NOT_FOUND_CAPABLE2,
+          "INVALID_TARGET",
+          "INVALID_INPUT"
+        ]
+      }),
+      referenceDocPath: "lists/set-level-start.mdx",
+      referenceGroup: "lists"
+    },
+    "lists.setLevelLayout": {
+      memberPath: "lists.setLevelLayout",
+      description: "Set the layout properties (alignment, indentation, trailing character, tab stop) for a specific list level. Accepts partial updates — omitted fields are left unchanged. Sequence-local: clones shared definitions.",
+      expectedResult: "Returns a ListsMutateItemResult receipt; reports NO_OP if all values already match.",
+      requiresDocumentContext: true,
+      metadata: mutationOperation2({
+        idempotency: "conditional",
+        supportsDryRun: true,
+        supportsTrackedMode: false,
+        possibleFailureCodes: [
+          "NO_OP",
+          "INVALID_TARGET",
+          "INVALID_INPUT",
+          "LEVEL_OUT_OF_RANGE",
+          "LEVEL_NOT_FOUND"
+        ],
+        throws: [
+          ...T_NOT_FOUND_CAPABLE2,
+          "INVALID_TARGET",
+          "INVALID_INPUT"
+        ]
+      }),
+      referenceDocPath: "lists/set-level-layout.mdx",
+      referenceGroup: "lists"
+    },
     "comments.create": {
       memberPath: "comments.create",
       description: "Create a new comment thread (or reply when parentCommentId is given).",
@@ -93318,6 +93876,42 @@ var init_SuperConverter_BcBeadrv_es = __esm(() => {
     position: listInsertPositionSchema2,
     text: { type: "string" }
   }, ["target", "position"]), listsInsertResultSchemaFor2("lists.insert"), listsFailureSchemaFor2("lists.insert"), ref2("BlockAddress"), ref2("BlockAddressOrRange"), objectSchema2({
+    version: { const: 1 },
+    levels: arraySchema2(objectSchema2({
+      level: {
+        type: "integer",
+        minimum: 0,
+        maximum: 8
+      },
+      numFmt: { type: "string" },
+      lvlText: { type: "string" },
+      start: { type: "integer" },
+      alignment: { enum: [
+        "left",
+        "center",
+        "right"
+      ] },
+      indents: objectSchema2({
+        left: { type: "integer" },
+        hanging: { type: "integer" },
+        firstLine: { type: "integer" }
+      }),
+      trailingCharacter: { enum: [
+        "tab",
+        "space",
+        "nothing"
+      ] },
+      markerFont: { type: "string" },
+      pictureBulletId: { type: "integer" },
+      tabStopAt: { type: ["integer", "null"] }
+    }, ["level"]))
+  }, ["version", "levels"]), objectSchema2({
+    mode: { const: "new" },
+    startAt: {
+      type: "integer",
+      minimum: 1
+    }
+  }, ["mode"]), objectSchema2({ mode: { const: "continuePrevious" } }, ["mode"]), objectSchema2({
     success: { const: true },
     listId: { type: "string" },
     item: listItemAddressSchema2
@@ -93623,7 +94217,164 @@ var init_SuperConverter_BcBeadrv_es = __esm(() => {
       minimum: 0,
       maximum: 8
     }
-  }, ["target", "level"]), listsMutateItemResultSchemaFor2("lists.clearLevelOverrides"), listsFailureSchemaFor2("lists.clearLevelOverrides"), objectSchema2({
+  }, ["target", "level"]), listsMutateItemResultSchemaFor2("lists.clearLevelOverrides"), listsFailureSchemaFor2("lists.clearLevelOverrides"), (() => {
+    const successSchema = objectSchema2({
+      success: { const: true },
+      style: objectSchema2({
+        version: { const: 1 },
+        levels: arraySchema2(objectSchema2({
+          level: {
+            type: "integer",
+            minimum: 0,
+            maximum: 8
+          },
+          numFmt: { type: "string" },
+          lvlText: { type: "string" },
+          start: { type: "integer" },
+          alignment: { enum: [
+            "left",
+            "center",
+            "right"
+          ] },
+          indents: objectSchema2({
+            left: { type: "integer" },
+            hanging: { type: "integer" },
+            firstLine: { type: "integer" }
+          }),
+          trailingCharacter: { enum: [
+            "tab",
+            "space",
+            "nothing"
+          ] },
+          markerFont: { type: "string" },
+          pictureBulletId: { type: "integer" },
+          tabStopAt: { type: ["integer", "null"] }
+        }, ["level"]))
+      }, ["version", "levels"])
+    }, ["success", "style"]);
+    return {
+      input: objectSchema2({
+        target: listItemAddressSchema2,
+        levels: arraySchema2({
+          type: "integer",
+          minimum: 0,
+          maximum: 8
+        })
+      }, ["target"]),
+      output: { oneOf: [successSchema, listsFailureSchemaFor2("lists.getStyle")] },
+      success: successSchema,
+      failure: listsFailureSchemaFor2("lists.getStyle")
+    };
+  })(), objectSchema2({
+    target: listItemAddressSchema2,
+    style: objectSchema2({
+      version: { const: 1 },
+      levels: arraySchema2(objectSchema2({
+        level: {
+          type: "integer",
+          minimum: 0,
+          maximum: 8
+        },
+        numFmt: { type: "string" },
+        lvlText: { type: "string" },
+        start: { type: "integer" },
+        alignment: { enum: [
+          "left",
+          "center",
+          "right"
+        ] },
+        indents: objectSchema2({
+          left: { type: "integer" },
+          hanging: { type: "integer" },
+          firstLine: { type: "integer" }
+        }),
+        trailingCharacter: { enum: [
+          "tab",
+          "space",
+          "nothing"
+        ] },
+        markerFont: { type: "string" },
+        pictureBulletId: { type: "integer" },
+        tabStopAt: { type: ["integer", "null"] }
+      }, ["level"]))
+    }, ["version", "levels"]),
+    levels: arraySchema2({
+      type: "integer",
+      minimum: 0,
+      maximum: 8
+    })
+  }, ["target", "style"]), listsMutateItemResultSchemaFor2("lists.applyStyle"), listsFailureSchemaFor2("lists.applyStyle"), objectSchema2({
+    target: listItemAddressSchema2,
+    startAt: {
+      type: "integer",
+      minimum: 1
+    }
+  }, ["target", "startAt"]), listsMutateItemResultSchemaFor2("lists.restartAt"), listsFailureSchemaFor2("lists.restartAt"), objectSchema2({
+    target: listItemAddressSchema2,
+    level: {
+      type: "integer",
+      minimum: 0,
+      maximum: 8
+    },
+    numberStyle: { type: "string" }
+  }, [
+    "target",
+    "level",
+    "numberStyle"
+  ]), listsMutateItemResultSchemaFor2("lists.setLevelNumberStyle"), listsFailureSchemaFor2("lists.setLevelNumberStyle"), objectSchema2({
+    target: listItemAddressSchema2,
+    level: {
+      type: "integer",
+      minimum: 0,
+      maximum: 8
+    },
+    text: { type: "string" }
+  }, [
+    "target",
+    "level",
+    "text"
+  ]), listsMutateItemResultSchemaFor2("lists.setLevelText"), listsFailureSchemaFor2("lists.setLevelText"), objectSchema2({
+    target: listItemAddressSchema2,
+    level: {
+      type: "integer",
+      minimum: 0,
+      maximum: 8
+    },
+    startAt: {
+      type: "integer",
+      minimum: 1
+    }
+  }, [
+    "target",
+    "level",
+    "startAt"
+  ]), listsMutateItemResultSchemaFor2("lists.setLevelStart"), listsFailureSchemaFor2("lists.setLevelStart"), objectSchema2({
+    target: listItemAddressSchema2,
+    level: {
+      type: "integer",
+      minimum: 0,
+      maximum: 8
+    },
+    layout: objectSchema2({
+      alignment: { enum: [
+        "left",
+        "center",
+        "right"
+      ] },
+      alignedAt: { type: "integer" },
+      textIndentAt: { type: "integer" },
+      followCharacter: { enum: [
+        "tab",
+        "space",
+        "nothing"
+      ] },
+      tabStopAt: { type: ["integer", "null"] }
+    })
+  }, [
+    "target",
+    "level",
+    "layout"
+  ]), listsMutateItemResultSchemaFor2("lists.setLevelLayout"), listsFailureSchemaFor2("lists.setLevelLayout"), objectSchema2({
     text: { type: "string" },
     target: textAddressSchema2,
     parentCommentId: { type: "string" }
@@ -144352,7 +145103,7 @@ var init_remark_gfm_CjV8kaUy_es = __esm(() => {
   init_remark_gfm_z_sDF4ss_es();
 });
 
-// ../../packages/superdoc/dist/chunks/src-B0uLvfdR.es.js
+// ../../packages/superdoc/dist/chunks/src-D3r_lb_g.es.js
 function deleteProps(obj, propOrProps) {
   const props = typeof propOrProps === "string" ? [propOrProps] : propOrProps;
   const removeNested = (target, pathParts, index2 = 0) => {
@@ -144437,6 +145188,90 @@ function getSuperdocVersion() {
     return "unknown";
   }
 }
+function getPreservedSelection(state) {
+  return CustomSelectionPluginKey.getState(state)?.preservedSelection ?? null;
+}
+function createSelectionTrackingBookmark(selection) {
+  if (selection instanceof TextSelection2 && !selection.empty)
+    return new InclusiveTextSelectionBookmark(selection.anchor, selection.head);
+  return selection.getBookmark();
+}
+function createSelectionHandlePlugin() {
+  return new Plugin({
+    key: SelectionHandlePluginKey,
+    state: {
+      init() {
+        return { entries: /* @__PURE__ */ new Map };
+      },
+      apply(tr, prev) {
+        const meta2 = tr.getMeta(SelectionHandlePluginKey);
+        let entries = prev.entries;
+        if (tr.docChanged && entries.size > 0) {
+          const next2 = /* @__PURE__ */ new Map;
+          for (const [id2, entry] of entries)
+            next2.set(id2, {
+              ...entry,
+              bookmark: entry.bookmark.map(tr.mapping)
+            });
+          entries = next2;
+        }
+        if (meta2?.action === "capture") {
+          if (entries === prev.entries)
+            entries = new Map(entries);
+          entries.set(meta2.entry.id, meta2.entry);
+        } else if (meta2?.action === "release") {
+          if (entries.has(meta2.id)) {
+            if (entries === prev.entries)
+              entries = new Map(entries);
+            entries.delete(meta2.id);
+          }
+        }
+        return entries === prev.entries ? prev : { entries };
+      }
+    }
+  });
+}
+function captureSelectionHandle(owner, selection, surface) {
+  const id2 = nextHandleId++;
+  const bookmark = createSelectionTrackingBookmark(selection);
+  const wasNonEmpty = !selection.empty;
+  const entry = {
+    id: id2,
+    bookmark,
+    wasNonEmpty
+  };
+  const tr = owner.state.tr.setMeta(SelectionHandlePluginKey, {
+    action: "capture",
+    entry
+  });
+  owner.dispatch(tr);
+  return {
+    id: id2,
+    surface,
+    wasNonEmpty,
+    _owner: owner
+  };
+}
+function resolveHandleToSelection(handle3) {
+  const { state } = handle3._owner;
+  const pluginState = SelectionHandlePluginKey.getState(state);
+  if (!pluginState)
+    return null;
+  const entry = pluginState.entries.get(handle3.id);
+  if (!entry)
+    return null;
+  const resolved = entry.bookmark.resolve(state.doc);
+  if (entry.wasNonEmpty && resolved.empty)
+    return null;
+  return resolved;
+}
+function releaseSelectionHandle(handle3) {
+  const { state, dispatch } = handle3._owner;
+  dispatch(state.tr.setMeta(SelectionHandlePluginKey, {
+    action: "release",
+    id: handle3.id
+  }));
+}
 function getFocusMeta(tr) {
   return tr.getMeta(CustomSelectionPluginKey);
 }
@@ -144449,14 +145284,13 @@ function getFocusState(state) {
 function mapPreservedSelection(selection, tr) {
   if (!selection || !tr.docChanged)
     return selection;
-  if (typeof selection.from !== "number" || typeof selection.to !== "number")
-    return null;
-  const from$1 = tr.mapping.map(selection.from, -1);
-  const to = tr.mapping.map(selection.to, 1);
-  if (from$1 >= to)
+  if (typeof selection.getBookmark !== "function")
     return null;
   try {
-    return TextSelection2.create(tr.doc, from$1, to);
+    const resolved = createSelectionTrackingBookmark(selection).map(tr.mapping).resolve(tr.doc);
+    if (!selection.empty && resolved.empty)
+      return null;
+    return resolved;
   } catch {
     return null;
   }
@@ -154693,7 +155527,7 @@ function validateInsertionContext(editor, index2, step3, stepIndex, anchorBlockI
 function isV3Ref(payload) {
   return typeof payload === "object" && payload !== null && "v" in payload && payload.v === 3;
 }
-function resolveAbsoluteRange(editor, candidate, from$1, to, stepId) {
+function resolveAbsoluteRange$1(editor, candidate, from$1, to, stepId) {
   const resolved = resolveTextRangeInBlock(candidate.node, candidate.pos, {
     start: from$1,
     end: to
@@ -154781,7 +155615,7 @@ function coalesceBlockRanges(stepId, blockId, ranges) {
   };
 }
 function buildRangeTarget(editor, step3, addr, candidate) {
-  const abs$1 = resolveAbsoluteRange(editor, candidate, addr.from, addr.to, step3.id);
+  const abs$1 = resolveAbsoluteRange$1(editor, candidate, addr.from, addr.to, step3.id);
   const capturedStyle = step3.op === "text.rewrite" || step3.op === "format.apply" ? captureRunsInRange(editor, candidate.pos, addr.from, addr.to) : undefined;
   return {
     kind: "range",
@@ -154806,7 +155640,7 @@ function buildSpanTarget(editor, index2, step3, segments, matchId) {
     const candidate = index2.candidates.find((c) => c.nodeId === seg.blockId);
     if (!candidate)
       throw planError("INVALID_INPUT", `block "${seg.blockId}" not found for span segment`, step3.id);
-    const abs$1 = resolveAbsoluteRange(editor, candidate, seg.from, seg.to, step3.id);
+    const abs$1 = resolveAbsoluteRange$1(editor, candidate, seg.from, seg.to, step3.id);
     compiledSegments.push({
       blockId: seg.blockId,
       from: seg.from,
@@ -160360,6 +161194,745 @@ function blocksDeleteRangeWrapper(editor, input2, options) {
     dryRun: false
   };
 }
+function findLevelElement(abstract, ilvl) {
+  const ilvlStr = String(ilvl);
+  return abstract.elements?.find((el) => el.name === "w:lvl" && el.attributes?.["w:ilvl"] === ilvlStr);
+}
+function readChildAttr(parent, elementName) {
+  return parent.elements?.find((el) => el.name === elementName)?.attributes?.["w:val"];
+}
+function setChildAttr(parent, elementName, value) {
+  if (!parent.elements)
+    parent.elements = [];
+  const existing = parent.elements.find((el) => el.name === elementName);
+  if (existing) {
+    if (existing.attributes?.["w:val"] === value)
+      return false;
+    if (!existing.attributes)
+      existing.attributes = {};
+    existing.attributes["w:val"] = value;
+    return true;
+  }
+  parent.elements.push({
+    type: "element",
+    name: elementName,
+    attributes: { "w:val": value }
+  });
+  return true;
+}
+function findOrCreateChild(parent, elementName) {
+  if (!parent.elements)
+    parent.elements = [];
+  let child = parent.elements.find((el) => el.name === elementName);
+  if (!child) {
+    child = {
+      type: "element",
+      name: elementName,
+      elements: []
+    };
+    parent.elements.push(child);
+  }
+  if (!child.elements)
+    child.elements = [];
+  return child;
+}
+function resolveAbstractLevel(editor, abstractNumId, ilvl) {
+  const abstract = editor.converter.numbering?.abstracts?.[abstractNumId];
+  if (!abstract)
+    return null;
+  const lvlEl = findLevelElement(abstract, ilvl);
+  if (!lvlEl)
+    return null;
+  return {
+    abstract,
+    lvlEl
+  };
+}
+function hasLevel(editor, abstractNumId, ilvl) {
+  return resolveAbstractLevel(editor, abstractNumId, ilvl) != null;
+}
+function readLevelProperties(lvlEl, ilvl) {
+  const props = { level: ilvl };
+  const numFmt = readChildAttr(lvlEl, "w:numFmt");
+  if (numFmt != null)
+    props.numFmt = numFmt;
+  const lvlText = readChildAttr(lvlEl, "w:lvlText");
+  if (lvlText != null)
+    props.lvlText = lvlText;
+  const startVal = readChildAttr(lvlEl, "w:start");
+  if (startVal != null)
+    props.start = Number(startVal);
+  const alignment$1 = readChildAttr(lvlEl, "w:lvlJc");
+  if (alignment$1 != null)
+    props.alignment = alignment$1;
+  const suff = readChildAttr(lvlEl, "w:suff");
+  if (suff != null)
+    props.trailingCharacter = suff;
+  const picBulletId = readChildAttr(lvlEl, "w:lvlPicBulletId");
+  if (picBulletId != null)
+    props.pictureBulletId = Number(picBulletId);
+  const pPr = lvlEl.elements?.find((el) => el.name === "w:pPr");
+  const ind = pPr?.elements?.find((el) => el.name === "w:ind");
+  if (ind?.attributes) {
+    const indents = {};
+    if (ind.attributes["w:left"] != null)
+      indents.left = Number(ind.attributes["w:left"]);
+    if (ind.attributes["w:hanging"] != null)
+      indents.hanging = Number(ind.attributes["w:hanging"]);
+    if (ind.attributes["w:firstLine"] != null)
+      indents.firstLine = Number(ind.attributes["w:firstLine"]);
+    if (Object.keys(indents).length > 0)
+      props.indents = indents;
+  }
+  const tabStopVal = readLevelTabStop(pPr);
+  if (tabStopVal != null)
+    props.tabStopAt = tabStopVal;
+  const rFonts = lvlEl.elements?.find((el) => el.name === "w:rPr")?.elements?.find((el) => el.name === "w:rFonts");
+  if (rFonts?.attributes?.["w:ascii"])
+    props.markerFont = rFonts.attributes["w:ascii"];
+  return props;
+}
+function readLevelTabStop(pPr) {
+  if (!pPr?.elements)
+    return;
+  const tabs = pPr.elements.find((el) => el.name === "w:tabs");
+  if (!tabs?.elements)
+    return;
+  const tab = tabs.elements.find((el) => el.name === "w:tab");
+  if (!tab?.attributes?.["w:pos"])
+    return;
+  return Number(tab.attributes["w:pos"]);
+}
+function mutateLevelTabStop(lvlEl, value) {
+  const pPr = findOrCreateChild(lvlEl, "w:pPr");
+  if (value === null) {
+    const tabsIdx = pPr.elements.findIndex((el) => el.name === "w:tabs");
+    if (tabsIdx === -1)
+      return false;
+    pPr.elements.splice(tabsIdx, 1);
+    return true;
+  }
+  const tabs = findOrCreateChild(pPr, "w:tabs");
+  const existing = tabs.elements.find((el) => el.name === "w:tab");
+  const posStr = String(value);
+  if (existing) {
+    if (existing.attributes?.["w:pos"] === posStr && existing.attributes?.["w:val"] === "num")
+      return false;
+    existing.attributes = {
+      ...existing.attributes,
+      "w:val": "num",
+      "w:pos": posStr
+    };
+    return true;
+  }
+  tabs.elements.push({
+    type: "element",
+    name: "w:tab",
+    attributes: {
+      "w:val": "num",
+      "w:pos": posStr
+    }
+  });
+  return true;
+}
+function setLevelTabStop(editor, abstractNumId, ilvl, value) {
+  const resolved = resolveAbstractLevel(editor, abstractNumId, ilvl);
+  if (!resolved)
+    return false;
+  return mutateLevelTabStop(resolved.lvlEl, value);
+}
+function clearPictureBulletId(lvlEl) {
+  if (!lvlEl.elements)
+    return false;
+  const idx = lvlEl.elements.findIndex((el) => el.name === "w:lvlPicBulletId");
+  if (idx === -1)
+    return false;
+  lvlEl.elements.splice(idx, 1);
+  return true;
+}
+function mutateLevelNumberStyle(lvlEl, numFmt) {
+  let changed = setChildAttr(lvlEl, "w:numFmt", numFmt);
+  changed = clearPictureBulletId(lvlEl) || changed;
+  return changed;
+}
+function setLevelNumberStyle(editor, abstractNumId, ilvl, numFmt) {
+  const resolved = resolveAbstractLevel(editor, abstractNumId, ilvl);
+  if (!resolved)
+    return false;
+  return mutateLevelNumberStyle(resolved.lvlEl, numFmt);
+}
+function setLevelText(editor, abstractNumId, ilvl, text5) {
+  const resolved = resolveAbstractLevel(editor, abstractNumId, ilvl);
+  if (!resolved)
+    return false;
+  return setChildAttr(resolved.lvlEl, "w:lvlText", text5);
+}
+function setLevelStart(editor, abstractNumId, ilvl, start$1) {
+  const resolved = resolveAbstractLevel(editor, abstractNumId, ilvl);
+  if (!resolved)
+    return false;
+  return setChildAttr(resolved.lvlEl, "w:start", String(start$1));
+}
+function applyLevelPropertiesToElement(lvlEl, entry) {
+  let changed = false;
+  if (entry.numFmt != null || entry.lvlText != null) {
+    const fmtParams = {};
+    if (entry.numFmt != null)
+      fmtParams.numFmt = entry.numFmt;
+    if (entry.lvlText != null)
+      fmtParams.lvlText = entry.lvlText;
+    if (entry.start != null)
+      fmtParams.start = entry.start;
+    if (fmtParams.numFmt != null && fmtParams.lvlText != null)
+      changed = mutateLevelNumberingFormat(lvlEl, fmtParams) || changed;
+    else {
+      if (fmtParams.numFmt != null)
+        changed = setChildAttr(lvlEl, "w:numFmt", fmtParams.numFmt) || changed;
+      if (fmtParams.lvlText != null)
+        changed = setChildAttr(lvlEl, "w:lvlText", fmtParams.lvlText) || changed;
+      if (fmtParams.start != null)
+        changed = setChildAttr(lvlEl, "w:start", String(fmtParams.start)) || changed;
+    }
+  } else if (entry.start != null)
+    changed = setChildAttr(lvlEl, "w:start", String(entry.start)) || changed;
+  if (entry.alignment != null)
+    changed = mutateLevelAlignment(lvlEl, entry.alignment) || changed;
+  if (entry.indents != null)
+    changed = mutateLevelIndents(lvlEl, entry.indents) || changed;
+  if (entry.trailingCharacter != null)
+    changed = mutateLevelTrailingCharacter(lvlEl, entry.trailingCharacter) || changed;
+  if (entry.markerFont != null)
+    changed = mutateLevelMarkerFont(lvlEl, entry.markerFont) || changed;
+  if (entry.pictureBulletId != null)
+    changed = mutateLevelPictureBulletId(lvlEl, entry.pictureBulletId) || changed;
+  if (entry.tabStopAt !== undefined)
+    changed = mutateLevelTabStop(lvlEl, entry.tabStopAt) || changed;
+  return changed;
+}
+function mutateLevelNumberingFormat(lvlEl, { numFmt, lvlText, start: start$1 }) {
+  let changed = false;
+  changed = setChildAttr(lvlEl, "w:numFmt", numFmt) || changed;
+  changed = setChildAttr(lvlEl, "w:lvlText", lvlText) || changed;
+  if (start$1 != null)
+    changed = setChildAttr(lvlEl, "w:start", String(start$1)) || changed;
+  return changed;
+}
+function mutateLevelBulletMarker(lvlEl, markerText) {
+  let changed = false;
+  changed = setChildAttr(lvlEl, "w:numFmt", "bullet") || changed;
+  changed = setChildAttr(lvlEl, "w:lvlText", markerText) || changed;
+  return changed;
+}
+function mutateLevelPictureBulletId(lvlEl, pictureBulletId) {
+  return setChildAttr(lvlEl, "w:lvlPicBulletId", String(pictureBulletId));
+}
+function mutateLevelAlignment(lvlEl, alignment$1) {
+  return setChildAttr(lvlEl, "w:lvlJc", alignment$1);
+}
+function mutateLevelIndents(lvlEl, indents) {
+  const ind = findOrCreateChild(findOrCreateChild(lvlEl, "w:pPr"), "w:ind");
+  if (!ind.attributes)
+    ind.attributes = {};
+  let changed = false;
+  if (indents.left != null) {
+    const newVal = String(indents.left);
+    if (ind.attributes["w:left"] !== newVal) {
+      ind.attributes["w:left"] = newVal;
+      changed = true;
+    }
+  }
+  if (indents.hanging != null) {
+    const newVal = String(indents.hanging);
+    if (ind.attributes["w:hanging"] !== newVal) {
+      ind.attributes["w:hanging"] = newVal;
+      changed = true;
+    }
+    if (ind.attributes["w:firstLine"] != null) {
+      delete ind.attributes["w:firstLine"];
+      changed = true;
+    }
+  }
+  if (indents.firstLine != null) {
+    const newVal = String(indents.firstLine);
+    if (ind.attributes["w:firstLine"] !== newVal) {
+      ind.attributes["w:firstLine"] = newVal;
+      changed = true;
+    }
+    if (ind.attributes["w:hanging"] != null) {
+      delete ind.attributes["w:hanging"];
+      changed = true;
+    }
+  }
+  return changed;
+}
+function mutateLevelTrailingCharacter(lvlEl, trailingCharacter) {
+  return setChildAttr(lvlEl, "w:suff", trailingCharacter);
+}
+function mutateLevelMarkerFont(lvlEl, fontFamily) {
+  const rPr = findOrCreateChild(lvlEl, "w:rPr");
+  const rFonts = rPr.elements.find((el) => el.name === "w:rFonts");
+  if (rFonts) {
+    const attrs = rFonts.attributes || {};
+    if (attrs["w:ascii"] === fontFamily && attrs["w:hAnsi"] === fontFamily && attrs["w:eastAsia"] === fontFamily && attrs["w:cs"] === fontFamily)
+      return false;
+    rFonts.attributes = {
+      ...rFonts.attributes,
+      "w:ascii": fontFamily,
+      "w:hAnsi": fontFamily,
+      "w:eastAsia": fontFamily,
+      "w:cs": fontFamily
+    };
+    return true;
+  }
+  rPr.elements.push({
+    type: "element",
+    name: "w:rFonts",
+    attributes: {
+      "w:ascii": fontFamily,
+      "w:hAnsi": fontFamily,
+      "w:eastAsia": fontFamily,
+      "w:cs": fontFamily
+    }
+  });
+  return true;
+}
+function setLevelNumberingFormat(editor, abstractNumId, ilvl, params$1) {
+  const resolved = resolveAbstractLevel(editor, abstractNumId, ilvl);
+  if (!resolved)
+    return false;
+  return mutateLevelNumberingFormat(resolved.lvlEl, params$1);
+}
+function setLevelBulletMarker(editor, abstractNumId, ilvl, markerText) {
+  const resolved = resolveAbstractLevel(editor, abstractNumId, ilvl);
+  if (!resolved)
+    return false;
+  return mutateLevelBulletMarker(resolved.lvlEl, markerText);
+}
+function setLevelPictureBulletId(editor, abstractNumId, ilvl, pictureBulletId) {
+  const resolved = resolveAbstractLevel(editor, abstractNumId, ilvl);
+  if (!resolved)
+    return false;
+  return mutateLevelPictureBulletId(resolved.lvlEl, pictureBulletId);
+}
+function setLevelAlignment(editor, abstractNumId, ilvl, alignment$1) {
+  const resolved = resolveAbstractLevel(editor, abstractNumId, ilvl);
+  if (!resolved)
+    return false;
+  return mutateLevelAlignment(resolved.lvlEl, alignment$1);
+}
+function setLevelIndents(editor, abstractNumId, ilvl, indents) {
+  const resolved = resolveAbstractLevel(editor, abstractNumId, ilvl);
+  if (!resolved)
+    return false;
+  return mutateLevelIndents(resolved.lvlEl, indents);
+}
+function setLevelTrailingCharacter(editor, abstractNumId, ilvl, trailingCharacter) {
+  const resolved = resolveAbstractLevel(editor, abstractNumId, ilvl);
+  if (!resolved)
+    return false;
+  return mutateLevelTrailingCharacter(resolved.lvlEl, trailingCharacter);
+}
+function setLevelMarkerFont(editor, abstractNumId, ilvl, fontFamily) {
+  const resolved = resolveAbstractLevel(editor, abstractNumId, ilvl);
+  if (!resolved)
+    return false;
+  return mutateLevelMarkerFont(resolved.lvlEl, fontFamily);
+}
+function hasLevelOverride$1(editor, numId, ilvl) {
+  const numDef = editor.converter.numbering?.definitions?.[numId];
+  if (!numDef?.elements)
+    return false;
+  const ilvlStr = String(ilvl);
+  return numDef.elements.some((el) => el.name === "w:lvlOverride" && el.attributes?.["w:ilvl"] === ilvlStr);
+}
+function clearLevelOverride(editor, numId, ilvl) {
+  if (!hasLevelOverride$1(editor, numId, ilvl))
+    return false;
+  removeLvlOverride(editor.converter.numbering, numId, ilvl);
+  return true;
+}
+function materializeLevelFormattingOverride(editor, abstractNumId, numId, ilvl) {
+  const resolved = resolveAbstractLevel(editor, abstractNumId, ilvl);
+  const numDef = editor.converter.numbering?.definitions?.[numId];
+  if (!resolved || !numDef?.elements)
+    return false;
+  const ilvlStr = String(ilvl);
+  const overrideIndex = numDef.elements.findIndex((el) => el.name === "w:lvlOverride" && el.attributes?.["w:ilvl"] === ilvlStr);
+  if (overrideIndex === -1)
+    return false;
+  const overrideEl = numDef.elements[overrideIndex];
+  if (!overrideEl?.elements)
+    return false;
+  const lvlIndex = overrideEl.elements.findIndex((el) => el.name === "w:lvl");
+  if (lvlIndex === -1)
+    return false;
+  const lvlEl = overrideEl.elements[lvlIndex];
+  const props = readLevelProperties(lvlEl, ilvl);
+  const abstractChanged = applyLevelPropertiesToElement(resolved.lvlEl, props);
+  const lvlRestartElements = lvlEl.elements?.filter((el) => el.name === "w:lvlRestart").map((el) => deepCloneElement(el)) ?? [];
+  overrideEl.elements.splice(lvlIndex, 1);
+  if (lvlRestartElements.length > 0)
+    overrideEl.elements.push({
+      type: "element",
+      name: "w:lvl",
+      attributes: { "w:ilvl": ilvlStr },
+      elements: lvlRestartElements
+    });
+  let overrideChanged = true;
+  if (overrideEl.elements.length === 0)
+    numDef.elements.splice(overrideIndex, 1);
+  return abstractChanged || overrideChanged;
+}
+function captureTemplate(editor, abstractNumId, levels) {
+  const abstract = editor.converter.numbering?.abstracts?.[abstractNumId];
+  if (!abstract?.elements)
+    return null;
+  const lvlElements = abstract.elements.filter((el) => el.name === "w:lvl");
+  const captured = [];
+  for (const lvlEl of lvlElements) {
+    const ilvl = Number(lvlEl.attributes?.["w:ilvl"]);
+    if (levels && !levels.includes(ilvl))
+      continue;
+    captured.push(readLevelProperties(lvlEl, ilvl));
+  }
+  captured.sort((a2, b$1) => a2.level - b$1.level);
+  return {
+    version: 1,
+    levels: captured
+  };
+}
+function applyTemplateToAbstract(editor, abstractNumId, template, levels) {
+  const abstract = editor.converter.numbering?.abstracts?.[abstractNumId];
+  if (!abstract?.elements)
+    return {
+      changed: false,
+      error: "ABSTRACT_NOT_FOUND"
+    };
+  const templateByLevel = /* @__PURE__ */ new Map;
+  for (const entry of template.levels)
+    templateByLevel.set(entry.level, entry);
+  const targetLevels = levels ?? template.levels.map((l) => l.level);
+  for (const ilvl of targetLevels)
+    if (!templateByLevel.has(ilvl))
+      return {
+        changed: false,
+        error: "LEVEL_NOT_IN_TEMPLATE"
+      };
+  for (const ilvl of targetLevels)
+    if (!findLevelElement(abstract, ilvl))
+      return {
+        changed: false,
+        error: "LEVEL_NOT_IN_ABSTRACT"
+      };
+  let anyChanged = false;
+  for (const ilvl of targetLevels) {
+    const entry = templateByLevel.get(ilvl);
+    anyChanged = applyLevelPropertiesToElement(findLevelElement(abstract, ilvl), entry) || anyChanged;
+  }
+  return { changed: anyChanged };
+}
+function buildOrderedPresetTemplate(config2) {
+  const levels = [];
+  for (let ilvl = 0;ilvl <= 8; ilvl++)
+    levels.push({
+      level: ilvl,
+      numFmt: config2.numFmt,
+      lvlText: `%${ilvl + 1}${config2.lvlTextSuffix}`,
+      start: 1,
+      alignment: "left",
+      indents: {
+        left: INDENT_PER_LEVEL_TWIPS * (ilvl + 1),
+        hanging: HANGING_INDENT_TWIPS
+      }
+    });
+  return {
+    version: 1,
+    levels
+  };
+}
+function buildBulletPresetTemplate(config2) {
+  const levels = [];
+  for (let ilvl = 0;ilvl <= 8; ilvl++)
+    levels.push({
+      level: ilvl,
+      numFmt: "bullet",
+      lvlText: config2.markerText,
+      start: 1,
+      alignment: "left",
+      markerFont: config2.fontFamily,
+      indents: {
+        left: INDENT_PER_LEVEL_TWIPS * (ilvl + 1),
+        hanging: HANGING_INDENT_TWIPS
+      }
+    });
+  return {
+    version: 1,
+    levels
+  };
+}
+function getPresetTemplate(presetId) {
+  return PRESET_TEMPLATES[presetId];
+}
+function mutateLevelLayout(lvlEl, layout) {
+  let changed = false;
+  if (layout.alignment != null)
+    changed = mutateLevelAlignment(lvlEl, layout.alignment) || changed;
+  if (layout.followCharacter != null)
+    changed = mutateLevelTrailingCharacter(lvlEl, layout.followCharacter) || changed;
+  if (layout.tabStopAt !== undefined)
+    changed = mutateLevelTabStop(lvlEl, layout.tabStopAt) || changed;
+  const hasAlignedAt = layout.alignedAt != null;
+  const hasTextIndentAt = layout.textIndentAt != null;
+  if (hasAlignedAt || hasTextIndentAt) {
+    const ind = lvlEl.elements?.find((el) => el.name === "w:pPr")?.elements?.find((el) => el.name === "w:ind");
+    const existingLeft = ind?.attributes?.["w:left"] != null ? Number(ind.attributes["w:left"]) : undefined;
+    const existingHanging = ind?.attributes?.["w:hanging"] != null ? Number(ind.attributes["w:hanging"]) : undefined;
+    const existingFirstLine = ind?.attributes?.["w:firstLine"] != null ? Number(ind.attributes["w:firstLine"]) : undefined;
+    let existingAlignedAt;
+    if (existingLeft != null)
+      if (existingHanging != null)
+        existingAlignedAt = existingLeft - existingHanging;
+      else if (existingFirstLine != null)
+        existingAlignedAt = existingLeft + existingFirstLine;
+      else
+        existingAlignedAt = existingLeft;
+    let newLeft, newHanging;
+    if (hasAlignedAt && hasTextIndentAt) {
+      newLeft = layout.textIndentAt;
+      newHanging = layout.textIndentAt - layout.alignedAt;
+    } else if (hasTextIndentAt) {
+      newLeft = layout.textIndentAt;
+      newHanging = existingAlignedAt != null ? layout.textIndentAt - existingAlignedAt : 0;
+    } else if (hasAlignedAt) {
+      if (existingLeft == null)
+        return {
+          changed,
+          error: "INVALID_INPUT"
+        };
+      newLeft = existingLeft;
+      newHanging = existingLeft - layout.alignedAt;
+    }
+    if (newLeft != null)
+      changed = mutateLevelIndents(lvlEl, {
+        left: newLeft,
+        hanging: newHanging ?? 0
+      }) || changed;
+  }
+  return { changed };
+}
+function setLevelLayout(editor, abstractNumId, ilvl, layout) {
+  const resolved = resolveAbstractLevel(editor, abstractNumId, ilvl);
+  if (!resolved)
+    return { changed: false };
+  return mutateLevelLayout(resolved.lvlEl, layout);
+}
+function captureEffectiveStyle(editor, abstractNumId, numId, levels) {
+  const abstract = editor.converter.numbering?.abstracts?.[abstractNumId];
+  if (!abstract?.elements)
+    return null;
+  const numDef = editor.converter.numbering?.definitions?.[numId];
+  const overridesByLevel = buildOverrideMap(numDef);
+  const lvlElements = abstract.elements.filter((el) => el.name === "w:lvl");
+  const captured = [];
+  for (const lvlEl of lvlElements) {
+    const ilvl = Number(lvlEl.attributes?.["w:ilvl"]);
+    if (levels && !levels.includes(ilvl))
+      continue;
+    const baseProps = readLevelProperties(lvlEl, ilvl);
+    const overrideLvl = overridesByLevel.get(ilvl);
+    if (overrideLvl)
+      mergeOverrideProps(baseProps, readLevelProperties(overrideLvl, ilvl));
+    captured.push(baseProps);
+  }
+  captured.sort((a2, b$1) => a2.level - b$1.level);
+  return {
+    version: 1,
+    levels: captured
+  };
+}
+function buildOverrideMap(numDef) {
+  const map$12 = /* @__PURE__ */ new Map;
+  if (!numDef?.elements)
+    return map$12;
+  for (const el of numDef.elements) {
+    if (el.name !== "w:lvlOverride")
+      continue;
+    const ilvl = Number(el.attributes?.["w:ilvl"]);
+    const lvlChild = el.elements?.find((c) => c.name === "w:lvl");
+    if (lvlChild)
+      map$12.set(ilvl, lvlChild);
+  }
+  return map$12;
+}
+function mergeOverrideProps(base5, override) {
+  if (override.numFmt != null)
+    base5.numFmt = override.numFmt;
+  if (override.lvlText != null)
+    base5.lvlText = override.lvlText;
+  if (override.start != null)
+    base5.start = override.start;
+  if (override.alignment != null)
+    base5.alignment = override.alignment;
+  if (override.indents != null)
+    base5.indents = {
+      ...base5.indents,
+      ...override.indents
+    };
+  if (override.trailingCharacter != null)
+    base5.trailingCharacter = override.trailingCharacter;
+  if (override.markerFont != null)
+    base5.markerFont = override.markerFont;
+  if (override.pictureBulletId != null)
+    base5.pictureBulletId = override.pictureBulletId;
+  if (override.tabStopAt != null)
+    base5.tabStopAt = override.tabStopAt;
+}
+function isAbstractShared(editor, abstractNumId, numId) {
+  const definitions = editor.converter.numbering?.definitions;
+  if (!definitions)
+    return false;
+  for (const [defNumId, numDef] of Object.entries(definitions)) {
+    if (Number(defNumId) === numId)
+      continue;
+    if (!numDef?.elements)
+      continue;
+    const absEl = numDef.elements.find((el) => el.name === "w:abstractNumId");
+    if (absEl && Number(absEl.attributes?.["w:val"]) === abstractNumId)
+      return true;
+  }
+  return false;
+}
+function deepCloneElement(element3) {
+  const clone = { ...element3 };
+  if (element3.attributes)
+    clone.attributes = { ...element3.attributes };
+  if (element3.elements)
+    clone.elements = element3.elements.map((child) => deepCloneElement(child));
+  return clone;
+}
+function cloneAbstractDefinition(editor, originalAbstractNumId) {
+  const numbering = editor.converter.numbering;
+  const existingAbstractIds = Object.keys(numbering.abstracts).map(Number);
+  const newAbstractNumId = existingAbstractIds.length > 0 ? Math.max(...existingAbstractIds) + 1 : 0;
+  const original = numbering.abstracts[originalAbstractNumId];
+  if (!original)
+    throw new Error(`cloneAbstractDefinition: abstract ${originalAbstractNumId} not found.`);
+  const cloned = deepCloneElement(original);
+  cloned.attributes = {
+    ...cloned.attributes,
+    "w:abstractNumId": String(newAbstractNumId)
+  };
+  numbering.abstracts[newAbstractNumId] = cloned;
+  return { newAbstractNumId };
+}
+function cloneAbstractIntoNum(editor, originalAbstractNumId, numId) {
+  const numbering = editor.converter.numbering;
+  const { newAbstractNumId } = cloneAbstractDefinition(editor, originalAbstractNumId);
+  const numDef = numbering.definitions[numId];
+  if (!numDef)
+    throw new Error(`cloneAbstractIntoNum: num ${numId} not found.`);
+  if (!numDef.elements)
+    numDef.elements = [];
+  const abstractNumIdEl = numDef.elements.find((el) => el.name === "w:abstractNumId");
+  if (abstractNumIdEl)
+    abstractNumIdEl.attributes = {
+      ...abstractNumIdEl.attributes || {},
+      "w:val": String(newAbstractNumId)
+    };
+  else
+    numDef.elements.unshift({
+      type: "element",
+      name: "w:abstractNumId",
+      attributes: { "w:val": String(newAbstractNumId) }
+    });
+  return { newAbstractNumId };
+}
+function copySequenceStateOverrides(editor, fromNumId, toNumId, levels) {
+  if (fromNumId === toNumId)
+    return false;
+  const sourceNumDef = editor.converter.numbering?.definitions?.[fromNumId];
+  const targetNumDef = editor.converter.numbering?.definitions?.[toNumId];
+  if (!sourceNumDef?.elements || !targetNumDef)
+    return false;
+  if (!targetNumDef.elements)
+    targetNumDef.elements = [];
+  const levelSet = levels ? new Set(levels.map((level) => String(level))) : null;
+  let changed = false;
+  for (const sourceEl of sourceNumDef.elements) {
+    if (sourceEl.name !== "w:lvlOverride")
+      continue;
+    const ilvl = sourceEl.attributes?.["w:ilvl"];
+    if (ilvl == null)
+      continue;
+    if (levelSet && !levelSet.has(ilvl))
+      continue;
+    const nextElements = [];
+    for (const child of sourceEl.elements ?? []) {
+      if (child.name === "w:startOverride") {
+        nextElements.push(deepCloneElement(child));
+        continue;
+      }
+      if (child.name === "w:lvl") {
+        const lvlRestartElements = child.elements?.filter((lvlChild) => lvlChild.name === "w:lvlRestart").map((lvlChild) => deepCloneElement(lvlChild)) ?? [];
+        if (lvlRestartElements.length > 0)
+          nextElements.push({
+            type: "element",
+            name: "w:lvl",
+            attributes: {
+              ...child.attributes || {},
+              "w:ilvl": child.attributes?.["w:ilvl"] ?? ilvl
+            },
+            elements: lvlRestartElements
+          });
+      }
+    }
+    if (nextElements.length === 0)
+      continue;
+    const targetIndex = targetNumDef.elements.findIndex((el) => el.name === "w:lvlOverride" && el.attributes?.["w:ilvl"] === ilvl);
+    const nextOverride = {
+      type: "element",
+      name: "w:lvlOverride",
+      attributes: {
+        ...sourceEl.attributes || {},
+        "w:ilvl": ilvl
+      },
+      elements: nextElements
+    };
+    if (targetIndex === -1)
+      targetNumDef.elements.push(nextOverride);
+    else
+      targetNumDef.elements[targetIndex] = nextOverride;
+    changed = true;
+  }
+  return changed;
+}
+function cloneAbstractAndNum(editor, originalAbstractNumId, originalNumId) {
+  const numbering = editor.converter.numbering;
+  const { newAbstractNumId } = cloneAbstractDefinition(editor, originalAbstractNumId);
+  const existingNumIds = Object.keys(numbering.definitions).map(Number);
+  const newNumId = existingNumIds.length > 0 ? Math.max(...existingNumIds) + 1 : 1;
+  const originalNumDef = numbering.definitions[originalNumId];
+  const newElements = [{
+    type: "element",
+    name: "w:abstractNumId",
+    attributes: { "w:val": String(newAbstractNumId) }
+  }];
+  if (originalNumDef?.elements) {
+    for (const el of originalNumDef.elements)
+      if (el.name === "w:lvlOverride")
+        newElements.push(deepCloneElement(el));
+  }
+  numbering.definitions[newNumId] = {
+    type: "element",
+    name: "w:num",
+    attributes: { "w:numId": String(newNumId) },
+    elements: newElements
+  };
+  return {
+    newAbstractNumId,
+    newNumId
+  };
+}
 function toListsFailure$1(code7, message, details) {
   return {
     success: false,
@@ -160381,6 +161954,9 @@ function dispatchEditorTransaction$2(editor, tr) {
   }
   throw new DocumentApiAdapterError("INTERNAL_ERROR", "Cannot apply list mutation because no transaction dispatcher is available.", { reason: "missing_dispatch" });
 }
+function getConverterNumbering$1(editor) {
+  return editor.converter.numbering;
+}
 function executeDomainCommandWithRollback(editor, handler2, options) {
   let receipt2;
   compoundMutation({
@@ -160420,7 +161996,7 @@ function resolveInsertedListItem(editor, sdBlockId) {
 function withListTarget(editor, input2) {
   return resolveListItem(editor, input2.target);
 }
-function hasLevelOverride$1(editor, numId, level) {
+function hasLevelOverride(editor, numId, level) {
   const definition3 = editor.converter?.numbering?.definitions?.[numId];
   const ilvl = String(level);
   return definition3?.elements?.some((element3) => element3.name === "w:lvlOverride" && element3.attributes?.["w:ilvl"] === ilvl) ?? false;
@@ -160570,6 +162146,33 @@ function listsOutdentWrapper(editor, input2, options) {
     return toListsFailure$1("NO_OP", "List item is already at level 0.", { target: input2.target });
   return executeSetLevel(editor, target, currentLevel - 1, options);
 }
+function resolveCreateKind(input2) {
+  const raw = input2;
+  if (raw.style != null && raw.preset != null)
+    return { failure: toListsFailure$1("INVALID_INPUT", "Cannot provide both style and preset.", {}) };
+  if (raw.preset != null) {
+    const presetKind = PRESET_KIND_MAP[raw.preset];
+    if (!presetKind)
+      return { failure: toListsFailure$1("INVALID_INPUT", `Unknown preset: ${raw.preset}.`, { preset: raw.preset }) };
+    if (raw.kind != null && raw.kind !== presetKind)
+      return { failure: toListsFailure$1("INVALID_INPUT", `Preset kind (${presetKind}) conflicts with provided kind (${raw.kind}).`, {
+        preset: raw.preset,
+        kind: raw.kind
+      }) };
+    return { kind: presetKind };
+  }
+  if (raw.style != null) {
+    if (raw.kind == null)
+      return { failure: toListsFailure$1("INVALID_INPUT", "kind is required when style is provided.", {}) };
+    return { kind: raw.kind };
+  }
+  if (raw.kind == null)
+    return { failure: toListsFailure$1("INVALID_INPUT", "kind is required when neither preset nor style is provided.", {}) };
+  return { kind: raw.kind };
+}
+function isListKind(value) {
+  return value === "ordered" || value === "bullet";
+}
 function listsCreateWrapper(editor, input2, options) {
   rejectTrackedMode("lists.create", options);
   const raw = input2;
@@ -160580,53 +162183,24 @@ function listsCreateWrapper(editor, input2, options) {
   const level = input2.level ?? 0;
   if (level < 0 || level > 8)
     return toListsFailure$1("LEVEL_OUT_OF_RANGE", "Level must be between 0 and 8.", { level });
-  const listType = input2.kind === "ordered" ? "orderedList" : "bulletList";
-  if (input2.mode === "empty") {
-    const block = resolveBlock(editor, input2.at.nodeId);
-    if (block.nodeType === "listItem")
-      return toListsFailure$1("INVALID_TARGET", "Target paragraph is already a list item.", { target: input2.at });
-    if (options?.dryRun)
-      return {
-        success: true,
-        listId: "(dry-run)",
-        item: {
-          kind: "block",
-          nodeType: "listItem",
-          nodeId: "(dry-run)"
-        }
-      };
-    let numId$1;
-    if (executeDomainCommandWithRollback(editor, () => {
-      numId$1 = ListHelpers.getNewListId(editor);
-      ListHelpers.generateNewListDefinition({
-        numId: numId$1,
-        listType,
-        editor
-      });
-      const { tr } = editor.state;
-      updateNumberingProperties({
-        numId: numId$1,
-        ilvl: level
-      }, block.node, block.pos, editor, tr);
-      dispatchEditorTransaction$2(editor, tr);
-      clearIndexCache(editor);
-      return true;
-    }, { expectedRevision: options?.expectedRevision }).steps[0]?.effect !== "changed")
-      return toListsFailure$1("INVALID_TARGET", "List creation could not be applied.", { mode: input2.mode });
-    return {
-      success: true,
-      listId: `${numId$1}:${block.nodeId}`,
-      item: {
-        kind: "block",
-        nodeType: "listItem",
-        nodeId: block.nodeId
-      }
-    };
-  }
-  const targets = isBlockRange(input2.target) ? resolveBlocksInRange(editor, input2.target.from.nodeId, input2.target.to.nodeId) : [resolveBlock(editor, input2.target.nodeId)];
-  if (targets.length === 0)
-    return toListsFailure$1("INVALID_TARGET", "No paragraphs found in the specified range.", { target: input2.target });
-  const alreadyListItem = targets.find((t) => t.nodeType === "listItem");
+  let styleTemplate;
+  if (raw.style != null) {
+    styleTemplate = raw.style;
+    if (styleTemplate.version !== 1)
+      return toListsFailure$1("INVALID_INPUT", "Unsupported style version.", { version: styleTemplate.version });
+  } else if (raw.preset != null) {
+    styleTemplate = LevelFormattingHelpers.getPresetTemplate(raw.preset);
+    if (!styleTemplate)
+      return toListsFailure$1("INVALID_INPUT", `Unknown preset: ${raw.preset}.`, { preset: raw.preset });
+  }
+  let blocks2;
+  if (input2.mode === "empty")
+    blocks2 = [resolveBlock(editor, input2.at.nodeId)];
+  else
+    blocks2 = isBlockRange(input2.target) ? resolveBlocksInRange(editor, input2.target.from.nodeId, input2.target.to.nodeId) : [resolveBlock(editor, input2.target.nodeId)];
+  if (blocks2.length === 0)
+    return toListsFailure$1("INVALID_TARGET", "No paragraphs found in the specified range.", {});
+  const alreadyListItem = blocks2.find((t) => t.nodeType === "listItem");
   if (alreadyListItem)
     return toListsFailure$1("INVALID_TARGET", "One or more target paragraphs are already list items.", { nodeId: alreadyListItem.nodeId });
   if (options?.dryRun)
@@ -160636,35 +162210,92 @@ function listsCreateWrapper(editor, input2, options) {
       item: {
         kind: "block",
         nodeType: "listItem",
-        nodeId: targets[0].nodeId
-      }
-    };
+        nodeId: blocks2[0].nodeId
+      }
+    };
+  const sequenceInput = raw.sequence ?? { mode: "new" };
+  const requestedKind = raw.kind;
+  if (requestedKind != null && !isListKind(requestedKind))
+    return toListsFailure$1("INVALID_INPUT", `Unknown list kind: ${String(requestedKind)}.`, { kind: requestedKind });
+  let kind;
+  let listType;
+  if (sequenceInput.mode !== "continuePrevious") {
+    const kindResult = resolveCreateKind(input2);
+    if ("failure" in kindResult)
+      return kindResult.failure;
+    kind = kindResult.kind;
+    listType = kind === "ordered" ? "orderedList" : "bulletList";
+  } else
+    kind = requestedKind;
+  let continuePreviousNumId;
+  if (sequenceInput.mode === "continuePrevious") {
+    if (styleTemplate)
+      return toListsFailure$1("INVALID_INPUT", 'preset/style cannot be combined with sequence.mode "continuePrevious". The new items inherit formatting from the previous sequence.', {});
+    const allItems = getAllListItemProjections(editor);
+    const firstBlockPos = blocks2[0].pos;
+    for (let i4 = allItems.length - 1;i4 >= 0; i4--) {
+      const item = allItems[i4];
+      if (item.candidate.pos >= firstBlockPos)
+        continue;
+      if (item.numId == null)
+        continue;
+      if (kind != null && item.kind !== kind)
+        continue;
+      continuePreviousNumId = item.numId;
+      break;
+    }
+    if (continuePreviousNumId == null)
+      return toListsFailure$1("NO_COMPATIBLE_PREVIOUS", "No compatible previous list sequence found.", {});
+  }
   let numId;
   if (executeDomainCommandWithRollback(editor, () => {
-    numId = ListHelpers.getNewListId(editor);
-    ListHelpers.generateNewListDefinition({
-      numId,
-      listType,
-      editor
-    });
-    const { tr } = editor.state;
-    for (const block of targets)
-      updateNumberingProperties({
+    if (sequenceInput.mode === "continuePrevious") {
+      numId = continuePreviousNumId;
+      const { tr } = editor.state;
+      for (const block of blocks2)
+        updateNumberingProperties({
+          numId,
+          ilvl: level
+        }, block.node, block.pos, editor, tr);
+      dispatchEditorTransaction$2(editor, tr);
+      clearIndexCache(editor);
+    } else {
+      numId = ListHelpers.getNewListId(editor);
+      ListHelpers.generateNewListDefinition({
         numId,
-        ilvl: level
-      }, block.node, block.pos, editor, tr);
-    dispatchEditorTransaction$2(editor, tr);
-    clearIndexCache(editor);
+        listType,
+        editor
+      });
+      if (styleTemplate) {
+        const abstractNumId = getAbstractNumId(editor, numId);
+        if (abstractNumId != null) {
+          LevelFormattingHelpers.applyTemplateToAbstract(editor, abstractNumId, styleTemplate, undefined);
+          const numberingPart = getPart(editor, "word/numbering.xml");
+          if (numberingPart)
+            syncNumberingToXmlTree(numberingPart, getConverterNumbering$1(editor));
+        }
+      }
+      const { tr } = editor.state;
+      for (const block of blocks2)
+        updateNumberingProperties({
+          numId,
+          ilvl: level
+        }, block.node, block.pos, editor, tr);
+      dispatchEditorTransaction$2(editor, tr);
+      clearIndexCache(editor);
+      if (sequenceInput.startAt != null)
+        ListHelpers.setLvlOverride(editor, numId, level, { startOverride: sequenceInput.startAt });
+    }
     return true;
   }, { expectedRevision: options?.expectedRevision }).steps[0]?.effect !== "changed")
     return toListsFailure$1("INVALID_TARGET", "List creation could not be applied.", { mode: input2.mode });
   return {
     success: true,
-    listId: `${numId}:${targets[0].nodeId}`,
+    listId: `${numId}:${blocks2[0].nodeId}`,
     item: {
       kind: "block",
       nodeType: "listItem",
-      nodeId: targets[0].nodeId
+      nodeId: blocks2[0].nodeId
     }
   };
 }
@@ -160848,7 +162479,7 @@ function listsSetValueWrapper(editor, input2, options) {
       item: target.address
     };
   if (input2.value === null) {
-    if (!hasLevelOverride$1(editor, target.numId, level))
+    if (!hasLevelOverride(editor, target.numId, level))
       return toListsFailure$1("NO_OP", "No startOverride to remove.", { target: input2.target });
     if (executeDomainCommandWithRollback(editor, () => {
       ListHelpers.removeLvlOverride(editor, target.numId, level);
@@ -161001,362 +162632,6 @@ function listsConvertToTextWrapper(editor, input2, options) {
     }
   };
 }
-function findLevelElement(abstract, ilvl) {
-  const ilvlStr = String(ilvl);
-  return abstract.elements?.find((el) => el.name === "w:lvl" && el.attributes?.["w:ilvl"] === ilvlStr);
-}
-function readChildAttr(parent, elementName) {
-  return parent.elements?.find((el) => el.name === elementName)?.attributes?.["w:val"];
-}
-function setChildAttr(parent, elementName, value) {
-  if (!parent.elements)
-    parent.elements = [];
-  const existing = parent.elements.find((el) => el.name === elementName);
-  if (existing) {
-    if (existing.attributes?.["w:val"] === value)
-      return false;
-    if (!existing.attributes)
-      existing.attributes = {};
-    existing.attributes["w:val"] = value;
-    return true;
-  }
-  parent.elements.push({
-    type: "element",
-    name: elementName,
-    attributes: { "w:val": value }
-  });
-  return true;
-}
-function findOrCreateChild(parent, elementName) {
-  if (!parent.elements)
-    parent.elements = [];
-  let child = parent.elements.find((el) => el.name === elementName);
-  if (!child) {
-    child = {
-      type: "element",
-      name: elementName,
-      elements: []
-    };
-    parent.elements.push(child);
-  }
-  if (!child.elements)
-    child.elements = [];
-  return child;
-}
-function resolveAbstractLevel(editor, abstractNumId, ilvl) {
-  const abstract = editor.converter.numbering?.abstracts?.[abstractNumId];
-  if (!abstract)
-    return null;
-  const lvlEl = findLevelElement(abstract, ilvl);
-  if (!lvlEl)
-    return null;
-  return {
-    abstract,
-    lvlEl
-  };
-}
-function hasLevel(editor, abstractNumId, ilvl) {
-  return resolveAbstractLevel(editor, abstractNumId, ilvl) != null;
-}
-function readLevelProperties(lvlEl, ilvl) {
-  const props = { level: ilvl };
-  const numFmt = readChildAttr(lvlEl, "w:numFmt");
-  if (numFmt != null)
-    props.numFmt = numFmt;
-  const lvlText = readChildAttr(lvlEl, "w:lvlText");
-  if (lvlText != null)
-    props.lvlText = lvlText;
-  const startVal = readChildAttr(lvlEl, "w:start");
-  if (startVal != null)
-    props.start = Number(startVal);
-  const alignment$1 = readChildAttr(lvlEl, "w:lvlJc");
-  if (alignment$1 != null)
-    props.alignment = alignment$1;
-  const suff = readChildAttr(lvlEl, "w:suff");
-  if (suff != null)
-    props.trailingCharacter = suff;
-  const picBulletId = readChildAttr(lvlEl, "w:lvlPicBulletId");
-  if (picBulletId != null)
-    props.pictureBulletId = Number(picBulletId);
-  const ind = lvlEl.elements?.find((el) => el.name === "w:pPr")?.elements?.find((el) => el.name === "w:ind");
-  if (ind?.attributes) {
-    const indents = {};
-    if (ind.attributes["w:left"] != null)
-      indents.left = Number(ind.attributes["w:left"]);
-    if (ind.attributes["w:hanging"] != null)
-      indents.hanging = Number(ind.attributes["w:hanging"]);
-    if (ind.attributes["w:firstLine"] != null)
-      indents.firstLine = Number(ind.attributes["w:firstLine"]);
-    if (Object.keys(indents).length > 0)
-      props.indents = indents;
-  }
-  const rFonts = lvlEl.elements?.find((el) => el.name === "w:rPr")?.elements?.find((el) => el.name === "w:rFonts");
-  if (rFonts?.attributes?.["w:ascii"])
-    props.markerFont = rFonts.attributes["w:ascii"];
-  return props;
-}
-function mutateLevelNumberingFormat(lvlEl, { numFmt, lvlText, start: start$1 }) {
-  let changed = false;
-  changed = setChildAttr(lvlEl, "w:numFmt", numFmt) || changed;
-  changed = setChildAttr(lvlEl, "w:lvlText", lvlText) || changed;
-  if (start$1 != null)
-    changed = setChildAttr(lvlEl, "w:start", String(start$1)) || changed;
-  return changed;
-}
-function mutateLevelBulletMarker(lvlEl, markerText) {
-  let changed = false;
-  changed = setChildAttr(lvlEl, "w:numFmt", "bullet") || changed;
-  changed = setChildAttr(lvlEl, "w:lvlText", markerText) || changed;
-  return changed;
-}
-function mutateLevelPictureBulletId(lvlEl, pictureBulletId) {
-  return setChildAttr(lvlEl, "w:lvlPicBulletId", String(pictureBulletId));
-}
-function mutateLevelAlignment(lvlEl, alignment$1) {
-  return setChildAttr(lvlEl, "w:lvlJc", alignment$1);
-}
-function mutateLevelIndents(lvlEl, indents) {
-  const ind = findOrCreateChild(findOrCreateChild(lvlEl, "w:pPr"), "w:ind");
-  if (!ind.attributes)
-    ind.attributes = {};
-  let changed = false;
-  if (indents.left != null) {
-    const newVal = String(indents.left);
-    if (ind.attributes["w:left"] !== newVal) {
-      ind.attributes["w:left"] = newVal;
-      changed = true;
-    }
-  }
-  if (indents.hanging != null) {
-    const newVal = String(indents.hanging);
-    if (ind.attributes["w:hanging"] !== newVal) {
-      ind.attributes["w:hanging"] = newVal;
-      changed = true;
-    }
-    if (ind.attributes["w:firstLine"] != null) {
-      delete ind.attributes["w:firstLine"];
-      changed = true;
-    }
-  }
-  if (indents.firstLine != null) {
-    const newVal = String(indents.firstLine);
-    if (ind.attributes["w:firstLine"] !== newVal) {
-      ind.attributes["w:firstLine"] = newVal;
-      changed = true;
-    }
-    if (ind.attributes["w:hanging"] != null) {
-      delete ind.attributes["w:hanging"];
-      changed = true;
-    }
-  }
-  return changed;
-}
-function mutateLevelTrailingCharacter(lvlEl, trailingCharacter) {
-  return setChildAttr(lvlEl, "w:suff", trailingCharacter);
-}
-function mutateLevelMarkerFont(lvlEl, fontFamily) {
-  const rPr = findOrCreateChild(lvlEl, "w:rPr");
-  const rFonts = rPr.elements.find((el) => el.name === "w:rFonts");
-  if (rFonts) {
-    const attrs = rFonts.attributes || {};
-    if (attrs["w:ascii"] === fontFamily && attrs["w:hAnsi"] === fontFamily && attrs["w:eastAsia"] === fontFamily && attrs["w:cs"] === fontFamily)
-      return false;
-    rFonts.attributes = {
-      ...rFonts.attributes,
-      "w:ascii": fontFamily,
-      "w:hAnsi": fontFamily,
-      "w:eastAsia": fontFamily,
-      "w:cs": fontFamily
-    };
-    return true;
-  }
-  rPr.elements.push({
-    type: "element",
-    name: "w:rFonts",
-    attributes: {
-      "w:ascii": fontFamily,
-      "w:hAnsi": fontFamily,
-      "w:eastAsia": fontFamily,
-      "w:cs": fontFamily
-    }
-  });
-  return true;
-}
-function setLevelNumberingFormat(editor, abstractNumId, ilvl, params$1) {
-  const resolved = resolveAbstractLevel(editor, abstractNumId, ilvl);
-  if (!resolved)
-    return false;
-  return mutateLevelNumberingFormat(resolved.lvlEl, params$1);
-}
-function setLevelBulletMarker(editor, abstractNumId, ilvl, markerText) {
-  const resolved = resolveAbstractLevel(editor, abstractNumId, ilvl);
-  if (!resolved)
-    return false;
-  return mutateLevelBulletMarker(resolved.lvlEl, markerText);
-}
-function setLevelPictureBulletId(editor, abstractNumId, ilvl, pictureBulletId) {
-  const resolved = resolveAbstractLevel(editor, abstractNumId, ilvl);
-  if (!resolved)
-    return false;
-  return mutateLevelPictureBulletId(resolved.lvlEl, pictureBulletId);
-}
-function setLevelAlignment(editor, abstractNumId, ilvl, alignment$1) {
-  const resolved = resolveAbstractLevel(editor, abstractNumId, ilvl);
-  if (!resolved)
-    return false;
-  return mutateLevelAlignment(resolved.lvlEl, alignment$1);
-}
-function setLevelIndents(editor, abstractNumId, ilvl, indents) {
-  const resolved = resolveAbstractLevel(editor, abstractNumId, ilvl);
-  if (!resolved)
-    return false;
-  return mutateLevelIndents(resolved.lvlEl, indents);
-}
-function setLevelTrailingCharacter(editor, abstractNumId, ilvl, trailingCharacter) {
-  const resolved = resolveAbstractLevel(editor, abstractNumId, ilvl);
-  if (!resolved)
-    return false;
-  return mutateLevelTrailingCharacter(resolved.lvlEl, trailingCharacter);
-}
-function setLevelMarkerFont(editor, abstractNumId, ilvl, fontFamily) {
-  const resolved = resolveAbstractLevel(editor, abstractNumId, ilvl);
-  if (!resolved)
-    return false;
-  return mutateLevelMarkerFont(resolved.lvlEl, fontFamily);
-}
-function hasLevelOverride(editor, numId, ilvl) {
-  const numDef = editor.converter.numbering?.definitions?.[numId];
-  if (!numDef?.elements)
-    return false;
-  const ilvlStr = String(ilvl);
-  return numDef.elements.some((el) => el.name === "w:lvlOverride" && el.attributes?.["w:ilvl"] === ilvlStr);
-}
-function clearLevelOverride(editor, numId, ilvl) {
-  if (!hasLevelOverride(editor, numId, ilvl))
-    return false;
-  removeLvlOverride(editor.converter.numbering, numId, ilvl);
-  return true;
-}
-function captureTemplate(editor, abstractNumId, levels) {
-  const abstract = editor.converter.numbering?.abstracts?.[abstractNumId];
-  if (!abstract?.elements)
-    return null;
-  const lvlElements = abstract.elements.filter((el) => el.name === "w:lvl");
-  const captured = [];
-  for (const lvlEl of lvlElements) {
-    const ilvl = Number(lvlEl.attributes?.["w:ilvl"]);
-    if (levels && !levels.includes(ilvl))
-      continue;
-    captured.push(readLevelProperties(lvlEl, ilvl));
-  }
-  captured.sort((a2, b$1) => a2.level - b$1.level);
-  return {
-    version: 1,
-    levels: captured
-  };
-}
-function applyTemplateToAbstract(editor, abstractNumId, template, levels) {
-  const abstract = editor.converter.numbering?.abstracts?.[abstractNumId];
-  if (!abstract?.elements)
-    return {
-      changed: false,
-      error: "ABSTRACT_NOT_FOUND"
-    };
-  const templateByLevel = /* @__PURE__ */ new Map;
-  for (const entry of template.levels)
-    templateByLevel.set(entry.level, entry);
-  const targetLevels = levels ?? template.levels.map((l) => l.level);
-  for (const ilvl of targetLevels)
-    if (!templateByLevel.has(ilvl))
-      return {
-        changed: false,
-        error: "LEVEL_NOT_IN_TEMPLATE"
-      };
-  for (const ilvl of targetLevels)
-    if (!findLevelElement(abstract, ilvl))
-      return {
-        changed: false,
-        error: "LEVEL_NOT_IN_ABSTRACT"
-      };
-  let anyChanged = false;
-  for (const ilvl of targetLevels) {
-    const entry = templateByLevel.get(ilvl);
-    const lvlEl = findLevelElement(abstract, ilvl);
-    if (entry.numFmt != null || entry.lvlText != null) {
-      const fmtParams = {};
-      if (entry.numFmt != null)
-        fmtParams.numFmt = entry.numFmt;
-      if (entry.lvlText != null)
-        fmtParams.lvlText = entry.lvlText;
-      if (entry.start != null)
-        fmtParams.start = entry.start;
-      if (fmtParams.numFmt != null && fmtParams.lvlText != null)
-        anyChanged = mutateLevelNumberingFormat(lvlEl, fmtParams) || anyChanged;
-      else {
-        if (fmtParams.numFmt != null)
-          anyChanged = setChildAttr(lvlEl, "w:numFmt", fmtParams.numFmt) || anyChanged;
-        if (fmtParams.lvlText != null)
-          anyChanged = setChildAttr(lvlEl, "w:lvlText", fmtParams.lvlText) || anyChanged;
-        if (fmtParams.start != null)
-          anyChanged = setChildAttr(lvlEl, "w:start", String(fmtParams.start)) || anyChanged;
-      }
-    } else if (entry.start != null)
-      anyChanged = setChildAttr(lvlEl, "w:start", String(entry.start)) || anyChanged;
-    if (entry.alignment != null)
-      anyChanged = mutateLevelAlignment(lvlEl, entry.alignment) || anyChanged;
-    if (entry.indents != null)
-      anyChanged = mutateLevelIndents(lvlEl, entry.indents) || anyChanged;
-    if (entry.trailingCharacter != null)
-      anyChanged = mutateLevelTrailingCharacter(lvlEl, entry.trailingCharacter) || anyChanged;
-    if (entry.markerFont != null)
-      anyChanged = mutateLevelMarkerFont(lvlEl, entry.markerFont) || anyChanged;
-    if (entry.pictureBulletId != null)
-      anyChanged = mutateLevelPictureBulletId(lvlEl, entry.pictureBulletId) || anyChanged;
-  }
-  return { changed: anyChanged };
-}
-function buildOrderedPresetTemplate(config2) {
-  const levels = [];
-  for (let ilvl = 0;ilvl <= 8; ilvl++)
-    levels.push({
-      level: ilvl,
-      numFmt: config2.numFmt,
-      lvlText: `%${ilvl + 1}${config2.lvlTextSuffix}`,
-      start: 1,
-      alignment: "left",
-      indents: {
-        left: INDENT_PER_LEVEL_TWIPS * (ilvl + 1),
-        hanging: HANGING_INDENT_TWIPS
-      }
-    });
-  return {
-    version: 1,
-    levels
-  };
-}
-function buildBulletPresetTemplate(config2) {
-  const levels = [];
-  for (let ilvl = 0;ilvl <= 8; ilvl++)
-    levels.push({
-      level: ilvl,
-      numFmt: "bullet",
-      lvlText: config2.markerText,
-      start: 1,
-      alignment: "left",
-      markerFont: config2.fontFamily,
-      indents: {
-        left: INDENT_PER_LEVEL_TWIPS * (ilvl + 1),
-        hanging: HANGING_INDENT_TWIPS
-      }
-    });
-  return {
-    version: 1,
-    levels
-  };
-}
-function getPresetTemplate(presetId) {
-  return PRESET_TEMPLATES[presetId];
-}
 function toListsFailure(code7, message, details) {
   return {
     success: false,
@@ -161386,13 +162661,13 @@ function validateLevelsArray(levels) {
   for (const lvl of levels)
     if (lvl < 0 || lvl > 8)
       return toListsFailure("LEVEL_OUT_OF_RANGE", "Each level must be between 0 and 8.", { level: lvl });
-  if (new Set(levels).size !== levels.length)
-    return toListsFailure("INVALID_INPUT", "levels must contain unique values.", { levels });
-  for (let i4 = 1;i4 < levels.length; i4++)
-    if (levels[i4] <= levels[i4 - 1])
-      return toListsFailure("INVALID_INPUT", "levels must be sorted in ascending order.", { levels });
   return null;
 }
+function normalizeLevels(levels) {
+  if (!levels)
+    return;
+  return [...new Set(levels)].sort((a2, b$1) => a2 - b$1);
+}
 function preflightTemplateLevels(template, levels, target) {
   const templateLevelSet = new Set(template.levels.map((l) => l.level));
   const targetLevels = levels ?? template.levels.map((l) => l.level);
@@ -161751,6 +163026,303 @@ function listsSetLevelTrailingCharacterWrapper(editor, input2, options) {
 function listsSetLevelMarkerFontWrapper(editor, input2, options) {
   return executeSingleLevelMutation(editor, "lists.setLevelMarkerFont", input2.target, input2.level, options, (abstractNumId, ilvl) => LevelFormattingHelpers.setLevelMarkerFont(editor, abstractNumId, ilvl, input2.fontFamily));
 }
+function ensureSequenceLocalAbstract(editor, target, targetAbstractNumId, targetNumId) {
+  if (!LevelFormattingHelpers.isAbstractShared(editor, targetAbstractNumId, targetNumId))
+    return {
+      abstractNumId: targetAbstractNumId,
+      numId: targetNumId,
+      sourceNumId: targetNumId,
+      pendingRebind: null
+    };
+  const sequence = getContiguousSequence(editor, target);
+  const sequenceNodeIds = new Set(sequence.map((item) => item.address.nodeId));
+  const allItemsWithNumId = getAllListItemProjections(editor).filter((item) => item.numId === targetNumId);
+  if (allItemsWithNumId.length === sequence.length && allItemsWithNumId.every((item) => sequenceNodeIds.has(item.address.nodeId))) {
+    const { newAbstractNumId: newAbstractNumId$1 } = LevelFormattingHelpers.cloneAbstractIntoNum(editor, targetAbstractNumId, targetNumId);
+    return {
+      abstractNumId: newAbstractNumId$1,
+      numId: targetNumId,
+      sourceNumId: targetNumId,
+      pendingRebind: null
+    };
+  }
+  const { newAbstractNumId, newNumId } = LevelFormattingHelpers.cloneAbstractAndNum(editor, targetAbstractNumId, targetNumId);
+  return {
+    abstractNumId: newAbstractNumId,
+    numId: newNumId,
+    sourceNumId: targetNumId,
+    pendingRebind: sequence
+  };
+}
+function applyPendingRebind(editor, tr, local) {
+  if (!local.pendingRebind)
+    return;
+  for (const item of local.pendingRebind)
+    updateNumberingProperties({
+      numId: local.numId,
+      ilvl: item.level ?? 0
+    }, item.candidate.node, item.candidate.pos, editor, tr);
+}
+function executeSequenceLocalLevelMutation(editor, operationId, target, level, options, mutate) {
+  rejectTrackedMode(operationId, options);
+  const levelError = validateLevel(level);
+  if (levelError)
+    return levelError;
+  const targetResult = resolveTargetAbstract(editor, target);
+  if (!targetResult.ok)
+    return targetResult.failure;
+  if (!LevelFormattingHelpers.hasLevel(editor, targetResult.abstractNumId, level))
+    return toListsFailure("LEVEL_NOT_FOUND", `Level ${level} does not exist in the abstract definition.`, {
+      target,
+      level
+    });
+  if (options?.dryRun)
+    return {
+      success: true,
+      item: targetResult.resolved.address
+    };
+  let noOp = false;
+  const compound = compoundMutation({
+    editor,
+    source: operationId,
+    affectedParts: [NUMBERING_PART],
+    execute() {
+      const local = ensureSequenceLocalAbstract(editor, resolveListItem(editor, target), targetResult.abstractNumId, targetResult.numId);
+      if (!mutatePart({
+        editor,
+        partId: NUMBERING_PART,
+        operation: "mutate",
+        source: operationId,
+        expectedRevision: options?.expectedRevision,
+        mutate({ part }) {
+          LevelFormattingHelpers.materializeLevelFormattingOverride(editor, local.abstractNumId, local.numId, level);
+          if (!mutate(local.abstractNumId, level))
+            return false;
+          LevelFormattingHelpers.copySequenceStateOverrides(editor, local.sourceNumId, local.numId, [level]);
+          syncNumberingToXmlTree(part, getConverterNumbering(editor));
+          return true;
+        }
+      }).changed) {
+        noOp = true;
+        return false;
+      }
+      const { tr } = editor.state;
+      applyPendingRebind(editor, tr, local);
+      dispatchEditorTransaction$1(editor, tr);
+      if (local.pendingRebind)
+        clearIndexCache(editor);
+      return true;
+    }
+  });
+  if (noOp)
+    return toListsFailure("NO_OP", `${operationId}: values already match.`, { target });
+  if (!compound.success)
+    return toListsFailure("NO_OP", `${operationId}: mutation failed.`, { target });
+  return {
+    success: true,
+    item: targetResult.resolved.address
+  };
+}
+function listsGetStyleWrapper(editor, input2) {
+  const levelsError = validateLevelsArray(input2.levels);
+  if (levelsError)
+    return levelsError;
+  const normalized = normalizeLevels(input2.levels);
+  const targetResult = resolveTargetAbstract(editor, input2.target);
+  if (!targetResult.ok)
+    return targetResult.failure;
+  const style2 = LevelFormattingHelpers.captureEffectiveStyle(editor, targetResult.abstractNumId, targetResult.numId, normalized);
+  if (!style2)
+    return toListsFailure("INVALID_TARGET", "Could not capture style from target.", { target: input2.target });
+  return {
+    success: true,
+    style: style2
+  };
+}
+function listsApplyStyleWrapper(editor, input2, options) {
+  rejectTrackedMode("lists.applyStyle", options);
+  if (input2.style.version !== 1)
+    return toListsFailure("INVALID_INPUT", "Unsupported style version.", { version: input2.style.version });
+  const levelsError = validateLevelsArray(input2.levels);
+  if (levelsError)
+    return levelsError;
+  const normalized = normalizeLevels(input2.levels);
+  const targetResult = resolveTargetAbstract(editor, input2.target);
+  if (!targetResult.ok)
+    return targetResult.failure;
+  const preflightError = preflightTemplateLevels(input2.style, normalized, input2.target);
+  if (preflightError)
+    return preflightError;
+  if (options?.dryRun)
+    return {
+      success: true,
+      item: targetResult.resolved.address
+    };
+  let applyError;
+  let noOp = false;
+  const compound = compoundMutation({
+    editor,
+    source: "lists.applyStyle",
+    affectedParts: [NUMBERING_PART],
+    execute() {
+      const local = ensureSequenceLocalAbstract(editor, resolveListItem(editor, input2.target), targetResult.abstractNumId, targetResult.numId);
+      const result = mutatePart({
+        editor,
+        partId: NUMBERING_PART,
+        operation: "mutate",
+        source: "lists.applyStyle",
+        expectedRevision: options?.expectedRevision,
+        mutate({ part }) {
+          const affectedLevels = normalized ?? input2.style.levels.map((l) => l.level);
+          for (const ilvl of affectedLevels)
+            LevelFormattingHelpers.materializeLevelFormattingOverride(editor, local.abstractNumId, local.numId, ilvl);
+          const applyResult = LevelFormattingHelpers.applyTemplateToAbstract(editor, local.abstractNumId, input2.style, normalized);
+          if (applyResult.error) {
+            applyError = applyResult.error;
+            return false;
+          }
+          if (!applyResult.changed)
+            return false;
+          LevelFormattingHelpers.copySequenceStateOverrides(editor, local.sourceNumId, local.numId, affectedLevels);
+          syncNumberingToXmlTree(part, getConverterNumbering(editor));
+          return true;
+        }
+      });
+      if (applyError || !result.changed) {
+        noOp = !applyError;
+        return false;
+      }
+      const { tr } = editor.state;
+      applyPendingRebind(editor, tr, local);
+      dispatchEditorTransaction$1(editor, tr);
+      if (local.pendingRebind)
+        clearIndexCache(editor);
+      return true;
+    }
+  });
+  if (applyError)
+    return toApplyTemplateError(applyError, input2.target);
+  if (noOp)
+    return toListsFailure("NO_OP", "All style levels already match.", { target: input2.target });
+  if (!compound.success)
+    return toListsFailure("NO_OP", "Style application failed.", { target: input2.target });
+  return {
+    success: true,
+    item: targetResult.resolved.address
+  };
+}
+function registerSetValueDelegate(fn) {
+  _setValueDelegate = fn;
+}
+function listsRestartAtWrapper(editor, input2, options) {
+  rejectTrackedMode("lists.restartAt", options);
+  if (input2.startAt < 1 || !Number.isInteger(input2.startAt))
+    return toListsFailure("INVALID_INPUT", "startAt must be a positive integer (>= 1).", { startAt: input2.startAt });
+  const resolved = resolveListItem(editor, input2.target);
+  if (resolved.numId == null)
+    return toListsFailure("INVALID_TARGET", "Target must have numbering metadata.", { target: input2.target });
+  if (resolved.kind === "bullet")
+    return toListsFailure("INVALID_INPUT", "Cannot restart numbering on a bullet list.", { target: input2.target });
+  if (!_setValueDelegate)
+    return toListsFailure("INVALID_INPUT", "restartAt: internal delegate not registered.", { target: input2.target });
+  return _setValueDelegate(editor, {
+    target: input2.target,
+    value: input2.startAt
+  }, options);
+}
+function listsSetLevelNumberStyleWrapper(editor, input2, options) {
+  if (input2.numberStyle === "bullet")
+    return toListsFailure("INVALID_INPUT", "Use setLevelBullet or setLevelPictureBullet to set bullet format.", { numberStyle: input2.numberStyle });
+  return executeSequenceLocalLevelMutation(editor, "lists.setLevelNumberStyle", input2.target, input2.level, options, (abstractNumId, ilvl) => LevelFormattingHelpers.setLevelNumberStyle(editor, abstractNumId, ilvl, input2.numberStyle));
+}
+function listsSetLevelTextWrapper(editor, input2, options) {
+  return executeSequenceLocalLevelMutation(editor, "lists.setLevelText", input2.target, input2.level, options, (abstractNumId, ilvl) => LevelFormattingHelpers.setLevelText(editor, abstractNumId, ilvl, input2.text));
+}
+function listsSetLevelStartWrapper(editor, input2, options) {
+  if (input2.startAt < 1 || !Number.isInteger(input2.startAt))
+    return toListsFailure("INVALID_INPUT", "startAt must be a positive integer (>= 1).", { startAt: input2.startAt });
+  if (!validateLevel(input2.level)) {
+    const targetResult = resolveTargetAbstract(editor, input2.target);
+    if (targetResult.ok && LevelFormattingHelpers.hasLevel(editor, targetResult.abstractNumId, input2.level)) {
+      const abstracts = getConverterNumbering(editor).abstracts;
+      const lvlEl = LevelFormattingHelpers.findLevelElement(abstracts[targetResult.abstractNumId], input2.level);
+      if (LevelFormattingHelpers.readLevelProperties(lvlEl, input2.level).numFmt === "bullet")
+        return toListsFailure("INVALID_INPUT", "Cannot set start value on a bullet level.", {
+          target: input2.target,
+          level: input2.level
+        });
+    }
+  }
+  return executeSequenceLocalLevelMutation(editor, "lists.setLevelStart", input2.target, input2.level, options, (abstractNumId, ilvl) => LevelFormattingHelpers.setLevelStart(editor, abstractNumId, ilvl, input2.startAt));
+}
+function listsSetLevelLayoutWrapper(editor, input2, options) {
+  rejectTrackedMode("lists.setLevelLayout", options);
+  const levelError = validateLevel(input2.level);
+  if (levelError)
+    return levelError;
+  const targetResult = resolveTargetAbstract(editor, input2.target);
+  if (!targetResult.ok)
+    return targetResult.failure;
+  if (!LevelFormattingHelpers.hasLevel(editor, targetResult.abstractNumId, input2.level))
+    return toListsFailure("LEVEL_NOT_FOUND", `Level ${input2.level} does not exist in the abstract definition.`, {
+      target: input2.target,
+      level: input2.level
+    });
+  if (options?.dryRun)
+    return {
+      success: true,
+      item: targetResult.resolved.address
+    };
+  let noOp = false;
+  let layoutError;
+  const compound = compoundMutation({
+    editor,
+    source: "lists.setLevelLayout",
+    affectedParts: [NUMBERING_PART],
+    execute() {
+      const local = ensureSequenceLocalAbstract(editor, resolveListItem(editor, input2.target), targetResult.abstractNumId, targetResult.numId);
+      const result = mutatePart({
+        editor,
+        partId: NUMBERING_PART,
+        operation: "mutate",
+        source: "lists.setLevelLayout",
+        expectedRevision: options?.expectedRevision,
+        mutate({ part }) {
+          LevelFormattingHelpers.materializeLevelFormattingOverride(editor, local.abstractNumId, local.numId, input2.level);
+          const layoutResult = LevelFormattingHelpers.setLevelLayout(editor, local.abstractNumId, input2.level, input2.layout);
+          if (layoutResult.error) {
+            layoutError = layoutResult.error;
+            return false;
+          }
+          if (!layoutResult.changed)
+            return false;
+          syncNumberingToXmlTree(part, getConverterNumbering(editor));
+          return true;
+        }
+      });
+      if (layoutError || !result.changed) {
+        noOp = !layoutError;
+        return false;
+      }
+      const { tr } = editor.state;
+      applyPendingRebind(editor, tr, local);
+      dispatchEditorTransaction$1(editor, tr);
+      if (local.pendingRebind)
+        clearIndexCache(editor);
+      return true;
+    }
+  });
+  if (layoutError)
+    return toListsFailure("INVALID_INPUT", `Layout mutation failed: ${layoutError}.`, { target: input2.target });
+  if (noOp)
+    return toListsFailure("NO_OP", "lists.setLevelLayout: values already match.", { target: input2.target });
+  if (!compound.success)
+    return toListsFailure("NO_OP", "lists.setLevelLayout: mutation failed.", { target: input2.target });
+  return {
+    success: true,
+    item: targetResult.resolved.address
+  };
+}
 function listsClearLevelOverridesWrapper(editor, input2, options) {
   rejectTrackedMode("lists.clearLevelOverrides", options);
   const levelError = validateLevel(input2.level);
@@ -161926,7 +163498,7 @@ function resolveAnchor(editor, anchor, revision, index2) {
   }
 }
 function isEdgeNodeType(nodeType) {
-  return EDGE_NODE_TYPES.has(nodeType);
+  return EDGE_NODE_TYPES$1.has(nodeType);
 }
 function computeTextOffset(editor, blockContentStart, absPos) {
   if (absPos <= blockContentStart)
@@ -162102,15 +163674,13 @@ function rangeContainsOnlyTextBlocks(index2, absFrom, absTo) {
   }
   return true;
 }
-function resolveRange(editor, input2) {
+function resolveAbsoluteRange(editor, input2) {
   const revision = getRevision(editor);
   if (input2.expectedRevision !== undefined)
     checkRevision(editor, input2.expectedRevision);
   const index2 = getBlockIndex(editor);
-  const rawFrom = resolveAnchor(editor, input2.start, revision, index2);
-  const rawTo = resolveAnchor(editor, input2.end, revision, index2);
-  const absFrom = Math.min(rawFrom, rawTo);
-  const absTo = Math.max(rawFrom, rawTo);
+  const absFrom = Math.min(input2.absFrom, input2.absTo);
+  const absTo = Math.max(input2.absFrom, input2.absTo);
   const target = buildSelectionTarget(editor, index2, absFrom, absTo);
   const coversFullTarget = target.start.kind === "text" && target.end.kind === "text" && rangeContainsOnlyTextBlocks(index2, absFrom, absTo);
   return {
@@ -162124,6 +163694,16 @@ function resolveRange(editor, input2) {
     preview: buildPreview(editor, index2, absFrom, absTo)
   };
 }
+function resolveRange(editor, input2) {
+  const revision = getRevision(editor);
+  if (input2.expectedRevision !== undefined)
+    checkRevision(editor, input2.expectedRevision);
+  const index2 = getBlockIndex(editor);
+  return resolveAbsoluteRange(editor, {
+    absFrom: resolveAnchor(editor, input2.start, revision, index2),
+    absTo: resolveAnchor(editor, input2.end, revision, index2)
+  });
+}
 function resolveTableLocator(editor, locator, operationName) {
   const hasTarget = locator.target != null;
   const hasNodeId = locator.nodeId != null;
@@ -176574,6 +178154,7 @@ function assembleDocumentApiAdapters(editor) {
   registerPartDescriptor(relsPartDescriptor);
   registerPartDescriptor(numberingPartDescriptor);
   const ccAdapter = createContentControlsAdapter(editor);
+  registerSetValueDelegate((ed, input2, options) => listsSetValueWrapper(ed, input2, options));
   return {
     get: { get: (input2) => getAdapter(editor, input2) },
     find: { find: (input2) => sdFindAdapter(editor, input2) },
@@ -176668,7 +178249,14 @@ function assembleDocumentApiAdapters(editor) {
       setLevelTrailingCharacter: (input2, options) => listsSetLevelTrailingCharacterWrapper(editor, input2, options),
       setLevelMarkerFont: (input2, options) => listsSetLevelMarkerFontWrapper(editor, input2, options),
       clearLevelOverrides: (input2, options) => listsClearLevelOverridesWrapper(editor, input2, options),
-      setType: (input2, options) => listsSetTypeWrapper(editor, input2, options)
+      setType: (input2, options) => listsSetTypeWrapper(editor, input2, options),
+      getStyle: (input2) => listsGetStyleWrapper(editor, input2),
+      applyStyle: (input2, options) => listsApplyStyleWrapper(editor, input2, options),
+      restartAt: (input2, options) => listsRestartAtWrapper(editor, input2, options),
+      setLevelNumberStyle: (input2, options) => listsSetLevelNumberStyleWrapper(editor, input2, options),
+      setLevelText: (input2, options) => listsSetLevelTextWrapper(editor, input2, options),
+      setLevelStart: (input2, options) => listsSetLevelStartWrapper(editor, input2, options),
+      setLevelLayout: (input2, options) => listsSetLevelLayoutWrapper(editor, input2, options)
     },
     sections: {
       list: (query2) => sectionsListAdapter(editor, query2),
@@ -176901,6 +178489,59 @@ function assembleDocumentApiAdapters(editor) {
 function getDocumentApiAdapters(editor) {
   return assembleDocumentApiAdapters(editor);
 }
+function selectCurrentPmSelection(editor) {
+  return editor.state.selection;
+}
+function selectEffectivePmSelection(editor) {
+  const liveSelection = editor.state.selection;
+  if (!liveSelection.empty)
+    return liveSelection;
+  const preserved = getPreservedSelection(editor.state);
+  if (preserved && !preserved.empty)
+    return preserved;
+  return liveSelection;
+}
+function classifyNodeSelection(editor, selection) {
+  const node3 = selection.node;
+  const mappedType = mapBlockNodeType(node3);
+  if (mappedType && EDGE_NODE_TYPES.has(mappedType))
+    return "block-edge";
+  if (node3.isLeaf && node3.isInline) {
+    if (editor.state.doc.resolve(selection.from).parent.inlineContent)
+      return "inline-leaf";
+  }
+  return "reject";
+}
+function extractAbsoluteRange(editor, selection) {
+  if ("$anchorCell" in selection)
+    throw new DocumentApiAdapterError("INVALID_CONTEXT", "CellSelection cannot be converted to SelectionTarget. Use table-specific APIs for rectangular table selections.", { selectionType: selection.constructor.name });
+  if (selection instanceof NodeSelection) {
+    if (classifyNodeSelection(editor, selection) === "reject") {
+      const displayType = mapBlockNodeType(selection.node) ?? selection.node.type.name;
+      throw new DocumentApiAdapterError("INVALID_CONTEXT", `NodeSelection for node type "${displayType}" cannot be converted to SelectionTarget.`, {
+        nodeType: displayType,
+        pmNodeType: selection.node.type.name
+      });
+    }
+  }
+  return {
+    absFrom: selection.from,
+    absTo: selection.to
+  };
+}
+function resolvePmSelectionToRange(editor, selection) {
+  const { absFrom, absTo } = extractAbsoluteRange(editor, selection);
+  return resolveAbsoluteRange(editor, {
+    absFrom,
+    absTo
+  });
+}
+function resolveCurrentEditorSelectionRange(editor) {
+  return resolvePmSelectionToRange(editor, selectCurrentPmSelection(editor));
+}
+function resolveEffectiveEditorSelectionRange(editor) {
+  return resolvePmSelectionToRange(editor, selectEffectivePmSelection(editor));
+}
 function initPartsRuntime(editor) {
   registerPartDescriptor(stylesPartDescriptor);
   registerPartDescriptor(settingsPartDescriptor);
@@ -200586,7 +202227,19 @@ var Node$13 = class Node$14 {
   static create(config2) {
     return new Extension2(config2);
   }
-}, isKeyboardInvocation = (event) => {
+}, CustomSelectionPluginKey, InclusiveTextSelectionBookmark = class InclusiveTextSelectionBookmark2 {
+  constructor(anchor, head) {
+    this.anchor = anchor;
+    this.head = head;
+  }
+  map(mapping) {
+    const isForward = this.anchor <= this.head;
+    return new InclusiveTextSelectionBookmark2(mapping.map(this.anchor, isForward ? -1 : 1), mapping.map(this.head, isForward ? 1 : -1));
+  }
+  resolve(doc$12) {
+    return TextSelection2.between(doc$12.resolve(this.anchor), doc$12.resolve(this.head));
+  }
+}, nextHandleId = 1, SelectionHandlePluginKey, isKeyboardInvocation = (event) => {
   return event.type === "contextmenu" && typeof event.detail === "number" && event.detail === 0 && (event.button === 0 || event.button === undefined) && event.clientX === 0 && event.clientY === 0;
 }, prefersNativeMenu = (event) => {
   if (!event)
@@ -200599,7 +202252,7 @@ var Node$13 = class Node$14 {
 }, DEFAULT_SELECTION_STATE, normalizeSelectionState = (state = {}) => ({
   ...DEFAULT_SELECTION_STATE,
   ...state
-}), CustomSelectionPluginKey, handleClickOutside = (event, editor) => {
+}), handleClickOutside = (event, editor) => {
   const editorElem = editor?.options?.element;
   if (!editorElem)
     return;
@@ -202848,7 +204501,7 @@ var Node$13 = class Node$14 {
   view.dispatch(tr);
   event.preventDefault();
   return true;
-}, NAVIGATION_KEYS, Editable, EditorFocus, PositionTrackerExtension, global3, browser2, process3, cachedSetTimeout2, cachedClearTimeout2, queue3, draining2 = false, currentQueue2, queueIndex2 = -1, browserExports2, process$1$1, EventEmitter$1 = class {
+}, NAVIGATION_KEYS, Editable, EditorFocus, PositionTrackerExtension, SelectionHandleExtension, global3, browser2, process3, cachedSetTimeout2, cachedClearTimeout2, queue3, draining2 = false, currentQueue2, queueIndex2 = -1, browserExports2, process$1$1, EventEmitter$1 = class {
   #events = /* @__PURE__ */ new Map;
   on(name, fn) {
     const callbacks = this.#events.get(name);
@@ -206083,7 +207736,7 @@ var Node$13 = class Node$14 {
     return;
   const candidate = run2.pmEnd;
   return typeof candidate === "number" ? candidate : undefined;
-}, engines_exports, DEFAULT_HEADER_FOOTER_MARGIN_PX = 0, LINK_MARK_NAME = "link", COMMENT_MARK_NAME, SUPPORTED_INLINE_TYPES, cacheByEditor, OBJECT_REPLACEMENT_CHAR = "", LINE_NUMBER_RESTART_VALUES, PAGE_NUMBER_FORMAT_VALUES, SECTION_ORIENTATION_VALUES, SECTION_VERTICAL_ALIGN_VALUES, readSectPrHeaderFooterRefs, PIXELS_PER_INCH$2 = 96, BULLET_FORMATS$1, LOCK_MODE_TO_SDT_LOCK, SDT_NODE_NAMES, SDT_BLOCK_NAME = "structuredContentBlock", VALID_CONTROL_TYPES, VALID_LOCK_MODES, VALID_APPEARANCES, SNIPPET_PADDING = 30, DUAL_KIND_TYPES, KNOWN_BLOCK_PM_NODE_TYPES, KNOWN_INLINE_PM_NODE_TYPES, MAX_PATTERN_LENGTH = 1024, TOGGLE_MARK_SPECS, CORE_MARK_NAMES, METADATA_MARK_NAMES, CSS_NAMED_COLORS, HEADING_STYLE_DEPTH, BULLET_FORMATS, MARK_PRIORITY, remarkProcessor, DEFAULT_UNFLATTEN_LISTS = true, DERIVED_ID_LENGTH = 24, groupedCache, FIELD_LIKE_SDT_TYPES, liveDocumentCountsCache, REQUIRED_COMMANDS, VALID_CAPABILITY_REASON_CODES, REQUIRED_HELPERS, SCHEMA_NODE_GATES, schemaGatedIds, SUPPORTED_NON_UNIFORM_STRATEGIES, SUPPORTED_SET_MARKS, REGEX_MAX_PATTERN_LENGTH = 1024, registry, VALID_CREATE_POSITIONS, REF_HANDLERS, STEP_INTERACTION_MATRIX, MATRIX_EXEMPT_OPS, DEFAULT_INLINE_POLICY, CORE_SET_MARK_KEYS, BOOLEAN_INLINE_MARK_KEYS, TEXT_STYLE_KEYS, PRESERVE_RUN_PROPERTIES_META_KEY = "sdPreserveRunPropertiesKeys", CONTENT_CAPABILITIES, INLINE_CAPABILITIES, SDT_LOCK_TO_LOCK_MODE, STUB_WHERE, EMPTY_RESOLUTION, CONTAINER_NODE_TYPES, VALID_EDGE_NODE_TYPES3, FALLBACK_STORE_KEY = "__documentApiComments", STYLES_PART = "word/styles.xml", PROPERTIES_KEY_BY_CHANNEL, XML_PATH_BY_CHANNEL2, UNDERLINE_API_TO_STORAGE, UNDERLINE_STORAGE_TO_API, HEX_SUBKEYS_BY_PROPERTY, PARAGRAPH_NODE_TYPES, TEXT_STYLE_CHARACTER_STYLE_ATTR = "styleId", DIRECT_FORMATTING_MARK_NAMES, ALIGNMENT_TO_JUSTIFICATION, SUPPORTED_DELETE_NODE_TYPES3, REJECTED_DELETE_NODE_TYPES3, TEXT_PREVIEW_MAX_LENGTH = 80, RANGE_DELETE_SAFE_NODE_TYPES, INDENT_PER_LEVEL_TWIPS = 720, HANGING_INDENT_TWIPS = 360, ORDERED_PRESET_CONFIG, BULLET_PRESET_CONFIG, PRESET_TEMPLATES, LevelFormattingHelpers, NUMBERING_PART = "word/numbering.xml", DEFAULT_PRESET_FOR_KIND, PREVIEW_TEXT_MAX_LENGTH = 2000, BLOCK_PREVIEW_MAX_LENGTH = 200, EDGE_NODE_TYPES, DOCX_HEX_ID_LENGTH = 8, SETTINGS_PART_PATH = "word/settings.xml", POINTS_TO_PIXELS, POINTS_TO_TWIPS = 20, PIXELS_TO_TWIPS, DEFAULT_TABLE_GRID_WIDTH_TWIPS = 1500, SETTINGS_PART = "word/settings.xml", TABLE_ADAPTER_DISPATCH, ROW_OPS, TABLE_SCOPED_OPS, registered = false, STYLES_PART_ID = "word/styles.xml", stylesPartDescriptor, settingsPartDescriptor, RELS_PART_ID2 = "word/_rels/document.xml.rels", RELS_XMLNS$1 = "http://schemas.openxmlformats.org/package/2006/relationships", HEADER_RELATIONSHIP_TYPE$2 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/header", FOOTER_RELATIONSHIP_TYPE$2 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer", relsPartDescriptor, DOCUMENT_RELS_PATH$1 = "word/_rels/document.xml.rels", RELS_XMLNS2 = "http://schemas.openxmlformats.org/package/2006/relationships", HEADER_RELATIONSHIP_TYPE$1 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/header", FOOTER_RELATIONSHIP_TYPE$1 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer", WORDPROCESSINGML_XMLNS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", OFFICE_DOCUMENT_RELS_XMLNS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships", RELATIONSHIP_ID_PATTERN, HEADER_FILE_PATTERN$1, FOOTER_FILE_PATTERN$1, HISTORY_UNSAFE_OPS, IGNORED_ATTRIBUTE_KEYS, TRACK_CHANGE_MARK_NAMES, TRACK_CHANGE_IGNORED_ATTRIBUTE_KEYS, VOLATILE_PARAGRAPH_ATTRS, VOLATILE_IMAGE_ORIGINAL_ATTR_KEYS, SIMILARITY_THRESHOLD = 0.65, MIN_LENGTH_FOR_SIMILARITY = 4, COMMENT_ATTRS_DIFF_IGNORED_KEYS, setNestedValue = (target, path2, value) => {
+}, engines_exports, DEFAULT_HEADER_FOOTER_MARGIN_PX = 0, LINK_MARK_NAME = "link", COMMENT_MARK_NAME, SUPPORTED_INLINE_TYPES, cacheByEditor, OBJECT_REPLACEMENT_CHAR = "", LINE_NUMBER_RESTART_VALUES, PAGE_NUMBER_FORMAT_VALUES, SECTION_ORIENTATION_VALUES, SECTION_VERTICAL_ALIGN_VALUES, readSectPrHeaderFooterRefs, PIXELS_PER_INCH$2 = 96, BULLET_FORMATS$1, LOCK_MODE_TO_SDT_LOCK, SDT_NODE_NAMES, SDT_BLOCK_NAME = "structuredContentBlock", VALID_CONTROL_TYPES, VALID_LOCK_MODES, VALID_APPEARANCES, SNIPPET_PADDING = 30, DUAL_KIND_TYPES, KNOWN_BLOCK_PM_NODE_TYPES, KNOWN_INLINE_PM_NODE_TYPES, MAX_PATTERN_LENGTH = 1024, TOGGLE_MARK_SPECS, CORE_MARK_NAMES, METADATA_MARK_NAMES, CSS_NAMED_COLORS, HEADING_STYLE_DEPTH, BULLET_FORMATS, MARK_PRIORITY, remarkProcessor, DEFAULT_UNFLATTEN_LISTS = true, DERIVED_ID_LENGTH = 24, groupedCache, FIELD_LIKE_SDT_TYPES, liveDocumentCountsCache, REQUIRED_COMMANDS, VALID_CAPABILITY_REASON_CODES, REQUIRED_HELPERS, SCHEMA_NODE_GATES, schemaGatedIds, SUPPORTED_NON_UNIFORM_STRATEGIES, SUPPORTED_SET_MARKS, REGEX_MAX_PATTERN_LENGTH = 1024, registry, VALID_CREATE_POSITIONS, REF_HANDLERS, STEP_INTERACTION_MATRIX, MATRIX_EXEMPT_OPS, DEFAULT_INLINE_POLICY, CORE_SET_MARK_KEYS, BOOLEAN_INLINE_MARK_KEYS, TEXT_STYLE_KEYS, PRESERVE_RUN_PROPERTIES_META_KEY = "sdPreserveRunPropertiesKeys", CONTENT_CAPABILITIES, INLINE_CAPABILITIES, SDT_LOCK_TO_LOCK_MODE, STUB_WHERE, EMPTY_RESOLUTION, CONTAINER_NODE_TYPES, VALID_EDGE_NODE_TYPES3, FALLBACK_STORE_KEY = "__documentApiComments", STYLES_PART = "word/styles.xml", PROPERTIES_KEY_BY_CHANNEL, XML_PATH_BY_CHANNEL2, UNDERLINE_API_TO_STORAGE, UNDERLINE_STORAGE_TO_API, HEX_SUBKEYS_BY_PROPERTY, PARAGRAPH_NODE_TYPES, TEXT_STYLE_CHARACTER_STYLE_ATTR = "styleId", DIRECT_FORMATTING_MARK_NAMES, ALIGNMENT_TO_JUSTIFICATION, SUPPORTED_DELETE_NODE_TYPES3, REJECTED_DELETE_NODE_TYPES3, TEXT_PREVIEW_MAX_LENGTH = 80, RANGE_DELETE_SAFE_NODE_TYPES, INDENT_PER_LEVEL_TWIPS = 720, HANGING_INDENT_TWIPS = 360, ORDERED_PRESET_CONFIG, BULLET_PRESET_CONFIG, PRESET_TEMPLATES, LevelFormattingHelpers, PRESET_KIND_MAP, NUMBERING_PART = "word/numbering.xml", DEFAULT_PRESET_FOR_KIND, _setValueDelegate, PREVIEW_TEXT_MAX_LENGTH = 2000, BLOCK_PREVIEW_MAX_LENGTH = 200, EDGE_NODE_TYPES$1, DOCX_HEX_ID_LENGTH = 8, SETTINGS_PART_PATH = "word/settings.xml", POINTS_TO_PIXELS, POINTS_TO_TWIPS = 20, PIXELS_TO_TWIPS, DEFAULT_TABLE_GRID_WIDTH_TWIPS = 1500, SETTINGS_PART = "word/settings.xml", TABLE_ADAPTER_DISPATCH, ROW_OPS, TABLE_SCOPED_OPS, registered = false, STYLES_PART_ID = "word/styles.xml", stylesPartDescriptor, settingsPartDescriptor, RELS_PART_ID2 = "word/_rels/document.xml.rels", RELS_XMLNS$1 = "http://schemas.openxmlformats.org/package/2006/relationships", HEADER_RELATIONSHIP_TYPE$2 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/header", FOOTER_RELATIONSHIP_TYPE$2 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer", relsPartDescriptor, DOCUMENT_RELS_PATH$1 = "word/_rels/document.xml.rels", RELS_XMLNS2 = "http://schemas.openxmlformats.org/package/2006/relationships", HEADER_RELATIONSHIP_TYPE$1 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/header", FOOTER_RELATIONSHIP_TYPE$1 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer", WORDPROCESSINGML_XMLNS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", OFFICE_DOCUMENT_RELS_XMLNS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships", RELATIONSHIP_ID_PATTERN, HEADER_FILE_PATTERN$1, FOOTER_FILE_PATTERN$1, HISTORY_UNSAFE_OPS, IGNORED_ATTRIBUTE_KEYS, TRACK_CHANGE_MARK_NAMES, TRACK_CHANGE_IGNORED_ATTRIBUTE_KEYS, VOLATILE_PARAGRAPH_ATTRS, VOLATILE_IMAGE_ORIGINAL_ATTR_KEYS, SIMILARITY_THRESHOLD = 0.65, MIN_LENGTH_FOR_SIMILARITY = 4, COMMENT_ATTRS_DIFF_IGNORED_KEYS, setNestedValue = (target, path2, value) => {
   if (!path2.includes(".")) {
     target[path2] = value;
     return;
@@ -206696,7 +208349,7 @@ var Node$13 = class Node$14 {
     candidate = String(parseInt(hex, 16));
   } while (!candidate || existingIds.has(candidate));
   return candidate;
-}, ALLOWED_WRAP_ATTRS, WRAP_TYPES_SUPPORTING_SIDE, WRAP_TYPES_SUPPORTING_DISTANCES, RELATIVE_HEIGHT_MIN = 0, RELATIVE_HEIGHT_MAX = 4294967295, FORBIDDEN_RAW_PATCH_NAMES, CONTROL_TYPE_SDT_PR_ELEMENTS, DEFAULT_CHECKBOX_SYMBOL_FONT2 = "MS Gothic", DEFAULT_CHECKBOX_CHECKED_HEX2 = "2612", DEFAULT_CHECKBOX_UNCHECKED_HEX2 = "2610", VARIANT_ORDER, KIND_ORDER, HEADER_RELATIONSHIP_TYPE2 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/header", FOOTER_RELATIONSHIP_TYPE2 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer", DOCUMENT_RELS_PATH = "word/_rels/document.xml.rels", HEADER_FILE_PATTERN, FOOTER_FILE_PATTERN, SPECIAL_NOTE_TYPES, FOOTNOTES_PART_ID = "word/footnotes.xml", ENDNOTES_PART_ID = "word/endnotes.xml", FOOTNOTES_CONFIG, ENDNOTES_CONFIG, NOTES_XMLNS, footnotesPartDescriptor, endnotesPartDescriptor, RESTART_POLICY_TO_OOXML, VALID_DISPLAYS, CAPTION_STYLE_NAMES, CAPTION_PARAGRAPH_STYLE_ID = "Caption", CAPTION_FORMAT_TO_OOXML, FIELD_NODE_TYPES, TOA_LEADER_REVERSE_MAP, CONTENT_TYPES_PART_ID = "[Content_Types].xml", CONTENT_TYPES_NS = "http://schemas.openxmlformats.org/package/2006/content-types", contentTypesPartDescriptor, empty_exports, init_empty, CURRENT_APP_VERSION2 = "1.20.0", PIXELS_PER_INCH$1 = 96, MAX_HEIGHT_BUFFER_PX = 50, MAX_WIDTH_BUFFER_PX = 20, Editor, ContextMenuPluginKey, MENU_OFFSET_X = 0, MENU_OFFSET_Y = 28, CONTEXT_MENU_OFFSET_X = 10, CONTEXT_MENU_OFFSET_Y = 10, SLASH_COOLDOWN_MS = 5000, ContextMenu, SearchQuery = class {
+}, ALLOWED_WRAP_ATTRS, WRAP_TYPES_SUPPORTING_SIDE, WRAP_TYPES_SUPPORTING_DISTANCES, RELATIVE_HEIGHT_MIN = 0, RELATIVE_HEIGHT_MAX = 4294967295, FORBIDDEN_RAW_PATCH_NAMES, CONTROL_TYPE_SDT_PR_ELEMENTS, DEFAULT_CHECKBOX_SYMBOL_FONT2 = "MS Gothic", DEFAULT_CHECKBOX_CHECKED_HEX2 = "2612", DEFAULT_CHECKBOX_UNCHECKED_HEX2 = "2610", VARIANT_ORDER, KIND_ORDER, HEADER_RELATIONSHIP_TYPE2 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/header", FOOTER_RELATIONSHIP_TYPE2 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer", DOCUMENT_RELS_PATH = "word/_rels/document.xml.rels", HEADER_FILE_PATTERN, FOOTER_FILE_PATTERN, SPECIAL_NOTE_TYPES, FOOTNOTES_PART_ID = "word/footnotes.xml", ENDNOTES_PART_ID = "word/endnotes.xml", FOOTNOTES_CONFIG, ENDNOTES_CONFIG, NOTES_XMLNS, footnotesPartDescriptor, endnotesPartDescriptor, RESTART_POLICY_TO_OOXML, VALID_DISPLAYS, CAPTION_STYLE_NAMES, CAPTION_PARAGRAPH_STYLE_ID = "Caption", CAPTION_FORMAT_TO_OOXML, FIELD_NODE_TYPES, TOA_LEADER_REVERSE_MAP, EDGE_NODE_TYPES, CONTENT_TYPES_PART_ID = "[Content_Types].xml", CONTENT_TYPES_NS = "http://schemas.openxmlformats.org/package/2006/content-types", contentTypesPartDescriptor, empty_exports, init_empty, CURRENT_APP_VERSION2 = "1.20.0", PIXELS_PER_INCH$1 = 96, MAX_HEIGHT_BUFFER_PX = 50, MAX_WIDTH_BUFFER_PX = 20, Editor, ContextMenuPluginKey, MENU_OFFSET_X = 0, MENU_OFFSET_Y = 28, CONTEXT_MENU_OFFSET_X = 10, CONTEXT_MENU_OFFSET_Y = 10, SLASH_COOLDOWN_MS = 5000, ContextMenu, SearchQuery = class {
   constructor(config2) {
     this.search = config2.search;
     this.caseSensitive = !!config2.caseSensitive;
@@ -218756,6 +220409,7 @@ var Node$13 = class Node$14 {
     mediaFiles: editor.storage.image.media,
     fonts: editor.options.fonts,
     isHeaderOrFooter: true,
+    headerFooterType: type,
     isHeadless: editor.options.isHeadless,
     pagination: false,
     annotations: true,
@@ -225108,9 +226762,9 @@ var Node$13 = class Node$14 {
     return false;
   return Boolean(checker(attrs));
 }, SuperToolbar, ICONS, TEXTS, tableActionsOptions;
-var init_src_B0uLvfdR_es = __esm(() => {
+var init_src_D3r_lb_g_es = __esm(() => {
   init_rolldown_runtime_B2q5OVn9_es();
-  init_SuperConverter_BcBeadrv_es();
+  init_SuperConverter_hOU3ez7P_es();
   init_jszip_ChlR43oI_es();
   init_uuid_qzgm05fK_es();
   init_constants_ep1_Gwqi_es();
@@ -225662,13 +227316,14 @@ ${err.toString()}`);
       }
     }
   };
+  CustomSelectionPluginKey = new PluginKey("CustomSelection");
+  SelectionHandlePluginKey = new PluginKey("selectionHandle");
   DEFAULT_SELECTION_STATE = Object.freeze({
     focused: false,
     preservedSelection: null,
     showVisualSelection: false,
     skipFocusReset: false
   });
-  CustomSelectionPluginKey = new PluginKey("CustomSelection");
   CustomSelection = Extension.create({
     name: "customSelection",
     addPmPlugins() {
@@ -226214,6 +227869,12 @@ ${err.toString()}`);
       this.storage.tracker = null;
     }
   });
+  SelectionHandleExtension = Extension.create({
+    name: "selectionHandle",
+    addPmPlugins() {
+      return [createSelectionHandlePlugin()];
+    }
+  });
   global3 = globalThis || self;
   browser2 = { exports: {} };
   process3 = browser2.exports = {};
@@ -233087,18 +234748,41 @@ function print() { __p += __j.call(arguments, '') }
     setLevelIndents,
     setLevelTrailingCharacter,
     setLevelMarkerFont,
-    hasLevelOverride,
+    setLevelTabStop,
+    setLevelNumberStyle,
+    setLevelText,
+    setLevelStart,
+    setLevelLayout,
+    hasLevelOverride: hasLevelOverride$1,
     clearLevelOverride,
+    materializeLevelFormattingOverride,
     captureTemplate,
     applyTemplateToAbstract,
+    captureEffectiveStyle,
+    isAbstractShared,
+    cloneAbstractIntoNum,
+    cloneAbstractAndNum,
+    copySequenceStateOverrides,
     getPresetTemplate,
     PRESET_TEMPLATES
   };
+  PRESET_KIND_MAP = {
+    decimal: "ordered",
+    decimalParenthesis: "ordered",
+    lowerLetter: "ordered",
+    upperLetter: "ordered",
+    lowerRoman: "ordered",
+    upperRoman: "ordered",
+    disc: "bullet",
+    circle: "bullet",
+    square: "bullet",
+    dash: "bullet"
+  };
   DEFAULT_PRESET_FOR_KIND = {
     ordered: "decimal",
     bullet: "disc"
   };
-  EDGE_NODE_TYPES = new Set(SELECTION_EDGE_NODE_TYPES2);
+  EDGE_NODE_TYPES$1 = new Set(SELECTION_EDGE_NODE_TYPES2);
   POINTS_TO_PIXELS = 96 / 72;
   PIXELS_TO_TWIPS = 1440 / 96;
   TABLE_ADAPTER_DISPATCH = {
@@ -233496,6 +235180,7 @@ function print() { __p += __j.call(arguments, '') }
     "-": "hyphen",
     _: "underscore"
   };
+  EDGE_NODE_TYPES = new Set(SELECTION_EDGE_NODE_TYPES2);
   contentTypesPartDescriptor = {
     id: CONTENT_TYPES_PART_ID,
     ensurePart() {
@@ -234040,6 +235725,39 @@ function print() { __p += __j.call(arguments, '') }
         this.#documentApi = createDocumentApi2(getDocumentApiAdapters(this));
       return this.#documentApi;
     }
+    #getDefaultSelectionHandleSurface() {
+      const explicitType = this.options.headerFooterType;
+      return explicitType === "header" || explicitType === "footer" ? explicitType : "body";
+    }
+    captureCurrentSelectionHandle(surface) {
+      this.#assertState("ready", "saving");
+      const selection = selectCurrentPmSelection(this);
+      return captureSelectionHandle(this, selection, surface ?? this.#getDefaultSelectionHandleSurface());
+    }
+    captureEffectiveSelectionHandle(surface) {
+      this.#assertState("ready", "saving");
+      const selection = selectEffectivePmSelection(this);
+      return captureSelectionHandle(this, selection, surface ?? this.#getDefaultSelectionHandleSurface());
+    }
+    resolveSelectionHandle(handle3) {
+      this.#assertState("ready", "saving");
+      const selection = resolveHandleToSelection(handle3);
+      if (!selection)
+        return null;
+      return resolvePmSelectionToRange(handle3._owner, selection);
+    }
+    releaseSelectionHandle(handle3) {
+      this.#assertState("ready", "saving");
+      releaseSelectionHandle(handle3);
+    }
+    getCurrentSelectionRange() {
+      this.#assertState("ready", "saving");
+      return resolveCurrentEditorSelectionRange(this);
+    }
+    getEffectiveSelectionRange() {
+      this.#assertState("ready", "saving");
+      return resolveEffectiveEditorSelectionRange(this);
+    }
     get helpers() {
       return this.extensionService.helpers;
     }
@@ -234268,7 +235986,8 @@ function print() { __p += __j.call(arguments, '') }
         Commands,
         EditorFocus,
         Keymap,
-        PositionTrackerExtension
+        PositionTrackerExtension,
+        SelectionHandleExtension
       ];
       const externalExtensions = this.options.externalExtensions || [];
       const allExtensions = [...coreExtensions, ...this.options.extensions].filter((extension2) => {
@@ -243455,6 +245174,61 @@ function print() { __p += __j.call(arguments, '') }
         return this.#editor;
       return activeHfEditor;
     }
+    #resolveActiveSurface() {
+      const mode = this.#headerFooterSession?.session?.mode ?? "body";
+      if (mode === "header")
+        return "header";
+      if (mode === "footer")
+        return "footer";
+      return "body";
+    }
+    captureCurrentSelectionHandle() {
+      const surface = this.#resolveActiveSurface();
+      return this.getActiveEditor().captureCurrentSelectionHandle(surface);
+    }
+    captureEffectiveSelectionHandle() {
+      const surface = this.#resolveActiveSurface();
+      return this.getActiveEditor().captureEffectiveSelectionHandle(surface);
+    }
+    resolveSelectionHandle(handle3) {
+      const ownerEditor = handle3._owner;
+      const range = ownerEditor.resolveSelectionHandle(handle3);
+      if (!range)
+        return null;
+      return {
+        editor: ownerEditor,
+        doc: ownerEditor.doc,
+        surface: handle3.surface,
+        range
+      };
+    }
+    releaseSelectionHandle(handle3) {
+      handle3._owner.releaseSelectionHandle(handle3);
+    }
+    getCurrentSelectionRange() {
+      return this.getActiveEditor().getCurrentSelectionRange();
+    }
+    getEffectiveSelectionRange() {
+      return this.getActiveEditor().getEffectiveSelectionRange();
+    }
+    getCurrentSelectionContext() {
+      const activeEditor = this.getActiveEditor();
+      return {
+        editor: activeEditor,
+        doc: activeEditor.doc,
+        surface: this.#resolveActiveSurface(),
+        range: activeEditor.getCurrentSelectionRange()
+      };
+    }
+    getEffectiveSelectionContext() {
+      const activeEditor = this.getActiveEditor();
+      return {
+        editor: activeEditor,
+        doc: activeEditor.doc,
+        surface: this.#resolveActiveSurface(),
+        range: activeEditor.getEffectiveSelectionRange()
+      };
+    }
     undo() {
       const editor = this.getActiveEditor();
       if (editor?.commands?.undo)
@@ -258207,8 +259981,8 @@ var init_zipper_DqXT7uTa_es = __esm(() => {
 
 // ../../packages/superdoc/dist/super-editor.es.js
 var init_super_editor_es = __esm(() => {
-  init_src_B0uLvfdR_es();
-  init_SuperConverter_BcBeadrv_es();
+  init_src_D3r_lb_g_es();
+  init_SuperConverter_hOU3ez7P_es();
   init_jszip_ChlR43oI_es();
   init_xml_js_BtmJ6bNs_es();
   init_constants_ep1_Gwqi_es();
@@ -315768,6 +317542,15 @@ function acceptsLegacyTextAddressTarget(operationId, param, value2) {
   const docApiId = toDocApiId(operationId);
   return docApiId === "replace" || docApiId === "delete" || docApiId?.startsWith("format.") === true;
 }
+function extractConstValues(variants) {
+  const values2 = [];
+  for (const variant of variants) {
+    if (!("const" in variant))
+      return [];
+    values2.push(String(variant.const));
+  }
+  return values2;
+}
 function validateValueAgainstTypeSpec(value2, schema, path2) {
   if ("const" in schema) {
     if (value2 !== schema.const) {
@@ -315786,7 +317569,9 @@ function validateValueAgainstTypeSpec(value2, schema, path2) {
         errors2.push(error2 instanceof Error ? error2.message : String(error2));
       }
     }
-    throw new CliError("VALIDATION_ERROR", `${path2} must match one of the allowed schema variants.`, { errors: errors2 });
+    const allowedValues = extractConstValues(variants);
+    const message = allowedValues.length > 0 ? `${path2} must be one of: ${allowedValues.join(", ")}.` : `${path2} must match one of the allowed schema variants.`;
+    throw new CliError("VALIDATION_ERROR", message, { errors: errors2 });
   }
   if (schema.type === "json")
     return;