layoutbridge-spm 0.0.1 → 1.0.0

package/indesign/commands/45-frame-options.js

@@ -0,0 +1,247 @@
+/* Wunschliste J (Sitzung 7) – Rahmenoptionen lesen: get_frame_options. */
+
+/* first_baseline_offset: Name <-> FirstBaseline-Enumerator. */
+function idcFirstBaselineFor(name) {
+  if (typeof FirstBaseline === 'undefined') { return null; }
+  if (name === 'ascent') { return FirstBaseline.ASCENT_OFFSET; }
+  if (name === 'cap_height') { return FirstBaseline.CAP_HEIGHT; }
+  if (name === 'leading') { return FirstBaseline.LEADING_OFFSET; }
+  if (name === 'x_height') { return FirstBaseline.X_HEIGHT; }
+  if (name === 'fixed') { return FirstBaseline.FIXED_HEIGHT; }
+  if (name === 'embox_top') { return FirstBaseline.EMBOX_TOP; }
+  return null;
+}
+
+function idcFirstBaselineName(value) {
+  if (value === undefined || value === null) { return null; }
+  if (typeof FirstBaseline === 'undefined') { return String(value); }
+  if (IDC.enumIs(value, FirstBaseline.ASCENT_OFFSET)) { return 'ascent'; }
+  if (IDC.enumIs(value, FirstBaseline.CAP_HEIGHT)) { return 'cap_height'; }
+  if (IDC.enumIs(value, FirstBaseline.LEADING_OFFSET)) { return 'leading'; }
+  if (IDC.enumIs(value, FirstBaseline.X_HEIGHT)) { return 'x_height'; }
+  if (IDC.enumIs(value, FirstBaseline.FIXED_HEIGHT)) { return 'fixed'; }
+  if (IDC.enumIs(value, FirstBaseline.EMBOX_TOP)) { return 'embox_top'; }
+  return String(value);
+}
+
+function idcVerticalJustificationName(value) {
+  if (value === undefined || value === null) { return null; }
+  if (typeof VerticalJustification === 'undefined') { return String(value); }
+  if (IDC.enumIs(value, VerticalJustification.TOP_ALIGN)) { return 'top'; }
+  if (IDC.enumIs(value, VerticalJustification.CENTER_ALIGN)) { return 'center'; }
+  if (IDC.enumIs(value, VerticalJustification.BOTTOM_ALIGN)) { return 'bottom'; }
+  if (IDC.enumIs(value, VerticalJustification.JUSTIFY_ALIGN)) { return 'justify'; }
+  return String(value);
+}
+
+/*
+ * Name -> VerticalJustification, null bei unbekanntem Namen. Kein
+ * verschachtelter ?:-Ausdruck: ExtendScript klammert ihn links (Fund 3,
+ * Sitzung 6, live nachgewiesen am 05.09.2026).
+ */
+function idcVerticalJustificationFor(name) {
+  if (typeof VerticalJustification === 'undefined') { return null; }
+  if (name === 'top') { return VerticalJustification.TOP_ALIGN; }
+  if (name === 'center') { return VerticalJustification.CENTER_ALIGN; }
+  if (name === 'bottom') { return VerticalJustification.BOTTOM_ALIGN; }
+  if (name === 'justify') { return VerticalJustification.JUSTIFY_ALIGN; }
+  return null;
+}
+
+function idcColumnTypeName(value) {
+  if (value === undefined || value === null) { return null; }
+  if (typeof TextColumnType === 'undefined') { return String(value); }
+  if (IDC.enumIs(value, TextColumnType.FIXED_NUMBER)) { return 'fixed_number'; }
+  if (IDC.enumIs(value, TextColumnType.FIXED_WIDTH)) { return 'fixed_width'; }
+  if (IDC.enumIs(value, TextColumnType.FLEXIBLE_WIDTH)) { return 'flexible_width'; }
+  return String(value);
+}
+
+/*
+ * Spaltenart. Adobes DOM (TextFramePreference) fuehrt sie als zwei Schalter
+ * useFixedColumnWidth / useFlexibleColumnWidth; ein textColumnType gibt es
+ * dort nicht (in 21.5 wirft der Zugriff – Sitzung 7). Erst die Schalter,
+ * dann der Rueckfall auf textColumnType fuer Laufzeiten, die ihn kennen.
+ */
+function idcColumnType(prefs) {
+  var flexible = null, fixed = null;
+  try { flexible = prefs.useFlexibleColumnWidth === true; } catch (e0) { flexible = null; }
+  try { fixed = prefs.useFixedColumnWidth === true; } catch (e1) { fixed = null; }
+  if (flexible === true) { return 'flexible_width'; }
+  if (fixed === true) { return 'fixed_width'; }
+  if (flexible === false || fixed === false) { return 'fixed_number'; }
+  try { return idcColumnTypeName(prefs.textColumnType); } catch (e2) { return null; }
+}
+
+/*
+ * inset_mm beim Anlegen: eine Zahl (alle Kanten) oder { top, left, bottom,
+ * right }; fehlende Kanten eines Objekts gelten als 0.
+ */
+function idcInsetArg(spec, field) {
+  var keys = ['top', 'left', 'bottom', 'right'];
+  var out = {};
+  var i, v;
+  if (typeof spec === 'number') {
+    if (!isFinite(spec) || spec < 0) {
+      IDC.fail('invalid_argument', field + ' must be a number of 0 or more (mm).', { value: spec });
+    }
+    return { top: spec, left: spec, bottom: spec, right: spec };
+  }
+  if (!spec || typeof spec !== 'object') {
+    IDC.fail('invalid_argument', field + ' must be a number or an object { top, left, bottom, right } in mm.', null);
+  }
+  for (i = 0; i < keys.length; i++) {
+    v = spec[keys[i]];
+    if (v === undefined || v === null) { out[keys[i]] = 0; continue; }
+    if (typeof v !== 'number' || !isFinite(v) || v < 0) {
+      IDC.fail('invalid_argument', field + '.' + keys[i] + ' must be a number of 0 or more.', spec);
+    }
+    out[keys[i]] = v;
+  }
+  return out;
+}
+
+/*
+ * Rahmenoptionen eines Textrahmens (Objekt > Textrahmenoptionen), gelesen
+ * unter Millimeter; Grundlinien-Mindestabstand in Punkt.
+ */
+function idcTextFrameOptions(doc, frame) {
+  var prefs = null;
+  var out = {
+    columns: { count: null, gutter_mm: null, type: null, fixed_width_mm: null },
+    inset_mm: null,
+    vertical_justification: null,
+    vertical_threshold_mm: null,
+    first_baseline_offset: null,
+    min_first_baseline_pt: null,
+    ignore_text_wrap: null,
+    optical_margin_alignment: null,
+    optical_margin_size_pt: null
+  };
+  /* A-7.4: storyweite Werte (StoryPreference) unter text, damit get_frame_options sie zeigt. */
+  try {
+    var storyOptions = idcReadStoryOptions(frame.parentStory);
+    out.optical_margin_alignment = storyOptions.optical_margin_alignment;
+    out.optical_margin_size_pt = storyOptions.optical_margin_size_pt;
+  } catch (eS) { /* bleibt null */ }
+  try { prefs = frame.textFramePreferences; } catch (e0) { prefs = null; }
+  if (prefs === null || prefs === undefined) { return out; }
+  try { out.columns.count = Number(prefs.textColumnCount); } catch (e1) { /* bleibt null */ }
+  try { out.columns.gutter_mm = IDC.round(Number(prefs.textColumnGutter)); } catch (e2) { /* bleibt null */ }
+  out.columns.type = idcColumnType(prefs);
+  try { out.columns.fixed_width_mm = IDC.round(Number(prefs.textColumnFixedWidth)); } catch (e4) { /* bleibt null */ }
+  try { out.inset_mm = idcEdgesFromArray(prefs.insetSpacing); } catch (e5) { /* bleibt null */ }
+  try { out.vertical_justification = idcVerticalJustificationName(prefs.verticalJustification); } catch (e6) { /* bleibt null */ }
+  try { out.vertical_threshold_mm = IDC.round(Number(prefs.verticalThreshold)); } catch (e7) { /* bleibt null */ }
+  try { out.first_baseline_offset = idcFirstBaselineName(prefs.firstBaselineOffset); } catch (e8) { /* bleibt null */ }
+  try {
+    out.min_first_baseline_pt = IDC.inPoints(function () { return IDC.round(Number(prefs.minimumFirstBaselineOffset), 3); });
+  } catch (e9) { /* bleibt null */ }
+  try { out.ignore_text_wrap = prefs.ignoreWrap === true; } catch (e10) { /* bleibt null */ }
+  return out;
+}
+
+/* Verkettung: Story, Stellung des Rahmens in ihr, Nachbarn, Uebersatz. */
+function idcThreading(frame) {
+  var out = {
+    story_id: null,
+    story_length: null,
+    frame_index: null,
+    frame_count: null,
+    previous_frame_id: null,
+    next_frame_id: null,
+    overset: null,
+    story_overset: null
+  };
+  var story = null, frames, i, prev = null, next = null;
+  try { story = frame.parentStory; } catch (e0) { story = null; }
+  if (story !== null && story !== undefined) {
+    try { out.story_id = Number(story.id); } catch (e1) { /* null */ }
+    try { out.story_length = Number(story.characters.length); } catch (e2) { /* null */ }
+    try {
+      frames = story.textContainers;
+      out.frame_count = frames.length;
+      for (i = 0; i < frames.length; i++) {
+        if (Number(frames[i].id) === Number(frame.id)) { out.frame_index = i; break; }
+      }
+    } catch (e3) { /* null */ }
+    try { out.story_overset = story.overflows === true; } catch (e4) { /* null */ }
+  }
+  try { prev = frame.previousTextFrame; } catch (e5) { prev = null; }
+  try { next = frame.nextTextFrame; } catch (e6) { next = null; }
+  try { if (prev !== null && prev !== undefined && prev.isValid === true) { out.previous_frame_id = Number(prev.id); } } catch (e7) { /* null */ }
+  try { if (next !== null && next !== undefined && next.isValid === true) { out.next_frame_id = Number(next.id); } } catch (e8) { /* null */ }
+  try { out.overset = frame.overflows === true; } catch (e9) { /* null */ }
+  return out;
+}
+
+/*
+ * Grundlinie der ersten Zeile in mm ab Seitenoberkante (Lineal steht fuer
+ * den Aufruf auf Seiten-Nullpunkt), null ohne Text. Der direkte Weg, den
+ * Sitz einer Bildunterschrift im Grundlinienraster zu pruefen (Fund 3).
+ */
+function idcFirstBaselineMm(frame) {
+  try {
+    if (frame.lines.length === 0) { return null; }
+    return IDC.round(Number(frame.lines.item(0).baseline), 3);
+  } catch (e0) { return null; }
+}
+
+/* Textumfluss eines Objekts mit Abstand. */
+function idcTextWrapOptions(item) {
+  var out = { mode: null, offset_mm: null };
+  var prefs = null, mode;
+  try { prefs = item.textWrapPreferences; } catch (e0) { prefs = null; }
+  if (prefs === null || prefs === undefined) { return out; }
+  mode = idcTextWrapName(item);
+  if (mode === 'contour') { mode = 'object_shape'; }
+  out.mode = mode;
+  try { out.offset_mm = idcEdgesFromArray(prefs.textWrapOffset); } catch (e1) { out.offset_mm = null; }
+  return out;
+}
+
+IDC.register('get_frame_options', { needs_document: true, read_only: true, ruler: 'page' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var found = idcFrameArg(doc, args, 'frame_id');
+    var item = found.item;
+    var type = IDC.itemType(item);
+    var landing = IDC.landing(item);
+    var look = idcAppearanceFull(item);
+    var corners = type === 'line' || type === 'group' ? null : idcReadCorners(item);
+    var out = {
+      frame_id: Number(item.id),
+      type: type,
+      page_id: landing.page_id,
+      page_name: landing.page_name,
+      on_parent_page: found.on_parent === true,
+      coordinate_space: idcBoundsSpace(item),
+      bounds_mm: idcItemBounds(doc, item),
+      rotation_deg: idcRotationOf(item),
+      text_wrap: idcTextWrapOptions(item),
+      appearance: look,
+      corners: corners === null ? null : { top_left: corners.top_left, top_right: corners.top_right, bottom_left: corners.bottom_left, bottom_right: corners.bottom_right, uniform: corners.uniform },
+      layer: idcLayerSummary(doc, item),
+      locked: idcReadBool(item, 'locked') === true,
+      anchored: idcAnchorInfo(item),
+      effects: null,
+      has_effects: null,
+      text: null
+    };
+    /* A-8.6: Effekte des Objekts und ob Flaeche, Kontur, Text abweichen. */
+    var effects = idcEffectsSummary(item);
+    out.effects = effects.effects;
+    out.has_effects = effects.has_effects;
+    var parentGroup = null;
+    try { if (IDC.className(item.parent) === 'Group') { parentGroup = Number(item.parent.id); } } catch (e0) { parentGroup = null; }
+    out.parent_group_id = parentGroup;
+
+    if (IDC.isTextFrame(item)) {
+      out.text = idcTextFrameOptions(doc, item);
+      out.text.threading = idcThreading(item);
+      out.text.first_baseline_mm = idcFirstBaselineMm(item);
+      try { out.text.character_count = Number(item.characters.length); } catch (e1) { out.text.character_count = null; }
+    }
+    return out;
+  });

