layoutbridge-spm 0.0.1 → 1.0.0

package/indesign/commands/81-composition.js

@@ -0,0 +1,355 @@
+/*
+ * Auftrag A-7.1 bis A-7.3 (Sitzung 9) – Umbruchoptionen (Absatzkontrolle),
+ * Silbentrennungs- und Blocksatz-Abstandseinstellungen an Absatzformaten
+ * (define_paragraph_style) und Absaetzen (set_paragraph_options), gelesen
+ * von list_paragraph_styles und debug_inspect_run.
+ *
+ * DOM-Namen gegen Adobes Referenz (Klasse Text) geprueft am 05.09.2026:
+ * keepWithNext, keepFirstLines, keepLastLines, keepLinesTogether,
+ * keepAllLinesTogether, keepWithPrevious, startParagraph (StartParagraph);
+ * hyphenateWordsLongerThan, hyphenateAfterFirst, hyphenateBeforeLast,
+ * hyphenateLadderLimit, hyphenationZone, hyphenateCapitalizedWords,
+ * hyphenateLastWord, hyphenateAcrossColumns, hyphenWeight (0–10 am lebenden InDesign, Referenz sagt 0–100);
+ * minimum/desired/maximumWordSpacing (0–1000), ...LetterSpacing (-100–500),
+ * ...GlyphScaling (50–200), singleWordJustification
+ * (SingleWordJustification), composer (Zeichenkette), autoLeading (0–500).
+ * Alle Funktionen arbeiten gleich auf einem Format und auf einem Absatz.
+ */
+
+/* ------------------------------------------------------- Enumeratoren */
+
+var IDC_START_PARAGRAPH = [
+  ['anywhere', 'ANYWHERE'],
+  ['next_column', 'NEXT_COLUMN'],
+  ['next_frame', 'NEXT_FRAME'],
+  ['next_page', 'NEXT_PAGE'],
+  ['next_odd_page', 'NEXT_ODD_PAGE'],
+  ['next_even_page', 'NEXT_EVEN_PAGE']
+];
+
+var IDC_SINGLE_WORD = [
+  ['full', 'FULLY_JUSTIFIED'],
+  ['left', 'LEFT_ALIGN'],
+  ['center', 'CENTER_ALIGN'],
+  ['right', 'RIGHT_ALIGN']
+];
+
+function idcCompEnumFor(table, enumObject, enumName, value, field) {
+  var i;
+  if (typeof enumObject === 'undefined') {
+    IDC.fail('invalid_state', 'This runtime has no ' + enumName + ' enumeration.', null);
+  }
+  for (i = 0; i < table.length; i++) {
+    if (table[i][0] === value) { return enumObject[table[i][1]]; }
+  }
+  IDC.fail('invalid_argument', field + ' must be one of: ' + idcCompEnumNames(table) + '.', { value: value });
+  return null;
+}
+
+function idcCompEnumNames(table) {
+  var names = [];
+  var i;
+  for (i = 0; i < table.length; i++) { names.push(table[i][0]); }
+  return names.join(', ');
+}
+
+function idcCompEnumName(table, enumObject, value) {
+  var i;
+  if (idcIsNothing(value)) { return null; }
+  if (typeof enumObject === 'undefined') { return null; }
+  for (i = 0; i < table.length; i++) {
+    if (IDC.enumIs(value, enumObject[table[i][1]])) { return table[i][0]; }
+  }
+  return null;
+}
+
+/* ---------------------------------------------------------- Setzer */
+
+/*
+ * InDesign fuehrt den Setzer als lokalisierten Namen. Gesetzt wird ueber die
+ * bekannten Namen der Reihe nach, bis das Zuruecklesen die gewuenschte Art
+ * ergibt (Fallstrick wie bei "[Ohne]").
+ */
+var IDC_COMPOSER_NAMES = {
+  paragraph: ['Adobe Paragraph Composer', 'Adobe-Absatzsetzer', 'Adobe Absatzsetzer'],
+  /* Live 05.09.2026 (deutsches InDesign 21.5): "Adobe-Ein-Zeilen-Setzer"; "Adobe-Einzeilensetzer" wurde abgewiesen. */
+  single_line: ['Adobe Single-line Composer', 'Adobe-Ein-Zeilen-Setzer', 'Adobe Ein-Zeilen-Setzer', 'Adobe-Einzeilensetzer', 'Adobe Einzeilensetzer']
+};
+
+function idcComposerKind(text) {
+  var s;
+  if (text === null || text === undefined) { return null; }
+  s = String(text).toLowerCase();
+  if (s.indexOf('single') >= 0 || s.indexOf('einzeil') >= 0 || s.indexOf('ein-zeilen') >= 0) { return 'single_line'; }
+  if (s.indexOf('paragraph') >= 0 || s.indexOf('absatz') >= 0) { return 'paragraph'; }
+  return 'other';
+}
+
+function idcApplyComposer(target, kind, field) {
+  var names = IDC_COMPOSER_NAMES[kind];
+  var i, back;
+  if (!names) {
+    IDC.fail('invalid_argument', field + ' must be paragraph or single_line.', { value: kind });
+  }
+  for (i = 0; i < names.length; i++) {
+    try {
+      target.composer = names[i];
+      back = idcComposerKind(target.composer);
+      if (back === kind) { return names[i]; }
+    } catch (e) { /* naechster Name */ }
+  }
+  IDC.fail('invalid_state', 'InDesign accepted none of the known composer names for ' + kind + ': ' + names.join(', ') + '.',
+    { composer_read: (function () { try { return String(target.composer); } catch (e2) { return null; } })() });
+  return null;
+}
+
+/* ------------------------------------------------------- Argumente */
+
+function idcObjectArg(value, field) {
+  if (value === null || value === undefined) { return null; }
+  if (typeof value !== 'object' || IDC.isArray(value)) {
+    IDC.fail('invalid_argument', field + ' must be an object.', { value: value });
+  }
+  return value;
+}
+
+function idcOptBool(spec, key, field) {
+  if (!idcGiven(spec[key])) { return null; }
+  if (typeof spec[key] !== 'boolean') {
+    IDC.fail('invalid_argument', field + '.' + key + ' must be true or false.', { value: spec[key] });
+  }
+  return spec[key];
+}
+
+function idcOptNumber(spec, key, field, min, max, whole) {
+  var v;
+  if (!idcGiven(spec[key])) { return null; }
+  v = spec[key];
+  if (typeof v !== 'number' || !isFinite(v) || v < min || v > max || (whole && Math.floor(v) !== v)) {
+    IDC.fail('invalid_argument', field + '.' + key + ' must be a ' + (whole ? 'whole ' : '') + 'number between ' + min + ' and ' + max + '.', { value: v });
+  }
+  return v;
+}
+
+function idcSetProp(target, property, value, field) {
+  try {
+    target[property] = value;
+  } catch (e) {
+    IDC.fail('script_error', 'InDesign could not set ' + field + ' (' + property + '): ' + String(e.message ? e.message : e), { value: value });
+  }
+}
+
+/* ------------------------------------------------- Umbruchoptionen */
+
+function idcApplyKeepOptions(target, spec) {
+  var o = idcObjectArg(spec, 'keep_options');
+  var applied = [];
+  var v, probe;
+  if (o === null) { return applied; }
+
+  v = idcOptNumber(o, 'keep_with_next', 'keep_options', 0, 5, true);
+  if (v !== null) { idcSetProp(target, 'keepWithNext', v, 'keep_options.keep_with_next'); applied.push('keep_with_next'); }
+  v = idcOptBool(o, 'keep_lines_together', 'keep_options');
+  if (v !== null) { idcSetProp(target, 'keepLinesTogether', v, 'keep_options.keep_lines_together'); applied.push('keep_lines_together'); }
+  v = idcOptBool(o, 'keep_all_lines_together', 'keep_options');
+  if (v !== null) { idcSetProp(target, 'keepAllLinesTogether', v, 'keep_options.keep_all_lines_together'); applied.push('keep_all_lines_together'); }
+  v = idcOptNumber(o, 'keep_first_lines', 'keep_options', 1, 100, true);
+  if (v !== null) { idcSetProp(target, 'keepFirstLines', v, 'keep_options.keep_first_lines'); applied.push('keep_first_lines'); }
+  v = idcOptNumber(o, 'keep_last_lines', 'keep_options', 1, 100, true);
+  if (v !== null) { idcSetProp(target, 'keepLastLines', v, 'keep_options.keep_last_lines'); applied.push('keep_last_lines'); }
+  v = idcOptBool(o, 'keep_with_previous', 'keep_options');
+  if (v !== null) {
+    /* Erst ab InDesign CC; eine Laufzeit ohne die Eigenschaft meldet das. */
+    probe = undefined;
+    try { probe = target.keepWithPrevious; } catch (e) { probe = undefined; }
+    if (probe === undefined) {
+      IDC.fail('invalid_state', 'This InDesign version has no keepWithPrevious (Umbruchoptionen: Mit vorherigem zusammenhalten).', null);
+    }
+    idcSetProp(target, 'keepWithPrevious', v, 'keep_options.keep_with_previous');
+    applied.push('keep_with_previous');
+  }
+  if (idcGiven(o.start_paragraph)) {
+    idcSetProp(target, 'startParagraph',
+      idcCompEnumFor(IDC_START_PARAGRAPH, typeof StartParagraph === 'undefined' ? undefined : StartParagraph, 'StartParagraph', o.start_paragraph, 'keep_options.start_paragraph'),
+      'keep_options.start_paragraph');
+    applied.push('start_paragraph');
+  }
+  return applied;
+}
+
+function idcReadKeepOptions(target) {
+  var start = null;
+  try { start = idcCompEnumName(IDC_START_PARAGRAPH, typeof StartParagraph === 'undefined' ? undefined : StartParagraph, target.startParagraph); } catch (e) { start = null; }
+  return {
+    keep_with_next: idcReadNumberLoose(target, 'keepWithNext', 0),
+    keep_first_lines: idcReadNumberLoose(target, 'keepFirstLines', 0),
+    keep_last_lines: idcReadNumberLoose(target, 'keepLastLines', 0),
+    keep_lines_together: idcReadBoolLoose(target, 'keepLinesTogether'),
+    keep_all_lines_together: idcReadBoolLoose(target, 'keepAllLinesTogether'),
+    keep_with_previous: idcReadBoolLoose(target, 'keepWithPrevious'),
+    start_paragraph: start
+  };
+}
+
+/* ---------------------------------------------- Silbentrennung */
+
+function idcApplyHyphenationOptions(target, spec) {
+  var o = idcObjectArg(spec, 'hyphenation_options');
+  var applied = [];
+  var v;
+  if (o === null) { return applied; }
+
+  v = idcOptNumber(o, 'words_longer_than', 'hyphenation_options', 3, 25, true);
+  if (v !== null) { idcSetProp(target, 'hyphenateWordsLongerThan', v, 'hyphenation_options.words_longer_than'); applied.push('words_longer_than'); }
+  v = idcOptNumber(o, 'after_first', 'hyphenation_options', 1, 15, true);
+  if (v !== null) { idcSetProp(target, 'hyphenateAfterFirst', v, 'hyphenation_options.after_first'); applied.push('after_first'); }
+  v = idcOptNumber(o, 'before_last', 'hyphenation_options', 1, 15, true);
+  if (v !== null) { idcSetProp(target, 'hyphenateBeforeLast', v, 'hyphenation_options.before_last'); applied.push('before_last'); }
+  v = idcOptNumber(o, 'ladder_limit', 'hyphenation_options', 0, 25, true);
+  if (v !== null) { idcSetProp(target, 'hyphenateLadderLimit', v, 'hyphenation_options.ladder_limit'); applied.push('ladder_limit'); }
+  v = idcOptNumber(o, 'zone_mm', 'hyphenation_options', 0, 300, false);
+  if (v !== null) { idcSetProp(target, 'hyphenationZone', v, 'hyphenation_options.zone_mm'); applied.push('zone_mm'); }
+  v = idcOptBool(o, 'capitalized_words', 'hyphenation_options');
+  if (v !== null) { idcSetProp(target, 'hyphenateCapitalizedWords', v, 'hyphenation_options.capitalized_words'); applied.push('capitalized_words'); }
+  v = idcOptBool(o, 'last_word', 'hyphenation_options');
+  if (v !== null) { idcSetProp(target, 'hyphenateLastWord', v, 'hyphenation_options.last_word'); applied.push('last_word'); }
+  v = idcOptBool(o, 'across_columns', 'hyphenation_options');
+  if (v !== null) { idcSetProp(target, 'hyphenateAcrossColumns', v, 'hyphenation_options.across_columns'); applied.push('across_columns'); }
+  /* Live 05.09.2026: InDesign 21.5 verlangt 0–10 ("Short Integer (0 - 10) erwartet") – nicht 0–100 wie in Adobes Referenz. */
+  v = idcOptNumber(o, 'weight', 'hyphenation_options', 0, 10, true);
+  if (v !== null) { idcSetProp(target, 'hyphenWeight', v, 'hyphenation_options.weight'); applied.push('weight'); }
+  return applied;
+}
+
+function idcReadHyphenationOptions(target) {
+  return {
+    words_longer_than: idcReadNumberLoose(target, 'hyphenateWordsLongerThan', 0),
+    after_first: idcReadNumberLoose(target, 'hyphenateAfterFirst', 0),
+    before_last: idcReadNumberLoose(target, 'hyphenateBeforeLast', 0),
+    ladder_limit: idcReadNumberLoose(target, 'hyphenateLadderLimit', 0),
+    zone_mm: idcReadNumberLoose(target, 'hyphenationZone', 3),
+    capitalized_words: idcReadBoolLoose(target, 'hyphenateCapitalizedWords'),
+    last_word: idcReadBoolLoose(target, 'hyphenateLastWord'),
+    across_columns: idcReadBoolLoose(target, 'hyphenateAcrossColumns'),
+    weight: idcReadNumberLoose(target, 'hyphenWeight', 0)
+  };
+}
+
+/* ------------------------------------------------- Blocksatz */
+
+/*
+ * Ein Tripel {min, desired, max} setzen. InDesign verlangt min <= desired
+ * <= max zu jedem Zeitpunkt; deshalb erst das Zielbild aus Ist und Wunsch
+ * bilden, pruefen, dann in einer Reihenfolge schreiben, die nie dagegen
+ * verstoesst (sinkende Werte von unten, steigende von oben).
+ */
+function idcApplyTriple(target, spec, key, field, props, min, max, applied) {
+  var o = idcObjectArg(spec[key], field + '.' + key);
+  var current, wanted, order, i, name;
+  if (o === null) { return; }
+  current = {
+    min: idcReadNumberLoose(target, props[0], 3),
+    desired: idcReadNumberLoose(target, props[1], 3),
+    max: idcReadNumberLoose(target, props[2], 3)
+  };
+  wanted = {
+    min: idcOptNumber(o, 'min', field + '.' + key, min, max, false),
+    desired: idcOptNumber(o, 'desired', field + '.' + key, min, max, false),
+    max: idcOptNumber(o, 'max', field + '.' + key, min, max, false)
+  };
+  if (wanted.min === null && wanted.desired === null && wanted.max === null) {
+    IDC.fail('invalid_argument', field + '.' + key + ' needs at least one of min, desired, max.', { value: o });
+  }
+  if (wanted.min === null) { wanted.min = current.min; }
+  if (wanted.desired === null) { wanted.desired = current.desired; }
+  if (wanted.max === null) { wanted.max = current.max; }
+  if (wanted.min !== null && wanted.desired !== null && wanted.max !== null
+    && !(wanted.min <= wanted.desired && wanted.desired <= wanted.max)) {
+    IDC.fail('invalid_argument', field + '.' + key + ' must satisfy min <= desired <= max (after merging with the current values).',
+      { current: current, wanted: wanted });
+  }
+  if (current.desired !== null && wanted.desired !== null && wanted.desired < current.desired) {
+    order = ['min', 'desired', 'max'];
+  } else {
+    order = ['max', 'desired', 'min'];
+  }
+  for (i = 0; i < order.length; i++) {
+    name = order[i];
+    if (wanted[name] === null) { continue; }
+    idcSetProp(target, props[name === 'min' ? 0 : (name === 'desired' ? 1 : 2)], wanted[name], field + '.' + key + '.' + name);
+  }
+  applied.push(key);
+}
+
+function idcApplyJustificationOptions(target, spec) {
+  var o = idcObjectArg(spec, 'justification_options');
+  var applied = [];
+  var v;
+  if (o === null) { return applied; }
+
+  idcApplyTriple(target, o, 'word_spacing', 'justification_options',
+    ['minimumWordSpacing', 'desiredWordSpacing', 'maximumWordSpacing'], 0, 1000, applied);
+  idcApplyTriple(target, o, 'letter_spacing', 'justification_options',
+    ['minimumLetterSpacing', 'desiredLetterSpacing', 'maximumLetterSpacing'], -100, 500, applied);
+  idcApplyTriple(target, o, 'glyph_scaling', 'justification_options',
+    ['minimumGlyphScaling', 'desiredGlyphScaling', 'maximumGlyphScaling'], 50, 200, applied);
+  if (idcGiven(o.single_word_justification)) {
+    idcSetProp(target, 'singleWordJustification',
+      idcCompEnumFor(IDC_SINGLE_WORD, typeof SingleWordJustification === 'undefined' ? undefined : SingleWordJustification, 'SingleWordJustification', o.single_word_justification, 'justification_options.single_word_justification'),
+      'justification_options.single_word_justification');
+    applied.push('single_word_justification');
+  }
+  if (idcGiven(o.composer)) {
+    idcApplyComposer(target, o.composer, 'justification_options.composer');
+    applied.push('composer');
+  }
+  v = idcOptNumber(o, 'auto_leading_percent', 'justification_options', 0, 500, false);
+  if (v !== null) { idcSetProp(target, 'autoLeading', v, 'justification_options.auto_leading_percent'); applied.push('auto_leading_percent'); }
+  return applied;
+}
+
+function idcReadTriple(target, props) {
+  return {
+    min: idcReadNumberLoose(target, props[0], 3),
+    desired: idcReadNumberLoose(target, props[1], 3),
+    max: idcReadNumberLoose(target, props[2], 3)
+  };
+}
+
+function idcReadJustificationOptions(target) {
+  var composerRaw = null;
+  try { composerRaw = idcIsNothing(target.composer) ? null : String(target.composer); } catch (e) { composerRaw = null; }
+  return {
+    word_spacing: idcReadTriple(target, ['minimumWordSpacing', 'desiredWordSpacing', 'maximumWordSpacing']),
+    letter_spacing: idcReadTriple(target, ['minimumLetterSpacing', 'desiredLetterSpacing', 'maximumLetterSpacing']),
+    glyph_scaling: idcReadTriple(target, ['minimumGlyphScaling', 'desiredGlyphScaling', 'maximumGlyphScaling']),
+    single_word_justification: idcCompEnumName(IDC_SINGLE_WORD, typeof SingleWordJustification === 'undefined' ? undefined : SingleWordJustification,
+      (function () { try { return target.singleWordJustification; } catch (e2) { return null; } })()),
+    composer: idcComposerKind(composerRaw),
+    composer_name: composerRaw,
+    auto_leading_percent: idcReadNumberLoose(target, 'autoLeading', 3)
+  };
+}
+
+/* ------------------------------------------------ gemeinsam */
+
+function idcCompositionGiven(args) {
+  return idcGiven(args.keep_options) || idcGiven(args.hyphenation_options) || idcGiven(args.justification_options);
+}
+
+/* Alle drei Gruppen auf ein Format oder einen Absatz anwenden; liefert die Gruppennamen, die etwas gesetzt haben. */
+function idcApplyCompositionOptions(target, args) {
+  var applied = [];
+  if (idcApplyKeepOptions(target, args.keep_options).length > 0) { applied.push('keep_options'); }
+  if (idcApplyHyphenationOptions(target, args.hyphenation_options).length > 0) { applied.push('hyphenation_options'); }
+  if (idcApplyJustificationOptions(target, args.justification_options).length > 0) { applied.push('justification_options'); }
+  return applied;
+}
+
+function idcReadCompositionOptions(target) {
+  return {
+    keep_options: idcReadKeepOptions(target),
+    hyphenation_options: idcReadHyphenationOptions(target),
+    justification_options: idcReadJustificationOptions(target)
+  };
+}

