layoutbridge-light 0.0.0-stage → 1.0.0

package/indesign/commands/86-gradients.js

@@ -0,0 +1,185 @@
+/*
+ * Auftrag A-8.4 (Sitzung 9) – create_gradient_swatch: Verlaufsfarbfeld
+ * anlegen, das an Flaechen und Konturen per fill_swatch_name /
+ * stroke_swatch_name verwendet wird. Adobe-DOM (Auftrag, geprueft
+ * 05.09.2026): Gradients.add(withProperties) -> Gradient {name, type
+ * (GradientType.LINEAR|RADIAL), gradientStops}; GradientStops.add() ->
+ * GradientStop {stopColor (Swatch-Objekt), location 0–100, midpoint 13–87}.
+ * Ob ein neuer Verlauf schon zwei Stopps traegt: live pruefen (Journal).
+ */
+
+function idcGradientTypeFor(name) {
+  if (typeof GradientType === 'undefined') {
+    IDC.fail('invalid_state', 'This runtime has no GradientType enumeration.', null);
+  }
+  if (name === 'linear') { return GradientType.LINEAR; }
+  if (name === 'radial') { return GradientType.RADIAL; }
+  IDC.fail('invalid_argument', 'type must be linear or radial.', { type: name });
+  return null;
+}
+
+function idcGradientTypeName(value) {
+  if (value === null || value === undefined || typeof GradientType === 'undefined') { return null; }
+  if (IDC.enumIs(value, GradientType.LINEAR)) { return 'linear'; }
+  if (IDC.enumIs(value, GradientType.RADIAL)) { return 'radial'; }
+  return String(value);
+}
+
+/* Stopps eines Verlaufs lesen: [{index, swatch_name, location, midpoint}]. */
+function idcReadGradientStops(gradient) {
+  var out = [], stops, i, stop, entry;
+  try { stops = gradient.gradientStops; } catch (e0) { return out; }
+  for (i = 0; i < stops.length; i++) {
+    entry = { index: i, swatch_name: null, location: null, midpoint: null };
+    try { stop = stops.item(i); } catch (e1) { continue; }
+    try { entry.swatch_name = String(stop.stopColor.name); } catch (e2) { /* null */ }
+    try { entry.location = IDC.round(Number(stop.location), 3); } catch (e3) { /* null */ }
+    try { entry.midpoint = IDC.round(Number(stop.midpoint), 3); } catch (e4) { /* null */ }
+    out.push(entry);
+  }
+  return out;
+}
+
+/* Stopp-Angabe pruefen und das Farbfeld dafuer beschaffen (Name, Hex oder CMYK). */
+function idcGradientStopArg(doc, spec, index, gradientName, created) {
+  var ways = 0, swatch = null, kind, hexName;
+  if (spec === null || typeof spec !== 'object' || IDC.isArray(spec)) {
+    IDC.fail('invalid_argument', 'stops[' + index + '] must be an object {swatch_name | hex | cmyk, location, midpoint}.', { value: spec });
+  }
+  if (idcGiven(spec.swatch_name)) { ways += 1; }
+  if (idcGiven(spec.hex)) { ways += 1; }
+  if (idcGiven(spec.cmyk)) { ways += 1; }
+  if (ways !== 1) {
+    IDC.fail('invalid_argument', 'stops[' + index + '] needs exactly one of swatch_name, hex or cmyk.', { value: spec });
+  }
+  if (typeof spec.location !== 'number' || !isFinite(spec.location) || spec.location < 0 || spec.location > 100) {
+    IDC.fail('invalid_argument', 'stops[' + index + '].location must be a number between 0 and 100.', { value: spec.location });
+  }
+  if (idcGiven(spec.midpoint) && (typeof spec.midpoint !== 'number' || !isFinite(spec.midpoint) || spec.midpoint < 13 || spec.midpoint > 87)) {
+    IDC.fail('invalid_argument', 'stops[' + index + '].midpoint must be a number between 13 and 87.', { value: spec.midpoint });
+  }
+  if (idcGiven(spec.swatch_name)) {
+    swatch = idcSwatchArg(doc, spec.swatch_name, 'stops[' + index + '].swatch_name');
+    kind = idcSwatchKind(swatch);
+    if (kind !== 'color' && kind !== 'tint') {
+      IDC.fail('invalid_argument', 'stops[' + index + '].swatch_name must be a colour or tint swatch, not a ' + kind + '.', { swatch_name: spec.swatch_name, kind: kind });
+    }
+  } else if (idcGiven(spec.hex)) {
+    swatch = idcSwatchForHex(doc, spec.hex, 'stops[' + index + '].hex', created);
+  } else {
+    hexName = gradientName + ' Stopp ' + (index + 1);
+    swatch = idcSwatchByName(doc, hexName);
+    if (swatch === null) {
+      try {
+        swatch = doc.colors.add({ name: hexName, model: ColorModel.PROCESS, space: ColorSpace.CMYK, colorValue: idcCmykArg(spec.cmyk) });
+        created.push(Number(swatch.id));
+      } catch (e) {
+        IDC.fail('script_error', 'InDesign could not create the stop swatch "' + hexName + '": ' + String(e.message ? e.message : e), { name: hexName });
+      }
+    } else {
+      try { swatch.colorValue = idcCmykArg(spec.cmyk); } catch (e2) { /* Werte bleiben */ }
+    }
+  }
+  return { swatch: swatch, location: spec.location, midpoint: idcGiven(spec.midpoint) ? spec.midpoint : null };
+}
+
+/* Stopps in den Verlauf schreiben: vorhandene setzen, fehlende anlegen, ueberzaehlige entfernen. */
+function idcWriteGradientStops(gradient, stops) {
+  var collection = gradient.gradientStops;
+  var i, stop, count;
+  for (i = 0; i < stops.length; i++) {
+    try { count = Number(collection.length); } catch (e0) { count = 0; }
+    if (i < count) { stop = collection.item(i); }
+    else { stop = collection.add(); }
+    stop.stopColor = stops[i].swatch;
+    stop.location = stops[i].location;
+    if (stops[i].midpoint !== null) { stop.midpoint = stops[i].midpoint; }
+  }
+  try { count = Number(collection.length); } catch (e1) { count = stops.length; }
+  while (count > stops.length) {
+    try { collection.item(count - 1).remove(); } catch (e2) { break; }
+    count -= 1;
+  }
+}
+
+IDC.register('create_gradient_swatch', { needs_document: true, read_only: false, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var name = args.name;
+    var typeName = idcGiven(args.type) ? String(args.type) : 'linear';
+    var onCollision = idcCollisionArg(args.on_collision);
+    var created = [];
+    var stops = [], i, existing, existed, collision = 'none', chosenName, gradient = null, className, previous = null;
+
+    if (typeof name !== 'string' || name.length < 1 || name.length > 60) {
+      IDC.fail('invalid_argument', 'name is required (1–60 characters).', { name: name });
+    }
+    if (name.charAt(0) === '[') {
+      IDC.fail('invalid_argument', 'name must not start with "[".', { name: name });
+    }
+    idcGradientTypeFor(typeName);
+    if (!IDC.isArray(args.stops) || args.stops.length < 2 || args.stops.length > 20) {
+      IDC.fail('invalid_argument', 'stops must be an array of 2 to 20 entries in order.', { count: IDC.isArray(args.stops) ? args.stops.length : null });
+    }
+    for (i = 0; i < args.stops.length; i++) {
+      stops.push(idcGradientStopArg(doc, args.stops[i], i, name, created));
+      if (i > 0 && stops[i].location < stops[i - 1].location) {
+        IDC.fail('invalid_argument', 'stops must be in ascending order of location (stop ' + i + ' is at ' + stops[i].location + ', the one before at ' + stops[i - 1].location + ').', null);
+      }
+    }
+    if (stops[0].location !== 0) { ctx.warn('The first stop is at ' + stops[0].location + ' %, not 0 % – the gradient starts with a flat area.'); }
+    if (stops[stops.length - 1].location !== 100) { ctx.warn('The last stop is at ' + stops[stops.length - 1].location + ' %, not 100 % – the gradient ends with a flat area.'); }
+
+    chosenName = name;
+    existing = idcSwatchByName(doc, name);
+    existed = idcPresent(existing);
+    if (existed) {
+      className = IDC.className(existing);
+      if (onCollision === 'error') {
+        IDC.fail('invalid_state', 'Swatch "' + name + '" exists already (' + className + '). Pass on_collision "update" to change it or "version" to add "' + name + ' 2".',
+          { name: name, swatch_id: (function () { try { return Number(existing.id); } catch (e) { return null; } })() });
+      }
+      if (onCollision === 'update') {
+        if (className !== 'Gradient') {
+          IDC.fail('invalid_state', 'Swatch "' + name + '" is a ' + className + ', not a gradient; it cannot be updated with stops.', { name: name, type: className });
+        }
+        gradient = existing;
+        collision = 'updated';
+        previous = { type: idcGradientTypeName(gradient.type), stops: idcReadGradientStops(gradient) };
+      } else {
+        chosenName = idcFreeName(doc, name, 'swatch');
+        collision = 'versioned';
+      }
+    }
+    if (gradient === null) {
+      try {
+        gradient = doc.gradients.add({ name: chosenName, type: idcGradientTypeFor(typeName) });
+      } catch (e2) {
+        IDC.fail('script_error', 'InDesign could not create the gradient "' + chosenName + '": ' + String(e2.message ? e2.message : e2), { name: chosenName });
+      }
+    } else {
+      try { gradient.type = idcGradientTypeFor(typeName); } catch (e3) { /* Art bleibt */ }
+    }
+    try {
+      idcWriteGradientStops(gradient, stops);
+    } catch (e4) {
+      IDC.fail('script_error', 'InDesign could not write the gradient stops of "' + chosenName + '": ' + String(e4.message ? e4.message : e4), { name: chosenName });
+    }
+
+    var changes = { created_swatch_ids: created.slice() };
+    if (collision === 'updated') { changes.modified_swatch_ids = [Number(gradient.id)]; }
+    else { changes.created_swatch_ids.push(Number(gradient.id)); }
+    ctx.changes = changes;
+    return {
+      name: String(gradient.name),
+      swatch_id: Number(gradient.id),
+      type: idcGradientTypeName(gradient.type),
+      stops: idcReadGradientStops(gradient),
+      stop_count: idcReadGradientStops(gradient).length,
+      collision: collision,
+      existed: existed,
+      previous: previous,
+      swatch_ids: created
+    };
+  });