package/indesign/commands/47-anchored.js

@@ -0,0 +1,287 @@
+/* Wunschliste J2 Nr. 17 (Sitzung 8) – verankerte Objekte: anchor_frame_in_text, unanchor_frame. */
+
+var IDC_ANCHOR_POSITIONS = [
+  ['inline', 'INLINE_POSITION'],
+  ['above_line', 'ABOVE_LINE'],
+  ['custom', 'ANCHORED']
+];
+var IDC_ANCHOR_POINTS = [
+  ['top_left', 'TOP_LEFT_ANCHOR'], ['top_center', 'TOP_CENTER_ANCHOR'], ['top_right', 'TOP_RIGHT_ANCHOR'],
+  ['left_center', 'LEFT_CENTER_ANCHOR'], ['center', 'CENTER_ANCHOR'], ['right_center', 'RIGHT_CENTER_ANCHOR'],
+  ['bottom_left', 'BOTTOM_LEFT_ANCHOR'], ['bottom_center', 'BOTTOM_CENTER_ANCHOR'], ['bottom_right', 'BOTTOM_RIGHT_ANCHOR']
+];
+var IDC_H_REFERENCES = [
+  ['anchor_location', 'ANCHOR_LOCATION'], ['column_edge', 'COLUMN_EDGE'], ['text_frame', 'TEXT_FRAME'],
+  ['page_margins', 'PAGE_MARGINS'], ['page_edge', 'PAGE_EDGE']
+];
+var IDC_V_REFERENCES = [
+  ['line_baseline', 'LINE_BASELINE'], ['line_xheight', 'LINE_XHEIGHT'], ['line_ascent', 'LINE_ASCENT'],
+  ['cap_height', 'CAPHEIGHT'], ['top_of_leading', 'TOP_OF_LEADING'], ['embox_top', 'EMBOX_TOP'],
+  ['embox_middle', 'EMBOX_MIDDLE'], ['embox_bottom', 'EMBOX_BOTTOM'], ['column_edge', 'COLUMN_EDGE'],
+  ['text_frame', 'TEXT_FRAME'], ['page_margins', 'PAGE_MARGINS'], ['page_edge', 'PAGE_EDGE']
+];
+var IDC_H_ALIGNMENTS = [['left', 'LEFT_ALIGN'], ['center', 'CENTER_ALIGN'], ['right', 'RIGHT_ALIGN'], ['text', 'TEXT_ALIGN']];
+var IDC_V_ALIGNMENTS = [['top', 'TOP_ALIGN'], ['center', 'CENTER_ALIGN'], ['bottom', 'BOTTOM_ALIGN']];
+
+/* Enumeratorwert zu einem Namen aus einer Tabelle; null, wenn die Laufzeit den Enumerator nicht kennt. */
+function idcEnumFor(table, enumObject, name, field) {
+  var i;
+  for (i = 0; i < table.length; i++) {
+    if (table[i][0] === name) {
+      if (enumObject === null || enumObject === undefined) { return null; }
+      try { return enumObject[table[i][1]]; } catch (e) { return null; }
+    }
+  }
+  IDC.fail('invalid_argument', field + ' must be one of ' + idcTableNames(table).join(', ') + '.', { field: field, value: name });
+  return null;
+}
+
+function idcTableNames(table) {
+  var out = [], i;
+  for (i = 0; i < table.length; i++) { out.push(table[i][0]); }
+  return out;
+}
+
+/* Name zu einem Enumeratorwert; String(value), wenn kein Name passt. */
+function idcEnumName(table, enumObject, value) {
+  var i;
+  if (value === undefined || value === null) { return null; }
+  if (enumObject === null || enumObject === undefined) { return String(value); }
+  for (i = 0; i < table.length; i++) {
+    try { if (IDC.enumIs(value, enumObject[table[i][1]])) { return table[i][0]; } } catch (e) { /* naechster */ }
+  }
+  return String(value);
+}
+
+/* Enumerator-Objekt der Laufzeit ueber seinen Namen, null wenn unbekannt (kein eval). */
+function idcEnumObject(name) {
+  if (name === 'AnchorPosition') { return typeof AnchorPosition === 'undefined' ? null : AnchorPosition; }
+  if (name === 'AnchorPoint') { return typeof AnchorPoint === 'undefined' ? null : AnchorPoint; }
+  if (name === 'AnchoredRelativeTo') { return typeof AnchoredRelativeTo === 'undefined' ? null : AnchoredRelativeTo; }
+  if (name === 'VerticallyRelativeTo') { return typeof VerticallyRelativeTo === 'undefined' ? null : VerticallyRelativeTo; }
+  if (name === 'HorizontalAlignment') { return typeof HorizontalAlignment === 'undefined' ? null : HorizontalAlignment; }
+  if (name === 'VerticalAlignment') { return typeof VerticalAlignment === 'undefined' ? null : VerticalAlignment; }
+  return null;
+}
+
+/* Verankert? Der parent eines verankerten Objekts ist eine Textstelle. */
+function idcAnchorInfo(item) {
+  var parent = null, name = '', settings = null;
+  var out = { story_id: null, index: null, position: null };
+  try { parent = item.parent; } catch (e0) { return null; }
+  if (parent === null || parent === undefined) { return null; }
+  name = IDC.className(parent);
+  if (name !== 'Character' && name !== 'InsertionPoint' && name !== 'Text' && name !== 'Word' && name !== 'Line' && name !== 'Paragraph' && name !== 'TextStyleRange') {
+    return null;
+  }
+  try { out.story_id = Number(parent.parentStory.id); } catch (e1) { /* null */ }
+  try { out.index = Number(parent.index); } catch (e2) { /* null */ }
+  try { settings = item.anchoredObjectSettings; } catch (e3) { settings = null; }
+  if (settings !== null && settings !== undefined) {
+    try { out.position = idcEnumName(IDC_ANCHOR_POSITIONS, idcEnumObject('AnchorPosition'), settings.anchoredPosition); } catch (e4) { /* null */ }
+  }
+  return out;
+}
+
+function idcDescribeAnchoredSettings(item) {
+  var settings = null;
+  var out = { position: null, anchor_point: null, horizontal_reference: null, vertical_reference: null,
+    horizontal_alignment: null, vertical_alignment: null, offset_mm: { x: null, y: null }, keep_within_frame: null, lock_position: null };
+  try { settings = item.anchoredObjectSettings; } catch (e0) { settings = null; }
+  if (settings === null || settings === undefined) { return out; }
+  try { out.position = idcEnumName(IDC_ANCHOR_POSITIONS, idcEnumObject('AnchorPosition'), settings.anchoredPosition); } catch (e1) { /* null */ }
+  try { out.anchor_point = idcEnumName(IDC_ANCHOR_POINTS, idcEnumObject('AnchorPoint'), settings.anchorPoint); } catch (e2) { /* null */ }
+  try { out.horizontal_reference = idcEnumName(IDC_H_REFERENCES, idcEnumObject('AnchoredRelativeTo'), settings.horizontalReferencePoint); } catch (e3) { /* null */ }
+  try { out.vertical_reference = idcEnumName(IDC_V_REFERENCES, idcEnumObject('VerticallyRelativeTo'), settings.verticalReferencePoint); } catch (e4) { /* null */ }
+  try { out.horizontal_alignment = idcEnumName(IDC_H_ALIGNMENTS, idcEnumObject('HorizontalAlignment'), settings.horizontalAlignment); } catch (e5) { /* null */ }
+  try { out.vertical_alignment = idcEnumName(IDC_V_ALIGNMENTS, idcEnumObject('VerticalAlignment'), settings.verticalAlignment); } catch (e6) { /* null */ }
+  try { out.offset_mm.x = IDC.round(Number(settings.anchorXoffset), 3); } catch (e7) { /* null */ }
+  try { out.offset_mm.y = IDC.round(Number(settings.anchorYoffset), 3); } catch (e8) { /* null */ }
+  try { out.keep_within_frame = settings.pinPosition === true; } catch (e9) { /* null */ }
+  try { out.lock_position = settings.lockPosition === true; } catch (e10) { /* null */ }
+  return out;
+}
+
+function idcOffsetArg(value, field) {
+  var out = { x: 0, y: 0 };
+  if (value === undefined || value === null) { return out; }
+  if (typeof value !== 'object') {
+    IDC.fail('invalid_argument', field + ' must be an object {x, y} in mm.', { field: field });
+  }
+  if (value.x !== undefined && value.x !== null) {
+    if (typeof value.x !== 'number' || !isFinite(value.x)) { IDC.fail('invalid_argument', field + '.x must be a number (mm).', { field: field }); }
+    out.x = value.x;
+  }
+  if (value.y !== undefined && value.y !== null) {
+    if (typeof value.y !== 'number' || !isFinite(value.y)) { IDC.fail('invalid_argument', field + '.y must be a number (mm).', { field: field }); }
+    out.y = value.y;
+  }
+  return out;
+}
+
+IDC.register('anchor_frame_in_text', { needs_document: true, read_only: false, ruler: 'page' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var found = idcFrameArg(doc, args, 'frame_id');
+    var item = found.item;
+    var target = idcTextFrameArg(doc, args, 'target_frame_id');
+    var story = idcStoryOf(target.item);
+    var position = args.position === undefined || args.position === null ? 'inline' : args.position;
+    var offset = idcOffsetArg(args.offset_mm, 'offset_mm');
+    var length = 0, index, insertionPoint, settings, anchoredItem = null, result, existing, landing, boundsMm = null;
+    var positionValue, value;
+
+    idcRejectGroupMember(item, args.frame_id, 'anchor_frame_in_text');
+    if (Number(item.id) === Number(target.item.id)) {
+      IDC.fail('invalid_argument', 'frame_id and target_frame_id must differ.', { frame_id: args.frame_id });
+    }
+    existing = idcAnchorInfo(item);
+    if (existing !== null) {
+      IDC.fail('invalid_state', 'Object ' + args.frame_id + ' is already anchored (story ' + existing.story_id + ', index ' + existing.index + '); use unanchor_frame first.',
+        { frame_id: args.frame_id, anchored: existing });
+    }
+    if (IDC.isTextFrame(item)) {
+      try {
+        if (Number(item.parentStory.id) === Number(story.id)) {
+          IDC.fail('invalid_state', 'The object is a frame of the target story itself.', { frame_id: args.frame_id });
+        }
+      } catch (e0) { if (e0 && e0.isIdcError) { throw e0; } }
+    }
+    try { length = Number(story.characters.length); } catch (e1) { length = 0; }
+    if (args.index === undefined || args.index === null) {
+      index = length;
+    } else {
+      if (typeof args.index !== 'number' || Math.floor(args.index) !== args.index || args.index < 0 || args.index > length) {
+        IDC.fail('invalid_argument', 'index must be a whole number from 0 to the story length (' + length + ').', { index: args.index, story_length: length });
+      }
+      index = args.index;
+    }
+    positionValue = idcEnumFor(IDC_ANCHOR_POSITIONS, idcEnumObject('AnchorPosition'), position, 'position');
+    if (positionValue === null) {
+      IDC.fail('invalid_state', 'This runtime has no AnchorPosition enumeration.', null);
+    }
+
+    try { insertionPoint = story.insertionPoints.item(index); } catch (e2) {
+      IDC.fail('script_error', 'InDesign could not address insertion point ' + index + '.', { index: index });
+    }
+    try {
+      settings = item.anchoredObjectSettings;
+      anchoredItem = settings.insertAnchoredObject(insertionPoint, positionValue);
+    } catch (e3) {
+      IDC.fail('script_error', 'InDesign could not anchor object ' + args.frame_id + ': ' + String(e3.message ? e3.message : e3),
+        { frame_id: args.frame_id, target_frame_id: args.target_frame_id, index: index });
+    }
+    if (anchoredItem === null || anchoredItem === undefined) { anchoredItem = item; }
+    anchoredItem = IDC.concrete(anchoredItem);
+    try { settings = anchoredItem.anchoredObjectSettings; } catch (e4) { settings = null; }
+
+    if (settings !== null && position === 'custom') {
+      try {
+        if (args.anchor_point !== undefined && args.anchor_point !== null) {
+          value = idcEnumFor(IDC_ANCHOR_POINTS, idcEnumObject('AnchorPoint'), args.anchor_point, 'anchor_point');
+          if (value !== null) { settings.anchorPoint = value; }
+        }
+        if (args.horizontal_reference !== undefined && args.horizontal_reference !== null) {
+          value = idcEnumFor(IDC_H_REFERENCES, idcEnumObject('AnchoredRelativeTo'), args.horizontal_reference, 'horizontal_reference');
+          if (value !== null) { settings.horizontalReferencePoint = value; }
+        }
+        if (args.vertical_reference !== undefined && args.vertical_reference !== null) {
+          value = idcEnumFor(IDC_V_REFERENCES, idcEnumObject('VerticallyRelativeTo'), args.vertical_reference, 'vertical_reference');
+          if (value !== null) { settings.verticalReferencePoint = value; }
+        }
+        if (args.horizontal_alignment !== undefined && args.horizontal_alignment !== null) {
+          value = idcEnumFor(IDC_H_ALIGNMENTS, idcEnumObject('HorizontalAlignment'), args.horizontal_alignment, 'horizontal_alignment');
+          if (value !== null) { settings.horizontalAlignment = value; }
+        }
+        if (args.vertical_alignment !== undefined && args.vertical_alignment !== null) {
+          value = idcEnumFor(IDC_V_ALIGNMENTS, idcEnumObject('VerticalAlignment'), args.vertical_alignment, 'vertical_alignment');
+          if (value !== null) { settings.verticalAlignment = value; }
+        }
+        settings.anchorXoffset = offset.x;
+        settings.anchorYoffset = offset.y;
+        if (args.keep_within_frame !== undefined && args.keep_within_frame !== null) { settings.pinPosition = args.keep_within_frame === true; }
+        if (args.lock_position !== undefined && args.lock_position !== null) { settings.lockPosition = args.lock_position === true; }
+      } catch (e5) {
+        if (e5 && e5.isIdcError) { throw e5; }
+        ctx.warn('Some anchored object settings could not be written: ' + String(e5.message ? e5.message : e5));
+      }
+    } else if (position !== 'custom' && (args.offset_mm !== undefined || args.anchor_point !== undefined || args.horizontal_reference !== undefined || args.vertical_reference !== undefined)) {
+      ctx.warn('offset_mm, anchor_point and the reference/alignment parameters apply to position "custom" only; ignored.');
+    }
+
+    landing = IDC.landing(anchoredItem);
+    try { boundsMm = idcItemBounds(doc, anchoredItem); } catch (e6) { boundsMm = null; }
+    result = {
+      frame_id: Number(anchoredItem.id),
+      previous_frame_id: Number(args.frame_id),
+      type: IDC.itemType(anchoredItem),
+      story_id: Number(story.id),
+      target_frame_id: Number(target.item.id),
+      index: index,
+      story_length: length + 1,
+      settings: idcDescribeAnchoredSettings(anchoredItem),
+      bounds_mm: boundsMm,
+      page_id: landing.page_id,
+      page_name: landing.page_name,
+      story_overset: idcOverflows(target.item)
+    };
+    try { result.story_overset = story.overflows === true; } catch (e7) { /* Rahmenwert bleibt */ }
+    if (Number(anchoredItem.id) !== Number(args.frame_id)) {
+      ctx.warn('InDesign gave the anchored object a new id (' + Number(anchoredItem.id) + '); use it from now on.');
+    }
+    if (result.story_overset === true) {
+      ctx.warn('The story overflows after anchoring (Übersatz) – the object may sit in the overset text.');
+    }
+    ctx.changes = { modified_frame_ids: [Number(anchoredItem.id), Number(target.item.id)] };
+    return result;
+  });
+
+IDC.register('unanchor_frame', { needs_document: true, read_only: false, ruler: 'page' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var found = idcFrameArg(doc, args, 'frame_id');
+    var item = found.item;
+    var info = idcAnchorInfo(item);
+    var released = null, landing, boundsMm = null, result;
+
+    if (info === null) {
+      IDC.fail('invalid_state', 'Object ' + args.frame_id + ' is not anchored in text.', { frame_id: args.frame_id });
+    }
+    /*
+     * Live 05.09.2026: releaseAnchoredObject() laesst inline und above_line
+     * still unveraendert (im Menue gibt es „Loesen“ nur fuer benutzerdefinierte
+     * Position). Deshalb erst auf custom umstellen, dann loesen.
+     */
+    try {
+      if (info.position !== 'custom' && typeof AnchorPosition !== 'undefined') {
+        item.anchoredObjectSettings.anchoredPosition = AnchorPosition.ANCHORED;
+      }
+      released = item.anchoredObjectSettings.releaseAnchoredObject();
+    } catch (e0) {
+      IDC.fail('script_error', 'InDesign could not release object ' + args.frame_id + ': ' + String(e0.message ? e0.message : e0), { frame_id: args.frame_id });
+    }
+    if (released === null || released === undefined) { released = item; }
+    released = IDC.concrete(released);
+    if (idcAnchorInfo(released) !== null) {
+      IDC.fail('invalid_state', 'InDesign did not release object ' + args.frame_id + '; it is still anchored.', { frame_id: args.frame_id, anchored: idcAnchorInfo(released) });
+    }
+    landing = IDC.landing(released);
+    try { boundsMm = idcItemBounds(doc, released); } catch (e1) { boundsMm = null; }
+    result = {
+      frame_id: Number(released.id),
+      previous_frame_id: Number(args.frame_id),
+      type: IDC.itemType(released),
+      was_anchored: info,
+      bounds_mm: boundsMm,
+      page_id: landing.page_id,
+      page_name: landing.page_name,
+      on_pasteboard: landing.on_pasteboard
+    };
+    if (Number(released.id) !== Number(args.frame_id)) {
+      ctx.warn('InDesign gave the released object a new id (' + Number(released.id) + '); use it from now on.');
+    }
+    ctx.changes = { modified_frame_ids: [Number(released.id)] };
+    return result;
+  });