layoutbridge-spm 0.0.1 → 1.0.0

package/indesign/commands/20-documents.js

@@ -0,0 +1,513 @@
+/* Bereich A – Dokumente. */
+
+/* Pfad eines Dokuments, leer wenn nie gespeichert. */
+function idcDocumentPath(doc) {
+  try {
+    if (doc.saved) { return IDC.fsPath(doc.fullName); }
+  } catch (e) { /* leer */ }
+  return '';
+}
+
+/* Fehlende und veraltete Verknuepfungen sowie fehlende Schriften. */
+function idcDocumentIssues(doc) {
+  var missingLinks = [];
+  var outOfDateLinks = [];
+  var missingFonts = [];
+  var i, link, font, name;
+
+  try {
+    for (i = 0; i < doc.links.length; i++) {
+      link = doc.links.item(i);
+      if (IDC.enumIs(link.status, LinkStatus.LINK_MISSING)) {
+        missingLinks.push(String(link.name));
+      } else if (IDC.enumIs(link.status, LinkStatus.LINK_OUT_OF_DATE)) {
+        outOfDateLinks.push(String(link.name));
+      }
+    }
+  } catch (e1) { /* Liste bleibt so weit, wie sie kam */ }
+
+  try {
+    for (i = 0; i < doc.fonts.length; i++) {
+      font = doc.fonts.item(i);
+      if (!IDC.enumIs(font.status, FontStatus.INSTALLED)) {
+        name = String(font.name);
+        missingFonts.push(name);
+      }
+    }
+  } catch (e2) { /* dito */ }
+
+  return {
+    missing_links: missingLinks,
+    out_of_date_links: outOfDateLinks,
+    missing_fonts: missingFonts
+  };
+}
+
+IDC.register('list_documents', { needs_document: false, read_only: true, ruler: 'none' },
+  function () {
+    var documents = [];
+    var activeId = null;
+    var i, doc, isActive;
+
+    /*
+     * Ueber die ID vergleichen, nicht ueber equals(): equals() lieferte am
+     * lebenden Dokument false, obwohl nur ein Dokument offen war.
+     */
+    try {
+      if (app.documents.length > 0) { activeId = Number(app.activeDocument.id); }
+    } catch (e) { activeId = null; }
+
+    for (i = 0; i < app.documents.length; i++) {
+      doc = app.documents.item(i);
+      isActive = false;
+      try {
+        if (activeId !== null) { isActive = Number(doc.id) === activeId; }
+      } catch (e2) { isActive = false; }
+      documents.push({
+        document_id: Number(doc.id),
+        name: String(doc.name),
+        saved: doc.saved === true,
+        path: idcDocumentPath(doc),
+        page_count: doc.pages.length,
+        is_active: isActive
+      });
+    }
+    return { documents: documents, count: documents.length };
+  });
+
+IDC.register('open_document', { needs_document: false, read_only: false, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    if (typeof args.path !== 'string' || args.path.length === 0) {
+      IDC.fail('invalid_argument', 'path is required and must be a file path.', null);
+    }
+
+    var file = IDC.fileFor(args.path);
+    if (!file.exists) {
+      IDC.fail('not_found', 'File does not exist: ' + args.path, { path: args.path });
+    }
+    var wantedPath = IDC.fsPath(file);
+
+    var isTemplate = /\.indt$/i.test(args.path);
+    var openCopy = args.open_copy === true || (args.open_copy !== false && isTemplate);
+
+    /*
+     * Schon offen? Dann nicht doppelt oeffnen – ausser jemand will ausdruecklich
+     * eine Kopie: die ist ein neues, unbenanntes Dokument und kollidiert mit
+     * nichts.
+     */
+    var i, candidate, doc = null;
+    if (!openCopy) {
+      for (i = 0; i < app.documents.length; i++) {
+        candidate = app.documents.item(i);
+        if (idcDocumentPath(candidate) === wantedPath && wantedPath !== '') {
+          doc = candidate;
+          break;
+        }
+      }
+    }
+
+    var alreadyOpen = doc !== null;
+    if (!alreadyOpen) {
+      var showWindow = args.show_window === false ? false : true;
+      var openOption = openCopy ? OpenOptions.OPEN_COPY : OpenOptions.OPEN_ORIGINAL;
+      try {
+        doc = app.open(file, showWindow, openOption);
+      } catch (e) {
+        IDC.fail('io_error', 'InDesign could not open the file: ' + String(e.message ? e.message : e),
+          { path: args.path });
+      }
+      if (IDC.isArray(doc)) { doc = doc[0]; }
+    } else {
+      ctx.warn('Document was already open; it was not opened a second time.');
+    }
+
+    var issues = idcDocumentIssues(doc);
+    if (issues.missing_links.length > 0) {
+      ctx.warn('Missing links (fehlende Verknuepfungen): ' + issues.missing_links.join(', '));
+    }
+    if (issues.out_of_date_links.length > 0) {
+      ctx.warn('Out of date links (veraltete Verknuepfungen): ' + issues.out_of_date_links.join(', '));
+    }
+    if (issues.missing_fonts.length > 0) {
+      ctx.warn('Missing fonts (fehlende Schriften): ' + issues.missing_fonts.join(', '));
+    }
+
+    ctx.changes = { opened_document_ids: alreadyOpen ? [] : [Number(doc.id)] };
+
+    return {
+      document_id: Number(doc.id),
+      name: String(doc.name),
+      page_count: doc.pages.length,
+      facing_pages: doc.documentPreferences.facingPages === true,
+      already_open: alreadyOpen,
+      path: idcDocumentPath(doc),
+      missing_links: issues.missing_links,
+      out_of_date_links: issues.out_of_date_links,
+      missing_fonts: issues.missing_fonts
+    };
+  });
+
+IDC.register('close_document', { needs_document: true, read_only: false, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+
+    if (args.save_changes !== 'yes' && args.save_changes !== 'no') {
+      IDC.fail('invalid_argument',
+        'save_changes is required and must be "yes" or "no" (InDesign save dialogs are suppressed).',
+        { save_changes: args.save_changes === undefined ? null : String(args.save_changes) });
+    }
+
+    var documentId = Number(doc.id);
+    var name = String(doc.name);
+    var hadUnsavedChanges = doc.modified === true;
+    var currentPath = idcDocumentPath(doc);
+    var savedTo = '';
+    var target = null;
+
+    if (args.save_changes === 'yes') {
+      if (typeof args.path === 'string' && args.path.length > 0) {
+        target = IDC.fileFor(args.path);
+        savedTo = String(args.path);
+      } else if (currentPath === '') {
+        IDC.fail('invalid_argument',
+          'This document has never been saved; path is required when save_changes is "yes".', null);
+      } else {
+        savedTo = currentPath;
+      }
+    }
+
+    try {
+      if (args.save_changes === 'yes') {
+        if (target !== null) { doc.close(SaveOptions.YES, target); }
+        else { doc.close(SaveOptions.YES); }
+      } else {
+        doc.close(SaveOptions.NO);
+      }
+    } catch (e) {
+      IDC.fail('io_error', 'InDesign could not close the document: ' + String(e.message ? e.message : e),
+        { document_id: documentId });
+    }
+
+    var remaining = [];
+    var i;
+    for (i = 0; i < app.documents.length; i++) {
+      remaining.push(Number(app.documents.item(i).id));
+    }
+
+    ctx.changes = { closed_document_ids: [documentId] };
+
+    return {
+      document_id: documentId,
+      name: name,
+      saved_to: savedTo,
+      had_unsaved_changes: hadUnsavedChanges,
+      remaining_document_ids: remaining
+    };
+  });
+
+/* ------------------------------------------------------- create_document */
+
+var IDC_PAGE_PRESETS = {
+  A4: { width: 210, height: 297 },
+  Letter: { width: 215.9, height: 279.4 },
+  Legal: { width: 215.9, height: 355.6 },
+  Tabloid: { width: 279.4, height: 431.8 }
+};
+
+function idcIsNumber(value) {
+  return typeof value === 'number' && isFinite(value);
+}
+
+/* Seitenformat aus preset oder width_mm/height_mm, Ausrichtung beachten. */
+function idcPageSize(args) {
+  var width = null;
+  var height = null;
+  var preset;
+  var swap;
+
+  if (args.preset !== undefined && args.preset !== null) {
+    preset = IDC_PAGE_PRESETS[String(args.preset)];
+    if (!preset) {
+      IDC.fail('invalid_argument', 'preset must be one of A4, Letter, Legal, Tabloid.',
+        { preset: String(args.preset) });
+    }
+    width = preset.width;
+    height = preset.height;
+  }
+  if (idcIsNumber(args.width_mm)) { width = args.width_mm; }
+  if (idcIsNumber(args.height_mm)) { height = args.height_mm; }
+  if (width === null || height === null) {
+    IDC.fail('invalid_argument', 'Pass preset or both width_mm and height_mm.', null);
+  }
+  if (width <= 0 || height <= 0) {
+    IDC.fail('invalid_argument', 'width_mm and height_mm must be greater than 0.',
+      { width_mm: width, height_mm: height });
+  }
+
+  if (args.orientation === 'landscape') { swap = width < height; }
+  else if (args.orientation === 'portrait' || args.orientation === undefined) { swap = args.orientation === 'portrait' && width > height; }
+  else {
+    IDC.fail('invalid_argument', 'orientation must be "portrait" or "landscape".',
+      { orientation: String(args.orientation) });
+  }
+  if (swap) { return { width: height, height: width }; }
+  return { width: width, height: height };
+}
+
+/*
+ * Stege. InDesign kennt in der Skriptschnittstelle nur left/right; bei
+ * Doppelseiten bedeutet left "innen" und right "aussen" (Bund- und
+ * Aussensteg). inside/outside werden deshalb darauf abgebildet.
+ */
+function idcMargins(spec, facing, ctx) {
+  var out = { top: null, bottom: null, left: null, right: null };
+  var hasLR, hasIO;
+
+  if (!spec || typeof spec !== 'object') {
+    IDC.fail('invalid_argument',
+      'margins_mm is required: { top, bottom, left, right } or { top, bottom, inside, outside }.', null);
+  }
+  hasLR = idcIsNumber(spec.left) && idcIsNumber(spec.right);
+  hasIO = idcIsNumber(spec.inside) && idcIsNumber(spec.outside);
+  if (!idcIsNumber(spec.top) || !idcIsNumber(spec.bottom) || (!hasLR && !hasIO)) {
+    IDC.fail('invalid_argument',
+      'margins_mm needs top, bottom and either left/right or inside/outside, all numbers.', spec);
+  }
+  out.top = spec.top;
+  out.bottom = spec.bottom;
+  if (hasIO) {
+    out.left = spec.inside;
+    out.right = spec.outside;
+    if (!facing) { ctx.warn('inside/outside given for single pages: inside is used as left, outside as right.'); }
+  } else {
+    out.left = spec.left;
+    out.right = spec.right;
+    if (facing) { ctx.warn('left/right given for facing pages: left is the inside margin (Bundsteg), right the outside margin.'); }
+  }
+  var k;
+  for (k in out) {
+    if (IDC.hasOwn(out, k) && out[k] < 0) {
+      IDC.fail('invalid_argument', 'margins_mm.' + k + ' must not be negative.', spec);
+    }
+  }
+  return out;
+}
+
+function idcApplyMargins(target, margins, columns) {
+  var prefs = target.marginPreferences;
+  prefs.top = margins.top;
+  prefs.bottom = margins.bottom;
+  prefs.left = margins.left;
+  prefs.right = margins.right;
+  if (columns !== null) {
+    prefs.columnCount = columns.count;
+    prefs.columnGutter = columns.gutter_mm;
+  }
+}
+
+IDC.register('create_document', { needs_document: false, read_only: false, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var size = idcPageSize(args);
+    var facing = args.facing_pages === undefined ? true : args.facing_pages === true;
+    var pages = args.pages === undefined ? 1 : args.pages;
+    var columns = null;
+    var margins;
+    var doc, prefs, i, j, spread, page;
+    var pageIds = [];
+
+    if (!idcIsNumber(pages) || pages < 1 || Math.floor(pages) !== pages || pages > 9999) {
+      IDC.fail('invalid_argument', 'pages must be a whole number from 1 to 9999.', { pages: args.pages });
+    }
+    margins = idcMargins(args.margins_mm, facing, ctx);
+    if (args.columns !== undefined && args.columns !== null) {
+      if (typeof args.columns !== 'object' || !idcIsNumber(args.columns.count) || args.columns.count < 1) {
+        IDC.fail('invalid_argument', 'columns must be { count, gutter_mm } with count >= 1.', args.columns);
+      }
+      columns = {
+        count: Math.floor(args.columns.count),
+        gutter_mm: idcIsNumber(args.columns.gutter_mm) ? args.columns.gutter_mm : 4.233
+      };
+    }
+
+    try {
+      doc = app.documents.add();
+    } catch (e) {
+      IDC.fail('script_error', 'InDesign could not create a document: ' + String(e.message ? e.message : e), null);
+    }
+
+    try {
+      prefs = doc.documentPreferences;
+      prefs.facingPages = facing;
+      prefs.pageWidth = size.width;
+      prefs.pageHeight = size.height;
+      prefs.pagesPerDocument = pages;
+
+      /* Vorgabe fuer kuenftige Seiten, dann Musterseiten, dann die Seiten selbst. */
+      idcApplyMargins(doc, margins, columns);
+      for (i = 0; i < doc.masterSpreads.length; i++) {
+        spread = doc.masterSpreads.item(i);
+        for (j = 0; j < spread.pages.length; j++) {
+          idcApplyMargins(spread.pages.item(j), margins, columns);
+        }
+      }
+      for (i = 0; i < doc.pages.length; i++) {
+        page = doc.pages.item(i);
+        idcApplyMargins(page, margins, columns);
+        pageIds.push(Number(page.id));
+      }
+    } catch (e2) {
+      IDC.fail('script_error', 'Document was created but could not be set up: ' + String(e2.message ? e2.message : e2),
+        { document_id: Number(doc.id) });
+    }
+
+    ctx.changes = { created_document_ids: [Number(doc.id)] };
+
+    return {
+      document_id: Number(doc.id),
+      name: String(doc.name),
+      page_ids: pageIds,
+      page_count: doc.pages.length,
+      page_width_mm: IDC.round(prefs.pageWidth),
+      page_height_mm: IDC.round(prefs.pageHeight),
+      facing_pages: prefs.facingPages === true
+    };
+  });
+
+/* --------------------------------------------------------- save_document */
+
+IDC.register('save_document', { needs_document: true, read_only: false, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var target = null;
+
+    if (args.path !== undefined && args.path !== null) {
+      if (typeof args.path !== 'string' || args.path.length === 0) {
+        IDC.fail('invalid_argument', 'path must be a non-empty file path.', null);
+      }
+      target = IDC.fileFor(args.path);
+      if (!IDC.fileParentExists(target)) {
+        IDC.fail('io_error', 'The folder for the target path does not exist: ' + args.path, { path: args.path });
+      }
+    } else if (doc.saved !== true) {
+      IDC.fail('io_error',
+        'This document has never been saved; path is required for the first save.', null);
+    }
+
+    try {
+      if (target !== null) { doc.save(target); }
+      else { doc.save(); }
+    } catch (e) {
+      IDC.fail('io_error', 'InDesign could not save the document: ' + String(e.message ? e.message : e),
+        { path: target === null ? idcDocumentPath(doc) : args.path });
+    }
+
+    ctx.changes = { saved_document_ids: [Number(doc.id)] };
+    return {
+      document_id: Number(doc.id),
+      name: String(doc.name),
+      path: idcDocumentPath(doc)
+    };
+  });
+
+/* ---------------------------------------------------- set_document_bleed */
+
+/* Zahl = alle Kanten; Objekt = nur die genannten Kanten; Grenzen pruefen. */
+function idcEdges(value, field, max) {
+  var out = { top: null, left: null, bottom: null, right: null };
+  var keys = ['top', 'left', 'bottom', 'right'];
+  var i, k, any = false;
+
+  if (idcIsNumber(value)) {
+    for (i = 0; i < keys.length; i++) { out[keys[i]] = value; }
+    any = true;
+  } else if (value && typeof value === 'object') {
+    for (i = 0; i < keys.length; i++) {
+      k = keys[i];
+      if (value[k] !== undefined && value[k] !== null) {
+        if (!idcIsNumber(value[k])) {
+          IDC.fail('invalid_argument', field + '.' + k + ' must be a number.', value);
+        }
+        out[k] = value[k];
+        any = true;
+      }
+    }
+  } else {
+    IDC.fail('invalid_argument', field + ' must be a number or an object with top/left/bottom/right.', null);
+  }
+  if (!any) {
+    IDC.fail('invalid_argument', field + ' names no edge.', value);
+  }
+  for (i = 0; i < keys.length; i++) {
+    k = keys[i];
+    if (out[k] !== null && (out[k] < 0 || out[k] > max)) {
+      IDC.fail('invalid_argument', field + '.' + k + ' must be between 0 and ' + max + ' mm.', value);
+    }
+  }
+  return out;
+}
+
+function idcAllEqual(edges) {
+  return edges.top !== null && edges.left !== null && edges.bottom !== null && edges.right !== null
+    && edges.top === edges.left && edges.top === edges.bottom && edges.top === edges.right;
+}
+
+IDC.register('set_document_bleed', { needs_document: true, read_only: false, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var prefs = ctx.doc.documentPreferences;
+    var bleed = null;
+    var slug = null;
+    var changed = false;
+
+    if (args.bleed_mm !== undefined && args.bleed_mm !== null) { bleed = idcEdges(args.bleed_mm, 'bleed_mm', 50); }
+    if (args.slug_mm !== undefined && args.slug_mm !== null) { slug = idcEdges(args.slug_mm, 'slug_mm', 50); }
+
+    if (bleed !== null) {
+      prefs.documentBleedUniformSize = false;
+      if (bleed.top !== null) { prefs.documentBleedTopOffset = bleed.top; }
+      if (bleed.bottom !== null) { prefs.documentBleedBottomOffset = bleed.bottom; }
+      if (bleed.left !== null) { prefs.documentBleedInsideOrLeftOffset = bleed.left; }
+      if (bleed.right !== null) { prefs.documentBleedOutsideOrRightOffset = bleed.right; }
+      /* uniform nach dem, was jetzt wirklich steht – auch wenn nur eine Kante genannt war */
+      if (idcAllEqual({
+        top: prefs.documentBleedTopOffset, left: prefs.documentBleedInsideOrLeftOffset,
+        bottom: prefs.documentBleedBottomOffset, right: prefs.documentBleedOutsideOrRightOffset
+      })) { prefs.documentBleedUniformSize = true; }
+      changed = true;
+    }
+    if (slug !== null) {
+      prefs.documentSlugUniformSize = false;
+      if (slug.top !== null) { prefs.slugTopOffset = slug.top; }
+      if (slug.bottom !== null) { prefs.slugBottomOffset = slug.bottom; }
+      if (slug.left !== null) { prefs.slugInsideOrLeftOffset = slug.left; }
+      if (slug.right !== null) { prefs.slugRightOrOutsideOffset = slug.right; }
+      if (idcAllEqual({
+        top: prefs.slugTopOffset, left: prefs.slugInsideOrLeftOffset,
+        bottom: prefs.slugBottomOffset, right: prefs.slugRightOrOutsideOffset
+      })) { prefs.documentSlugUniformSize = true; }
+      changed = true;
+    }
+    if (!changed) { ctx.warn('Neither bleed_mm nor slug_mm given; nothing changed, current values returned.'); }
+    else { ctx.changes = { modified_document_ids: [Number(ctx.doc.id)] }; }
+
+    return {
+      bleed_mm: {
+        top: IDC.round(prefs.documentBleedTopOffset),
+        left: IDC.round(prefs.documentBleedInsideOrLeftOffset),
+        bottom: IDC.round(prefs.documentBleedBottomOffset),
+        right: IDC.round(prefs.documentBleedOutsideOrRightOffset)
+      },
+      slug_mm: {
+        top: IDC.round(prefs.slugTopOffset),
+        left: IDC.round(prefs.slugInsideOrLeftOffset),
+        bottom: IDC.round(prefs.slugBottomOffset),
+        right: IDC.round(prefs.slugRightOrOutsideOffset)
+      },
+      bleed_uniform: prefs.documentBleedUniformSize === true,
+      slug_uniform: prefs.documentSlugUniformSize === true
+    };
+  });