package/indesign/commands/87-replace-swatch.js

@@ -0,0 +1,180 @@
+/*
+ * Auftrag A-9.2 (Sitzung 9) – replace_swatch: alle Verwendungen eines
+ * Farbfelds auf ein anderes umstellen und das alte entfernen (InDesign
+ * "Farbfeld loeschen ... ersetzen durch"). Adobe-DOM (geprueft 05.09.2026):
+ * Swatch.remove(replacingWith) – InDesign stellt Flaechen, Konturen, Text,
+ * Formate, Tabellen und Verlaeufe selbst um. Ohne delete_old: Text ueber
+ * die Suchen/Ersetzen-Klammer (FindTextPreference.fillColor), Objekte
+ * ueber allPageItems, Absatz- und Zeichenformate direkt; Objektformate,
+ * Tabellenformate und Verlaufsstopps bleiben dann beim alten Feld (Warnung).
+ * Verlaufsfarbfelder (A-8.4) sind als Quelle und Ziel zulaessig: InDesign
+ * ersetzt sie wie Farben; ein Verlauf als Ziel eines Textlaufs ist ein
+ * Verlaufstext.
+ */
+
+function idcSwatchRef(doc, args, nameKey, idKey, what) {
+  var hasName = idcGiven(args[nameKey]);
+  var hasId = idcGiven(args[idKey]);
+  var swatch = null, i, list;
+  if (hasName === hasId) {
+    IDC.fail('invalid_argument', 'Pass exactly one of ' + nameKey + ' and ' + idKey + ' for the ' + what + ' swatch.', null);
+  }
+  if (hasName) {
+    swatch = idcSwatchByName(doc, args[nameKey]);
+    if (swatch === null) {
+      IDC.fail('not_found', 'Swatch "' + args[nameKey] + '" not found – names are exact (see list_swatches).', { swatch_name: args[nameKey] });
+    }
+    return swatch;
+  }
+  try {
+    list = doc.swatches;
+    for (i = 0; i < list.length; i++) {
+      if (Number(list.item(i).id) === Number(args[idKey])) { return list.item(i); }
+    }
+  } catch (e) { /* nicht gefunden */ }
+  IDC.fail('not_found', 'No swatch with ' + idKey + ' ' + args[idKey] + ' (see list_swatches).', { swatch_id: args[idKey] });
+  return null;
+}
+
+function idcDescribeSwatchShort(swatch) {
+  var out = { name: null, swatch_id: null, kind: null, space: null, values: [] };
+  try { out.name = String(swatch.name); } catch (e0) { /* null */ }
+  try { out.swatch_id = Number(swatch.id); } catch (e1) { /* null */ }
+  out.kind = idcSwatchKind(swatch);
+  try { out.space = idcColorSpaceName(swatch.space); } catch (e2) { out.space = null; }
+  try { out.values = idcNumberList(swatch.colorValue); } catch (e3) { out.values = []; }
+  return out;
+}
+
+function idcSwatchIs(value, swatch) {
+  try { return value !== null && value !== undefined && Number(value.id) === Number(swatch.id); } catch (e) { return false; }
+}
+
+/* Verwendungen eines Farbfelds zaehlen; Tabellen werden nicht gezaehlt (null). */
+function idcSwatchUsage(doc, swatch, args) {
+  var out = { text_runs: 0, fills: 0, strokes: 0, paragraph_styles: 0, character_styles: 0, object_styles: 0, tables: null, gradients: 0 };
+  var items, i, item, styles, found;
+  try { items = doc.allPageItems; } catch (e0) { items = []; }
+  for (i = 0; i < items.length; i++) {
+    item = IDC.concrete(items[i]);
+    try { if (idcSwatchIs(item.fillColor, swatch)) { out.fills += 1; } } catch (e1) { /* kein fillColor */ }
+    try { if (idcSwatchIs(item.strokeColor, swatch)) { out.strokes += 1; } } catch (e2) { /* kein strokeColor */ }
+  }
+  styles = idcAllStyles(doc, 'paragraph');
+  for (i = 0; i < styles.length; i++) { try { if (idcSwatchIs(styles[i].fillColor, swatch)) { out.paragraph_styles += 1; } } catch (e3) { /* weiter */ } }
+  styles = idcAllStyles(doc, 'character');
+  for (i = 0; i < styles.length; i++) { try { if (idcSwatchIs(styles[i].fillColor, swatch)) { out.character_styles += 1; } } catch (e4) { /* weiter */ } }
+  try {
+    for (i = 0; i < doc.allObjectStyles.length; i++) {
+      item = doc.allObjectStyles[i];
+      try { if (item.enableFill === true && idcSwatchIs(item.fillColor, swatch)) { out.object_styles += 1; } } catch (e5) { /* weiter */ }
+      try { if (item.enableStroke === true && idcSwatchIs(item.strokeColor, swatch)) { out.object_styles += 1; } } catch (e6) { /* weiter */ }
+    }
+  } catch (e7) { /* keine Objektformate */ }
+  idcEachIn(doc, 'gradients', function (gradient) {
+    var stops, k;
+    try {
+      stops = gradient.gradientStops;
+      for (k = 0; k < stops.length; k++) { if (idcSwatchIs(stops.item(k).stopColor, swatch)) { out.gradients += 1; } }
+    } catch (e8) { /* weiter */ }
+  });
+  /* Textlaeufe ueber die Suche (dry run): fillColor in findTextPreferences. */
+  try {
+    app.findTextPreferences = NothingEnum.NOTHING;
+    app.changeTextPreferences = NothingEnum.NOTHING;
+    idcSetFindOptions(app.findChangeTextOptions, { include_master_pages: true, include_hidden_layers: true, include_locked_layers: args.include_locked_layers === true });
+    app.findTextPreferences.fillColor = swatch;
+    found = doc.findText();
+    out.text_runs = found.length;
+  } catch (e9) {
+    out.text_runs = null;
+  } finally {
+    try { app.findTextPreferences = NothingEnum.NOTHING; } catch (e10) { /* egal */ }
+    try { app.changeTextPreferences = NothingEnum.NOTHING; } catch (e11) { /* egal */ }
+  }
+  return out;
+}
+
+/* Verwendungen ohne Loeschen umstellen (delete_old false). */
+function idcReassignSwatch(ctx, doc, oldSwatch, newSwatch, args) {
+  var items, i, item, styles, changed = { text_runs: 0, fills: 0, strokes: 0, paragraph_styles: 0, character_styles: 0 };
+  try { items = doc.allPageItems; } catch (e0) { items = []; }
+  for (i = 0; i < items.length; i++) {
+    item = IDC.concrete(items[i]);
+    try { if (idcSwatchIs(item.fillColor, oldSwatch)) { item.fillColor = newSwatch; changed.fills += 1; } } catch (e1) { /* weiter */ }
+    try { if (idcSwatchIs(item.strokeColor, oldSwatch)) { item.strokeColor = newSwatch; changed.strokes += 1; } } catch (e2) { /* weiter */ }
+  }
+  styles = idcAllStyles(doc, 'paragraph');
+  for (i = 0; i < styles.length; i++) { try { if (idcSwatchIs(styles[i].fillColor, oldSwatch)) { styles[i].fillColor = newSwatch; changed.paragraph_styles += 1; } } catch (e3) { /* weiter */ } }
+  styles = idcAllStyles(doc, 'character');
+  for (i = 0; i < styles.length; i++) { try { if (idcSwatchIs(styles[i].fillColor, oldSwatch)) { styles[i].fillColor = newSwatch; changed.character_styles += 1; } } catch (e4) { /* weiter */ } }
+  try {
+    app.findTextPreferences = NothingEnum.NOTHING;
+    app.changeTextPreferences = NothingEnum.NOTHING;
+    idcSetFindOptions(app.findChangeTextOptions, { include_master_pages: true, include_hidden_layers: true, include_locked_layers: args.include_locked_layers === true });
+    app.findTextPreferences.fillColor = oldSwatch;
+    app.changeTextPreferences.fillColor = newSwatch;
+    changed.text_runs = doc.changeText().length;
+  } catch (e5) {
+    ctx.warn('Text runs could not be changed by search: ' + String(e5.message ? e5.message : e5));
+  } finally {
+    try { app.findTextPreferences = NothingEnum.NOTHING; } catch (e6) { /* egal */ }
+    try { app.changeTextPreferences = NothingEnum.NOTHING; } catch (e7) { /* egal */ }
+  }
+  return changed;
+}
+
+IDC.register('replace_swatch', { needs_document: true, read_only: false, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var deleteOld = args.delete_old !== false;
+    var dryRun = args.dry_run === true;
+    var oldSwatch = idcSwatchRef(doc, args, 'old_name', 'old_swatch_id', 'old');
+    var newSwatch = idcSwatchRef(doc, args, 'new_name', 'new_swatch_id', 'new');
+    var oldInfo = idcDescribeSwatchShort(oldSwatch);
+    var newInfo = idcDescribeSwatchShort(newSwatch);
+    var usage, deleted = false, reassigned = null, remaining = null;
+
+    if (oldInfo.name === null || oldInfo.name.charAt(0) === '[' || oldInfo.name === 'None' || oldInfo.name === 'Paper' || oldInfo.name === 'Black' || oldInfo.name === 'Registration') {
+      IDC.fail('invalid_argument', 'Built-in swatch "' + oldInfo.name + '" cannot be replaced.', { old: oldInfo });
+    }
+    if (oldInfo.swatch_id === newInfo.swatch_id) {
+      IDC.fail('invalid_argument', 'old and new name the same swatch "' + oldInfo.name + '".', { old: oldInfo });
+    }
+    if (oldInfo.space !== null && newInfo.space !== null && oldInfo.space !== newInfo.space) {
+      ctx.warn('Colour space changes from ' + oldInfo.space + ' to ' + newInfo.space + ' – this is no colour management; the printed colour may differ. Check the values with list_swatches.');
+    }
+    usage = idcSwatchUsage(doc, oldSwatch, args);
+    if (usage.text_runs === null) { ctx.warn('Text runs could not be counted by search; the other counts are complete.'); }
+
+    if (!dryRun) {
+      if (deleteOld) {
+        try {
+          oldSwatch.remove(newSwatch);
+          deleted = true;
+        } catch (e) {
+          IDC.fail('invalid_state', 'InDesign refused to remove swatch "' + oldInfo.name + '" (used as a base for a mixed ink or gradient?): ' + String(e.message ? e.message : e), { old: oldInfo });
+        }
+      } else {
+        reassigned = idcReassignSwatch(ctx, doc, oldSwatch, newSwatch, args);
+        if (usage.object_styles > 0 || usage.gradients > 0) {
+          ctx.warn('Without delete_old, ' + usage.object_styles + ' object style use(s) and ' + usage.gradients + ' gradient stop(s) keep the old swatch; table styles are not checked. Use delete_old true to let InDesign replace everything.');
+        }
+      }
+      ctx.changes = { modified_document_ids: [Number(doc.id)] };
+      if (deleted) { ctx.changes.removed_swatch_ids = [oldInfo.swatch_id]; }
+    }
+    try { remaining = Number(doc.swatches.length); } catch (e2) { remaining = null; }
+    /* "new" ist in ExtendScript auch als Eigenschaftsname verboten (Live-Fund 05.09.2026) – deshalb ueber die Klammer. */
+    var out = {
+      old: oldInfo,
+      deleted: deleted,
+      usage_before: usage,
+      reassigned: reassigned,
+      remaining_swatches: remaining,
+      dry_run: dryRun
+    };
+    out['new'] = newInfo;
+    return out;
+  });