package/indesign/commands/82-object-styles.js

@@ -0,0 +1,263 @@
+/* Wunschliste J Nr. 5 (Sitzung 8) – Objektformate: list_object_styles, apply_object_style. */
+
+var IDC_OBJECT_STYLE_FLAGS = [
+  ['fill', 'enableFill'],
+  ['stroke', 'enableStroke'],
+  ['stroke_and_corner', 'enableStrokeAndCornerOptions'],
+  ['transform', 'enableTransformAttributes'],
+  ['text_frame_general', 'enableTextFrameGeneralOptions'],
+  ['text_frame_baseline', 'enableTextFrameBaselineOptions'],
+  ['text_frame_auto_sizing', 'enableTextFrameAutoSizingOptions'],
+  ['paragraph_style', 'enableParagraphStyle'],
+  ['story_options', 'enableStoryOptions'],
+  ['text_wrap_and_others', 'enableTextWrapAndOthers'],
+  ['anchored_object', 'enableAnchoredObjectOptions'],
+  ['frame_fitting', 'enableFrameFittingOptions']
+];
+
+function idcObjectStyleGroupPath(style) {
+  var names = [];
+  var current, name, step;
+  try { current = style.parent; } catch (e) { return ''; }
+  for (step = 0; step < 12; step++) {
+    if (current === null || current === undefined) { break; }
+    name = IDC.className(current);
+    if (name === 'ObjectStyleGroup') {
+      try { names.unshift(String(current.name)); } catch (e2) { break; }
+      try { current = current.parent; } catch (e3) { break; }
+    } else {
+      break;
+    }
+  }
+  return names.join('/');
+}
+
+function idcAllObjectStyles(doc) {
+  var all = null, out = [], i;
+  try { all = doc.allObjectStyles; } catch (e0) { all = null; }
+  if (all !== null && all !== undefined) {
+    for (i = 0; i < all.length; i++) { out.push(all[i]); }
+    return out;
+  }
+  try {
+    for (i = 0; i < doc.objectStyles.length; i++) { out.push(doc.objectStyles.item(i)); }
+  } catch (e1) { /* leer */ }
+  return out;
+}
+
+function idcObjectStyleByName(doc, name) {
+  var style = null, all, i;
+  try {
+    style = doc.objectStyles.itemByName(name);
+    if (style && style.isValid === true) { return style; }
+  } catch (e0) { /* weiter */ }
+  all = idcAllObjectStyles(doc);
+  for (i = 0; i < all.length; i++) {
+    try { if (String(all[i].name) === String(name)) { return all[i]; } } catch (e1) { /* naechstes */ }
+  }
+  return null;
+}
+
+function idcObjectStyleNames(doc) {
+  var all = idcAllObjectStyles(doc), out = [], i;
+  for (i = 0; i < all.length; i++) {
+    try { out.push(String(all[i].name)); } catch (e) { /* ohne */ }
+  }
+  return out;
+}
+
+function idcDescribeObjectStyle(style) {
+  var out = {
+    style_id: null,
+    name: null,
+    group_path: idcObjectStyleGroupPath(style),
+    based_on: idcBasedOnName(style),
+    built_in: false,
+    applies: {},
+    fill_color: null,
+    stroke_color: null,
+    stroke_weight_pt: null,
+    paragraph_style: null
+  };
+  var i, flag;
+  try { out.style_id = Number(style.id); } catch (e0) { /* null */ }
+  try { out.name = String(style.name); } catch (e1) { /* null */ }
+  out.built_in = out.name !== null && out.name.charAt(0) === '[';
+  for (i = 0; i < IDC_OBJECT_STYLE_FLAGS.length; i++) {
+    flag = IDC_OBJECT_STYLE_FLAGS[i];
+    out.applies[flag[0]] = idcReadBoolLoose(style, flag[1]);
+  }
+  if (out.applies.fill === true) {
+    out.fill_color = idcReadSwatchName(style, 'fillColor');
+  }
+  if (out.applies.stroke === true) {
+    out.stroke_color = idcReadSwatchName(style, 'strokeColor');
+    try { out.stroke_weight_pt = IDC.inPoints(function () { return IDC.round(Number(style.strokeWeight), 3); }); } catch (e2) { out.stroke_weight_pt = null; }
+  }
+  if (out.applies.paragraph_style === true) {
+    try { out.paragraph_style = String(style.appliedParagraphStyle.name); } catch (e3) { out.paragraph_style = null; }
+  }
+  /*
+   * Sitzung 10 (Kleinigkeit aus Sitzung 9): die uebrigen Kategorien, jeweils
+   * nur wenn das Format sie setzt. Adobe-DOM ObjectStyle (geprueft
+   * 05.09.2026): fillTint, strokeTint, strokeType, strokeAlignment,
+   * topLeftCornerOption/-Radius usw., textFramePreferences,
+   * textWrapPreferences, transparencySettings, anchoredObjectSettings,
+   * frameFittingOptions, storyPreferences, overprintFill, gapColor.
+   */
+  out.fill_tint_percent = null;
+  out.stroke_tint_percent = null;
+  out.stroke_type = null;
+  out.overprint_fill = null;
+  out.corners = null;
+  out.text_frame = null;
+  out.text_wrap = null;
+  out.effects = null;
+  out.anchored = null;
+  out.frame_fitting = null;
+  out.story = null;
+  if (out.applies.fill === true) {
+    out.fill_tint_percent = idcTintValue(style, 'fillTint');
+    try { out.overprint_fill = style.overprintFill === true; } catch (e4) { out.overprint_fill = null; }
+  }
+  if (out.applies.stroke === true) {
+    out.stroke_tint_percent = idcTintValue(style, 'strokeTint');
+    try { out.stroke_type = String(style.strokeType.name); } catch (e5) { out.stroke_type = null; }
+  }
+  if (out.applies.stroke_and_corner === true) {
+    try { out.corners = idcReadCorners(style); } catch (e6) { out.corners = null; }
+  }
+  if (out.applies.text_frame_general === true || out.applies.text_frame_baseline === true) {
+    try {
+      var text = idcTextFrameOptions(null, style);
+      out.text_frame = {
+        columns: text.columns,
+        inset_mm: text.inset_mm,
+        vertical_justification: text.vertical_justification,
+        vertical_threshold_mm: text.vertical_threshold_mm,
+        first_baseline_offset: text.first_baseline_offset,
+        min_first_baseline_pt: text.min_first_baseline_pt,
+        ignore_text_wrap: text.ignore_text_wrap
+      };
+    } catch (e7) { out.text_frame = null; }
+  }
+  if (out.applies.text_wrap_and_others === true) {
+    try { out.text_wrap = idcTextWrapOptions(style); } catch (e8) { out.text_wrap = null; }
+    try { out.effects = idcReadEffects(idcEffectSettings(style, 'object')); } catch (e9) { out.effects = null; }
+  }
+  if (out.applies.anchored_object === true) {
+    try { out.anchored = idcDescribeAnchoredSettings(style); } catch (e10) { out.anchored = null; }
+  }
+  if (out.applies.frame_fitting === true) {
+    out.frame_fitting = idcReadFrameFitting(style);
+  }
+  if (out.applies.story_options === true) {
+    try {
+      var storyPrefs = { storyPreferences: style.storyPreferences };
+      out.story = idcReadStoryOptions(storyPrefs);
+    } catch (e11) { out.story = null; }
+  }
+  return out;
+}
+
+/* Farbton eines Formats: -1 heisst „nicht gesetzt“ (geerbt). */
+function idcTintValue(style, property) {
+  var value;
+  try { value = Number(style[property]); } catch (e) { return null; }
+  if (isNaN(value) || value < 0) { return null; }
+  return IDC.round(value, 2);
+}
+
+function idcEmptyFrameFittingName(value) {
+  if (typeof EmptyFrameFittingOptions === 'undefined') { return String(value); }
+  if (IDC.enumIs(value, EmptyFrameFittingOptions.NONE)) { return 'none'; }
+  if (IDC.enumIs(value, EmptyFrameFittingOptions.PROPORTIONALLY)) { return 'proportionally'; }
+  if (IDC.enumIs(value, EmptyFrameFittingOptions.FILL_PROPORTIONALLY)) { return 'fill_proportionally'; }
+  if (IDC.enumIs(value, EmptyFrameFittingOptions.CONTENT_TO_FRAME)) { return 'content_to_frame'; }
+  return String(value);
+}
+
+function idcReadFrameFitting(style) {
+  var out = { on_empty_frame: null, auto_fit: null, crop_mm: null };
+  var options = null;
+  try { options = style.frameFittingOptions; } catch (e0) { return out; }
+  if (options === null || options === undefined) { return out; }
+  try { out.on_empty_frame = idcEmptyFrameFittingName(options.fittingOnEmptyFrame); } catch (e1) { /* null */ }
+  try { out.auto_fit = options.autoFit === true; } catch (e2) { /* null */ }
+  try {
+    out.crop_mm = { top: IDC.round(Number(options.topCrop)), left: IDC.round(Number(options.leftCrop)), bottom: IDC.round(Number(options.bottomCrop)), right: IDC.round(Number(options.rightCrop)) };
+  } catch (e3) { out.crop_mm = null; }
+  return out;
+}
+
+function idcAppliedObjectStyleName(item) {
+  try { return String(item.appliedObjectStyle.name); } catch (e) { return null; }
+}
+
+IDC.register('list_object_styles', { needs_document: true, read_only: true, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var includeBuiltIn = args.include_built_in !== false;
+    var all = idcAllObjectStyles(doc);
+    var out = [], excluded = 0, i, entry;
+    for (i = 0; i < all.length; i++) {
+      entry = idcDescribeObjectStyle(all[i]);
+      if (entry.built_in && !includeBuiltIn) { excluded += 1; continue; }
+      out.push(entry);
+    }
+    return { styles: out, count: out.length, built_in_excluded: excluded, include_built_in: includeBuiltIn };
+  });
+
+IDC.register('apply_object_style', { 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 clearOverrides = args.clear_overrides !== false;
+    var style, before, after, boundsBefore, boundsAfter, out;
+
+    if (typeof args.style_name !== 'string' || args.style_name === '') {
+      IDC.fail('invalid_argument', 'style_name is required (exact object style name, see list_object_styles).', null);
+    }
+    style = idcObjectStyleByName(doc, args.style_name);
+    if (style === null) {
+      IDC.fail('not_found', 'No object style named "' + args.style_name + '" in this document.',
+        { style_name: args.style_name, available: idcObjectStyleNames(doc) });
+    }
+
+    before = idcAppliedObjectStyleName(item);
+    boundsBefore = idcItemBounds(doc, item);
+    try {
+      item.applyObjectStyle(style, clearOverrides);
+    } catch (e0) {
+      IDC.fail('script_error', 'InDesign could not apply object style "' + args.style_name + '" to object ' + args.frame_id + ': ' + String(e0.message ? e0.message : e0),
+        { frame_id: args.frame_id, style_name: args.style_name });
+    }
+    after = idcAppliedObjectStyleName(item);
+    boundsAfter = idcItemBounds(doc, item);
+    if (after !== String(style.name)) {
+      ctx.warn('InDesign reports object style "' + String(after) + '" after applying "' + args.style_name + '".');
+    }
+
+    out = {
+      frame_id: Number(item.id),
+      type: IDC.itemType(item),
+      style_name: after,
+      style_id: null,
+      previous_style_name: before,
+      clear_overrides: clearOverrides,
+      changed: before !== after || clearOverrides,
+      bounds_mm: boundsAfter,
+      bounds_changed: IDC.stringify(boundsBefore) !== IDC.stringify(boundsAfter),
+      appearance: idcAppearance(item),
+      overset: IDC.isTextFrame(item) ? idcOverflows(item) : null
+    };
+    try { out.style_id = Number(style.id); } catch (e1) { /* null */ }
+    if (out.overset === true) {
+      ctx.warn('The text frame overflows after applying the object style (Übersatz).');
+    }
+    ctx.changes = { modified_frame_ids: [Number(item.id)] };
+    return out;
+  });