package/indesign/commands/22-document-setup.js

@@ -0,0 +1,118 @@
+/* Wunschliste J2 Nr. 21 (Sitzung 8) – Dokumenteinrichtung nachtraeglich: set_document_setup. */
+
+function idcDescribeSetup(doc) {
+  var prefs = doc.documentPreferences;
+  var out = { page_width_mm: null, page_height_mm: null, facing_pages: null, page_count: null, start_page_number: null, allow_page_shuffle: null };
+  try { out.page_width_mm = IDC.round(Number(prefs.pageWidth)); } catch (e0) { /* null */ }
+  try { out.page_height_mm = IDC.round(Number(prefs.pageHeight)); } catch (e1) { /* null */ }
+  try { out.facing_pages = prefs.facingPages === true; } catch (e2) { /* null */ }
+  try { out.page_count = Number(doc.pages.length); } catch (e3) { /* null */ }
+  try { out.start_page_number = Number(prefs.startPageNumber); } catch (e4) { /* null */ }
+  try { out.allow_page_shuffle = prefs.allowPageShuffle === true; } catch (e5) { /* null */ }
+  return out;
+}
+
+IDC.register('set_document_setup', { needs_document: true, read_only: false, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var prefs = doc.documentPreferences;
+    var before = idcDescribeSetup(doc);
+    var width = before.page_width_mm, height = before.page_height_mm, swap = false, sizeGiven = false;
+    var given = 0, after, i, page, removed = [], added = [], pageIds = [];
+
+    if (args.preset !== undefined && args.preset !== null) {
+      if (!IDC_PAGE_PRESETS[String(args.preset)]) {
+        IDC.fail('invalid_argument', 'preset must be one of A4, Letter, Legal, Tabloid.', { preset: String(args.preset) });
+      }
+      width = IDC_PAGE_PRESETS[String(args.preset)].width;
+      height = IDC_PAGE_PRESETS[String(args.preset)].height;
+      sizeGiven = true; given += 1;
+    }
+    if (args.width_mm !== undefined && args.width_mm !== null) {
+      if (!idcIsNumber(args.width_mm) || args.width_mm <= 0 || args.width_mm > 5486) { IDC.fail('invalid_argument', 'width_mm must be a number above 0 (mm).', { width_mm: args.width_mm }); }
+      width = args.width_mm; sizeGiven = true; given += 1;
+    }
+    if (args.height_mm !== undefined && args.height_mm !== null) {
+      if (!idcIsNumber(args.height_mm) || args.height_mm <= 0 || args.height_mm > 5486) { IDC.fail('invalid_argument', 'height_mm must be a number above 0 (mm).', { height_mm: args.height_mm }); }
+      height = args.height_mm; sizeGiven = true; given += 1;
+    }
+    if (args.orientation !== undefined && args.orientation !== null) {
+      if (args.orientation === 'landscape') { swap = width < height; }
+      else if (args.orientation === 'portrait') { swap = width > height; }
+      else { IDC.fail('invalid_argument', 'orientation must be "portrait" or "landscape".', { orientation: String(args.orientation) }); }
+      if (swap) { sizeGiven = true; }
+      given += 1;
+    }
+    if (args.facing_pages !== undefined && args.facing_pages !== null) {
+      if (args.facing_pages !== true && args.facing_pages !== false) { IDC.fail('invalid_argument', 'facing_pages must be true or false.', null); }
+      given += 1;
+    }
+    if (args.pages !== undefined && args.pages !== null) {
+      if (!idcIsNumber(args.pages) || args.pages < 1 || Math.floor(args.pages) !== args.pages || args.pages > 9999) {
+        IDC.fail('invalid_argument', 'pages must be a whole number from 1 to 9999.', { pages: args.pages });
+      }
+      if (args.pages < before.page_count && args.allow_page_removal !== true) {
+        IDC.fail('invalid_argument', 'pages ' + args.pages + ' is below the current page count ' + before.page_count + '; InDesign would delete the last pages with their contents. Pass allow_page_removal true to confirm, or use delete_page.',
+          { pages: args.pages, page_count: before.page_count });
+      }
+      given += 1;
+    }
+    if (args.start_page_number !== undefined && args.start_page_number !== null) {
+      if (!idcIsNumber(args.start_page_number) || args.start_page_number < 1 || Math.floor(args.start_page_number) !== args.start_page_number) {
+        IDC.fail('invalid_argument', 'start_page_number must be a whole number of 1 or more.', { start_page_number: args.start_page_number });
+      }
+      given += 1;
+    }
+    if (given === 0) {
+      IDC.fail('invalid_argument', 'Pass at least one of preset, width_mm, height_mm, orientation, facing_pages, pages, start_page_number.', null);
+    }
+    if (swap) { i = width; width = height; height = i; }
+
+    for (i = 0; i < doc.pages.length; i++) { try { pageIds.push(Number(doc.pages.item(i).id)); } catch (e0) { /* ohne */ } }
+
+    try {
+      if (args.facing_pages !== undefined && args.facing_pages !== null) { prefs.facingPages = args.facing_pages; }
+      if (sizeGiven) {
+        prefs.pageWidth = width;
+        prefs.pageHeight = height;
+      }
+      if (args.pages !== undefined && args.pages !== null) { prefs.pagesPerDocument = args.pages; }
+      if (args.start_page_number !== undefined && args.start_page_number !== null) { prefs.startPageNumber = args.start_page_number; }
+    } catch (e1) {
+      IDC.fail('script_error', 'InDesign could not change the document setup: ' + String(e1.message ? e1.message : e1), null);
+    }
+
+    after = idcDescribeSetup(doc);
+    /* Welche Seiten sind weg, welche neu? */
+    var current = {};
+    for (i = 0; i < doc.pages.length; i++) {
+      try { page = doc.pages.item(i); current[Number(page.id)] = true; if (!idcIdIn(pageIds, Number(page.id))) { added.push(Number(page.id)); } } catch (e2) { /* ohne */ }
+    }
+    for (i = 0; i < pageIds.length; i++) { if (!current[pageIds[i]]) { removed.push(pageIds[i]); } }
+
+    if (sizeGiven && (after.page_width_mm !== IDC.round(width) || after.page_height_mm !== IDC.round(height))) {
+      ctx.warn('InDesign reports the page size ' + after.page_width_mm + ' x ' + after.page_height_mm + ' mm after the change.');
+    }
+    if (sizeGiven && (before.page_width_mm !== after.page_width_mm || before.page_height_mm !== after.page_height_mm)) {
+      ctx.warn('The page size changed; objects and margins are not adjusted automatically – check get_layout_grid and get_page_state.');
+    }
+    if (args.facing_pages !== undefined && args.facing_pages !== null && before.facing_pages !== after.facing_pages) {
+      ctx.warn('facing_pages changed; spreads and parent pages were rearranged by InDesign – read list_pages and list_parent_pages again.');
+    }
+    if (removed.length > 0) { ctx.warn(removed.length + ' page(s) were removed with their contents.'); }
+    ctx.changes = { modified_document_ids: [Number(doc.id)], created_page_ids: added, removed_page_ids: removed };
+    return {
+      setup: after,
+      previous: before,
+      pages_added: added,
+      pages_removed: removed,
+      changed: IDC.stringify(before) !== IDC.stringify(after)
+    };
+  });
+
+function idcIdIn(list, id) {
+  var i;
+  for (i = 0; i < list.length; i++) { if (list[i] === id) { return true; } }
+  return false;
+}