package/indesign/commands/88-replace-font.js

@@ -0,0 +1,212 @@
+/*
+ * Auftrag A-9.1 (Sitzung 9) – replace_font: eine Schrift dokumentweit
+ * ersetzen (InDesign "Schrift suchen/ersetzen") – in Absatz- und
+ * Zeichenformaten und in lokaler Formatierung, auf Dokument- und
+ * Musterseiten. Lokale Laeufe werden ueber story.textStyleRanges gelesen
+ * und je Lauf ueber appliedFont gesetzt (dieselbe Mechanik wie
+ * find_font_usage); die Zielschrift muss installiert sein. Adobe-DOM
+ * (geprueft 05.09.2026): FindTextPreference.appliedFont/fontStyle waeren
+ * der andere Weg; der Lauf ueber die Formatlaeufe zaehlt und lokalisiert
+ * dabei gleich und braucht keine Suchklammer.
+ */
+
+/* Zielschrift: installiert? Liefert { object, family, style } oder wirft not_found. Gezielt aufgeloest, nicht ueber die ganze Schriftliste (A-59, E-105). */
+function idcTargetFont(fonts, family, style) {
+  var name = String(family) + '\t' + String(style);
+  var found = fonts.find(family, style);
+  if (found === null) {
+    IDC.fail('not_found', 'Target font "' + family + ' ' + style + '" is not installed.', { to_family: family, to_style: style, available_styles: fonts.stylesOf(family) });
+  }
+  return { object: found.object, family: String(family), style: String(style), name: name };
+}
+
+function idcStoryLocked(doc, story) {
+  var containers, i, layer;
+  try { containers = story.textContainers; } catch (e0) { return false; }
+  for (i = 0; i < containers.length; i++) {
+    try { layer = containers[i].itemLayer; if (layer && layer.locked === true) { return true; } } catch (e1) { /* weiter */ }
+  }
+  return false;
+}
+
+/* Bezieht ein Lauf seine Schrift aus einem Absatz- oder Zeichenformat, das ersetzt wird? */
+function idcRunFontFromChangedStyle(range, font, stylesChanged) {
+  var i, style, styleFont, name;
+  var candidates = [];
+  try { candidates.push(range.appliedCharacterStyle); } catch (e0) { /* keins */ }
+  try { candidates.push(range.appliedParagraphStyle); } catch (e1) { /* keins */ }
+  for (i = 0; i < candidates.length; i++) {
+    style = candidates[i];
+    if (style === null || style === undefined) { continue; }
+    try { name = String(style.name); } catch (e2) { continue; }
+    styleFont = idcReadFontLoose(style);
+    if (styleFont.family === null || !idcSameFamily(styleFont.family, font.family)) { continue; }
+    if (styleFont.style !== null && font.style !== null && !idcSameText(styleFont.style, font.style)) { continue; }
+    if (idcStyleInList(stylesChanged, name)) { return true; }
+  }
+  return false;
+}
+
+function idcStyleInList(list, name) {
+  var i;
+  for (i = 0; i < list.length; i++) { if (list[i].name === name) { return true; } }
+  return false;
+}
+
+function idcSetFontOn(target, font) {
+  if (font.object !== null) { target.appliedFont = font.object; }
+  else { target.appliedFont = font.name; }
+}
+
+IDC.register('replace_font', { needs_document: true, read_only: false, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var fromFamily = args.from_family;
+    var fromStyle = idcGiven(args.from_style) ? String(args.from_style) : null;
+    var toFamily = args.to_family;
+    var toStyle = idcGiven(args.to_style) ? String(args.to_style) : null;
+    var scope = idcGiven(args.scope) ? String(args.scope) : 'all';
+    var includeMasters = args.include_master_pages !== false;
+    var includeLocked = args.include_locked_layers === true;
+    var dryRun = args.dry_run === true;
+    var fonts, targets = {}, missingStyles = [], stylesChanged = [], runsChanged = 0, charsChanged = 0, storiesTouched = 0;
+    var skippedLocked = [], oversetStories = [], remaining = 0, remainingWhere = [];
+    var kinds, k, styles, i, font, s, story, storyId, ranges, r, range, touched, length, target, styleName;
+
+    if (typeof fromFamily !== 'string' || fromFamily === '') { IDC.fail('invalid_argument', 'from_family is required.', null); }
+    if (typeof toFamily !== 'string' || toFamily === '') { IDC.fail('invalid_argument', 'to_family is required.', null); }
+    if (scope !== 'all' && scope !== 'styles_only' && scope !== 'local_only') {
+      IDC.fail('invalid_argument', 'scope must be all, styles_only or local_only.', { scope: scope });
+    }
+    if (fromStyle === null && toStyle !== null) {
+      IDC.fail('invalid_argument', 'to_style needs from_style; without from_style every style of the family is replaced by the same style name in the target family.', null);
+    }
+    if (fromStyle !== null && toStyle === null) { toStyle = fromStyle; }
+    if (idcSameFamily(fromFamily, toFamily) && (fromStyle === null || idcSameText(fromStyle, toStyle))) {
+      IDC.fail('invalid_argument', 'from and to name the same font.', { from_family: fromFamily, to_family: toFamily });
+    }
+    fonts = idcFontLookup();
+    if (!fonts.hasFamily(toFamily)) {
+      IDC.fail('not_found', 'Target font family "' + toFamily + '" is not installed.', { to_family: toFamily, available_styles: [] });
+    }
+    if (fromStyle !== null) { targets[fromStyle.toLowerCase()] = idcTargetFont(fonts, toFamily, toStyle); }
+
+    /* Zielschnitt je Quellschnitt: gleicher Name in der Zielfamilie, sonst Warnung und Auslassen. */
+    function targetFor(styleOfRun) {
+      var key = styleOfRun === null ? '' : String(styleOfRun).toLowerCase();
+      if (fromStyle !== null && !idcSameText(styleOfRun, fromStyle)) { return null; }
+      if (IDC.hasOwn(targets, key)) { return targets[key]; }
+      if (fonts.find(toFamily, styleOfRun) === null) {
+        if (!idcInList(missingStyles, String(styleOfRun))) { missingStyles.push(String(styleOfRun)); }
+        targets[key] = null;
+        return null;
+      }
+      targets[key] = idcTargetFont(fonts, toFamily, styleOfRun);
+      return targets[key];
+    }
+
+    /* Formate. */
+    if (scope !== 'local_only') {
+      kinds = ['paragraph', 'character'];
+      for (k = 0; k < kinds.length; k++) {
+        styles = idcAllStyles(doc, kinds[k]);
+        for (i = 0; i < styles.length; i++) {
+          font = idcReadFontLoose(styles[i]);
+          if (font.family === null || !idcSameFamily(font.family, fromFamily)) { continue; }
+          target = targetFor(font.style);
+          if (target === null) { continue; }
+          try { styleName = String(styles[i].name); } catch (e0) { styleName = ''; }
+          if (!dryRun) {
+            try { idcSetFontOn(styles[i], target); } catch (e1) {
+              IDC.fail('script_error', 'InDesign could not set the font of style "' + styleName + '": ' + String(e1.message ? e1.message : e1), { style: styleName });
+            }
+          }
+          stylesChanged.push({ kind: kinds[k], name: styleName, from_style: font.style, to_style: target.style });
+        }
+      }
+    }
+
+    /* Lokale Laeufe. */
+    if (scope !== 'styles_only') {
+      for (s = 0; s < doc.stories.length; s++) {
+        story = doc.stories.item(s);
+        try { storyId = Number(story.id); } catch (e2) { storyId = null; }
+        if (!includeMasters && idcStoryOnMaster(story)) { continue; }
+        if (!includeLocked && idcStoryLocked(doc, story)) { skippedLocked.push(storyId); continue; }
+        touched = false;
+        try { ranges = story.textStyleRanges; } catch (e3) { continue; }
+        for (r = 0; r < ranges.length; r++) {
+          try { range = ranges.item(r); } catch (e4) { continue; }
+          font = idcReadFontLoose(range);
+          if (font.family === null || !idcSameFamily(font.family, fromFamily)) { continue; }
+          target = targetFor(font.style);
+          if (target === null) { continue; }
+          /* dry_run: Laeufe, die ihre Schrift nur aus einem Format beziehen, das schon in styles_changed steht, zaehlen nicht (der echte Lauf aendert erst die Formate). */
+          if (dryRun && idcRunFontFromChangedStyle(range, font, stylesChanged)) { continue; }
+          try { length = Number(range.characters.length); } catch (e5) { length = 0; }
+          if (!dryRun) {
+            try { idcSetFontOn(range, target); } catch (e6) {
+              IDC.fail('script_error', 'InDesign could not set the font of a text run in story ' + storyId + ': ' + String(e6.message ? e6.message : e6), { story_id: storyId });
+            }
+          }
+          runsChanged += 1;
+          charsChanged += length;
+          touched = true;
+        }
+        if (touched) {
+          storiesTouched += 1;
+          if (!dryRun) { try { if (story.overflows === true) { oversetStories.push(storyId); } } catch (e7) { /* egal */ } }
+        }
+      }
+    }
+
+    /* Nachkontrolle: was von der Ausgangsschrift noch da ist (gesperrte Ebenen, Formate bei local_only ...). */
+    if (!dryRun) {
+      for (s = 0; s < doc.stories.length; s++) {
+        story = doc.stories.item(s);
+        try { ranges = story.textStyleRanges; } catch (e8) { continue; }
+        for (r = 0; r < ranges.length; r++) {
+          try { range = ranges.item(r); font = idcReadFontLoose(range); } catch (e9) { continue; }
+          if (font.family !== null && idcSameFamily(font.family, fromFamily) && (fromStyle === null || idcSameText(font.style, fromStyle))) {
+            remaining += 1;
+            if (remainingWhere.length < 20) {
+              try { remainingWhere.push({ story_id: Number(story.id), index: Number(range.characters.item(0).index), style: font.style }); } catch (e10) { /* auslassen */ }
+            }
+          }
+        }
+      }
+      if (remaining > 0) {
+        ctx.warn(remaining + ' run(s) still use "' + fromFamily + '" (locked layers, tables, anchored objects, a style outside the scope, or a style name missing in the target family) – see remaining_where.');
+      }
+      if (oversetStories.length > 0) {
+        ctx.warn(oversetStories.length + ' story/stories overflow after the change – InDesign recomposed every paragraph; check get_frame_lines.');
+      }
+      if (stylesChanged.length + runsChanged > 0) { ctx.changes = { modified_document_ids: [Number(doc.id)] }; }
+    }
+    for (i = 0; i < missingStyles.length; i++) {
+      ctx.warn('Style "' + missingStyles[i] + '" does not exist in "' + toFamily + '"; runs and styles with it were left alone. Available: ' + fonts.stylesOf(toFamily).join(', ') + '.');
+    }
+    if (skippedLocked.length > 0) {
+      ctx.warn(skippedLocked.length + ' story/stories on locked layers were skipped (include_locked_layers true to change them).');
+    }
+    if (stylesChanged.length + runsChanged === 0) {
+      ctx.warn('"' + fromFamily + (fromStyle === null ? '' : ' ' + fromStyle) + '" is not used in the given scope; nothing to replace.');
+    }
+
+    return {
+      from: { family: String(fromFamily), style: fromStyle },
+      to: { family: String(toFamily), style: toStyle },
+      scope: scope,
+      styles_changed: stylesChanged,
+      runs_changed: runsChanged,
+      characters_changed: charsChanged,
+      stories_touched: storiesTouched,
+      remaining_occurrences: dryRun ? null : remaining,
+      remaining_where: remainingWhere,
+      skipped_locked: skippedLocked,
+      styles_missing_in_target: missingStyles,
+      overset_stories: oversetStories,
+      dry_run: dryRun
+    };
+  });