layoutbridge-light 0.0.0-stage → 1.0.1

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

@@ -0,0 +1,204 @@
+/* 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;
+    }
+    var adjust = null;
+    if (args.adjust_layout !== undefined && args.adjust_layout !== null) {
+      if (args.adjust_layout !== true && args.adjust_layout !== false) {
+        IDC.fail('invalid_argument', 'adjust_layout must be true or false.', { adjust_layout: args.adjust_layout });
+      }
+      adjust = args.adjust_layout;
+    }
+    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 */ } }
+
+    var layoutState = idcSuspendLayoutAdjustment(doc, adjust);
+    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);
+    } finally {
+      idcRestoreLayoutAdjustment(ctx, doc, layoutState);
+    }
+
+    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 };
+    if (sizeGiven && adjust === null && layoutState.active.length > 0) {
+      ctx.warn('Layout adjustment was active (' + layoutState.active.join(', ') + '); InDesign may have moved or scaled objects with the page size. Pass adjust_layout false to keep them as they are.');
+    }
+    return {
+      setup: after,
+      previous: before,
+      pages_added: added,
+      pages_removed: removed,
+      changed: IDC.stringify(before) !== IDC.stringify(after),
+      layout_adjustment: {
+        requested: adjust,
+        active_before: layoutState.active,
+        layout_rules_suspended: layoutState.rules.length
+      }
+    };
+  });
+
+/*
+ * Layoutanpassung fuer einen Aufruf (A-43 Nr. 4, KDP-Befund 4). Live-Probe
+ * 09.10.2026 (InDesign 21.6): Rahmen wachsen bei geaenderter Seitengroesse,
+ * wenn eine fluessige Layoutregel (page.layoutRule, z. B. SCALE) gilt;
+ * "Layout anpassen" (adjustLayoutPreferences.enableAdjustLayout) verschiebt
+ * sie. adjust false schaltet beides fuer den Aufruf ab (Regeln der Dokument-
+ * und Musterseiten voruebergehend OFF), true schaltet "Layout anpassen" an,
+ * null laesst alles. Gemeldet wird, was vorher aktiv war.
+ */
+function idcLayoutRuleName(rule) {
+  if (typeof LayoutRuleOptions === 'undefined') { return String(rule); }
+  if (IDC.enumIs(rule, LayoutRuleOptions.OFF)) { return 'off'; }
+  if (IDC.enumIs(rule, LayoutRuleOptions.USE_MASTER)) { return 'use_master'; }
+  if (IDC.enumIs(rule, LayoutRuleOptions.SCALE)) { return 'scale'; }
+  if (IDC.enumIs(rule, LayoutRuleOptions.RECENTER)) { return 'recenter'; }
+  if (IDC.enumIs(rule, LayoutRuleOptions.GUIDE_BASED)) { return 'guide_based'; }
+  if (IDC.enumIs(rule, LayoutRuleOptions.OBJECT_BASED)) { return 'object_based'; }
+  return String(rule);
+}
+
+function idcSuspendLayoutAdjustment(doc, adjust) {
+  var state = { active: [], prevAdjust: null, adjustSet: false, rules: [] };
+  var pages = [], i, j, spread, name, enabled = null, seen = {};
+  try { enabled = doc.adjustLayoutPreferences.enableAdjustLayout === true; } catch (e0) { enabled = null; }
+  if (enabled === true) { state.active.push('adjust_layout'); }
+  for (i = 0; i < doc.pages.length; i++) { pages.push(doc.pages.item(i)); }
+  try {
+    for (i = 0; i < doc.masterSpreads.length; i++) {
+      spread = doc.masterSpreads.item(i);
+      for (j = 0; j < spread.pages.length; j++) { pages.push(spread.pages.item(j)); }
+    }
+  } catch (e1) { /* ohne Musterseiten */ }
+  for (i = 0; i < pages.length; i++) {
+    try { name = idcLayoutRuleName(pages[i].layoutRule); } catch (e2) { continue; }
+    if (name === 'off' || name === 'use_master') { continue; }
+    if (!IDC.hasOwn(seen, name)) { seen[name] = true; state.active.push('layout_rule ' + name); }
+    if (adjust === false) { state.rules.push({ page: pages[i], rule: pages[i].layoutRule }); }
+  }
+  if (adjust !== null && enabled !== null && enabled !== adjust) {
+    try {
+      state.prevAdjust = enabled;
+      doc.adjustLayoutPreferences.enableAdjustLayout = adjust;
+      state.adjustSet = true;
+    } catch (e3) { state.adjustSet = false; }
+  }
+  for (i = 0; i < state.rules.length; i++) {
+    try { state.rules[i].page.layoutRule = LayoutRuleOptions.OFF; } catch (e4) { /* bleibt */ }
+  }
+  return state;
+}
+
+function idcRestoreLayoutAdjustment(ctx, doc, state) {
+  var i;
+  for (i = 0; i < state.rules.length; i++) {
+    try {
+      if (state.rules[i].page.isValid !== true) { continue; }
+      state.rules[i].page.layoutRule = state.rules[i].rule;
+    } catch (e0) {
+      ctx.warn('Could not restore the liquid layout rule of a page.');
+    }
+  }
+  if (state.adjustSet) {
+    try { doc.adjustLayoutPreferences.enableAdjustLayout = state.prevAdjust; } catch (e1) {
+      ctx.warn('Could not restore the Adjust Layout setting.');
+    }
+  }
+}
+
+function idcIdIn(list, id) {
+  var i;
+  for (i = 0; i < list.length; i++) { if (list[i] === id) { return true; } }
+  return false;
+}

package/indesign/commands/23-save-package.js

@@ -0,0 +1,258 @@
+/* Wunschliste J2 Nr. 23 (Sitzung 8) – Kopie speichern und Verpacken: save_document_as, package_document. */
+
+function idcTargetFileArg(path, field, extensions) {
+  var file, lower, i, ok = false;
+  if (typeof path !== 'string' || path.length === 0) {
+    IDC.fail('invalid_argument', field + ' must be a non-empty file path.', null);
+  }
+  lower = path.toLowerCase();
+  for (i = 0; i < extensions.length; i++) {
+    if (lower.length > extensions[i].length && lower.substring(lower.length - extensions[i].length) === extensions[i]) { ok = true; break; }
+  }
+  if (!ok) {
+    IDC.fail('invalid_argument', field + ' must end in ' + extensions.join(' or ') + '.', { path: path });
+  }
+  file = IDC.fileFor(path);
+  if (!IDC.fileParentExists(file)) {
+    IDC.fail('io_error', 'The folder for ' + field + ' does not exist: ' + path, { path: path });
+  }
+  return file;
+}
+
+IDC.register('save_document_as', { needs_document: true, read_only: false, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var mode = args.mode === undefined || args.mode === null ? 'copy' : args.mode;
+    var overwrite = args.overwrite === true;
+    var extensions = ['.indd', '.indt'];
+    var file, own = idcDocumentPath(doc), nameBefore, existed, result;
+
+    if (mode !== 'copy' && mode !== 'switch') {
+      IDC.fail('invalid_argument', 'mode must be copy (the open document keeps its file) or switch (the open document continues under the new name).', { mode: mode });
+    }
+    file = idcTargetFileArg(args.path, 'path', extensions);
+    if (own !== '' && IDC.fsPath(file) === own) {
+      IDC.fail('invalid_argument', 'path is the file of the document itself; use save_document.', { path: args.path });
+    }
+    existed = file.exists === true;
+    if (existed && !overwrite) {
+      IDC.fail('io_error', 'A file exists at path already; pass overwrite true to replace it.', { path: args.path });
+    }
+    try { nameBefore = String(doc.name); } catch (e0) { nameBefore = ''; }
+    try {
+      if (mode === 'copy') {
+        doc.saveACopy(file, args.template === true);
+      } else {
+        doc.save(file, args.template === true);
+      }
+    } catch (e1) {
+      IDC.fail('io_error', 'InDesign could not save ' + (mode === 'copy' ? 'a copy' : 'the document') + ' to ' + args.path + ': ' + String(e1.message ? e1.message : e1), { path: args.path });
+    }
+    result = {
+      document_id: Number(doc.id),
+      mode: mode,
+      path: IDC.fsPath(file) || args.path,
+      bytes: IDC.fileSize(file),
+      overwritten: existed,
+      template: args.template === true,
+      name: String(doc.name),
+      document_path: idcDocumentPath(doc),
+      name_before: nameBefore
+    };
+    idcManagedSaveWarning(ctx, doc, mode === 'copy' ? 'The copy links to the same story files but is not bound to the editorial workflow.' :
+      'The document now continues under the new file and still links to the same story files; it is not bound to the editorial workflow under the new name.');
+    if (mode === 'copy' && result.document_path === '') {
+      ctx.warn('The open document itself is still unsaved (untitled); only the copy was written.');
+    }
+    ctx.changes = mode === 'copy' ? { written_files: [result.path] } : { saved_document_ids: [Number(doc.id)], written_files: [result.path] };
+    return result;
+  });
+
+IDC.register('package_document', { needs_document: true, read_only: false, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var folder, issues, ok = false, pdfPreset = '', result, count = 0, reportFile;
+    var copyFonts = args.copy_fonts !== false;
+    var copyGraphics = args.copy_graphics !== false;
+    var copyProfiles = args.copy_profiles === true;
+    var updateGraphics = args.update_graphics !== false;
+    var includeHidden = args.include_hidden_layers === true;
+    var ignorePreflight = args.ignore_preflight_errors !== false;
+    var createReport = args.create_report !== false;
+    var includeIdml = args.include_idml === true;
+    var includePdf = args.include_pdf === true;
+
+    if (typeof args.folder_path !== 'string' || args.folder_path.length === 0) {
+      IDC.fail('invalid_argument', 'folder_path is required (the package folder InDesign creates or fills).', null);
+    }
+    if (idcDocumentPath(doc) === '') {
+      IDC.fail('invalid_state', 'The document has never been saved; save_document with path first.', null);
+    }
+    folder = IDC.folderFor(args.folder_path);
+    if (!IDC.fileParentExists(folder)) {
+      IDC.fail('io_error', 'The parent folder of folder_path does not exist: ' + args.folder_path, { folder_path: args.folder_path });
+    }
+    if (includePdf) {
+      if (args.pdf_preset !== undefined && args.pdf_preset !== null) {
+        if (typeof args.pdf_preset !== 'string' || args.pdf_preset === '') { IDC.fail('invalid_argument', 'pdf_preset must be a preset name.', null); }
+        if (idcPdfPresetByName(args.pdf_preset) === null) {
+          IDC.fail('not_found', 'PDF preset "' + args.pdf_preset + '" not found.', { pdf_preset: args.pdf_preset, available: idcPdfPresetNames() });
+        }
+        pdfPreset = args.pdf_preset;
+      } else {
+        try { pdfPreset = String(idcHighQualityPreset().name); } catch (e0) { pdfPreset = ''; }
+      }
+    }
+    issues = idcDocumentIssues(doc);
+    if (issues.missing_links && issues.missing_links.length > 0) {
+      ctx.warn(issues.missing_links.length + ' missing link(s) cannot be packaged: ' + issues.missing_links.join(', '));
+    }
+    if (issues.missing_fonts && issues.missing_fonts.length > 0) {
+      ctx.warn(issues.missing_fonts.length + ' missing font(s): ' + issues.missing_fonts.join(', '));
+    }
+    try {
+      ok = doc.packageForPrint(folder, copyFonts, copyGraphics, copyProfiles, updateGraphics, includeHidden, ignorePreflight, createReport,
+        includeIdml, includePdf, pdfPreset, false, '', true);
+    } catch (e1) {
+      IDC.fail('io_error', 'InDesign could not package the document: ' + String(e1.message ? e1.message : e1), { folder_path: args.folder_path });
+    }
+    if (ok !== true) {
+      IDC.fail('io_error', 'InDesign reported that packaging did not succeed (preflight errors? missing links?).', { folder_path: args.folder_path, missing_links: issues.missing_links, missing_fonts: issues.missing_fonts });
+    }
+    result = {
+      document_id: Number(doc.id),
+      folder_path: IDC.fsPath(folder) || args.folder_path,
+      copy_fonts: copyFonts,
+      copy_graphics: copyGraphics,
+      copy_profiles: copyProfiles,
+      update_graphics: updateGraphics,
+      include_hidden_layers: includeHidden,
+      ignore_preflight_errors: ignorePreflight,
+      create_report: createReport,
+      include_idml: includeIdml,
+      include_pdf: includePdf,
+      pdf_preset: includePdf ? pdfPreset : null,
+      missing_links: issues.missing_links || [],
+      missing_fonts: issues.missing_fonts || [],
+      document_path: idcDocumentPath(doc)
+    };
+    try {
+      count = folder.getFiles ? folder.getFiles().length : null;
+    } catch (e2) { count = null; }
+    result.entries_in_folder = count;
+
+    /* Demo-Heft-Befund 6 (Sitzung 10): welche Schriften liegen im Paket, welche nicht. */
+    var fontReport = idcPackagedFontReport(doc, folder, copyFonts);
+    result.fonts = fontReport.fonts;
+    result.fonts_total = fontReport.fonts.length;
+    result.fonts_packaged_count = fontReport.packaged_count;
+    result.fonts_not_packaged = fontReport.not_packaged;
+    result.fonts_folder = fontReport.folder;
+    if (copyFonts && fontReport.not_packaged.length > 0) {
+      ctx.warn(fontReport.not_packaged.length + ' font(s) are not in the package folder: ' + fontReport.not_packaged.join(', ') +
+        ' – fonts from Adobe Fonts (Creative Cloud) and other protected fonts are never copied by InDesign; the printer needs them installed.');
+    }
+    idcManagedSaveWarning(ctx, doc, 'The package holds copies of their story files; the package is not bound to the editorial workflow.');
+    ctx.changes = { written_folders: [result.folder_path] };
+    return result;
+  });
+
+/* ------------------------------------------- Schriften im Paket (Befund 6) */
+
+/*
+ * FontTypes nach indesignjs.de (Adobes Seite liefert 404; live am 05.09.2026
+ * zu bestaetigen): TYPE_1, TRUETYPE, CID, ATC, BITMAP, OCF, OPENTYPE_CFF,
+ * OPENTYPE_TT, OPENTYPE_CID, UNKNOWN.
+ */
+function idcFontTypeName(value) {
+  if (typeof FontTypes === 'undefined' || value === undefined || value === null) { return null; }
+  if (IDC.enumIs(value, FontTypes.TYPE_1)) { return 'type1'; }
+  if (IDC.enumIs(value, FontTypes.TRUETYPE)) { return 'truetype'; }
+  if (IDC.enumIs(value, FontTypes.OPENTYPE_CFF)) { return 'opentype_cff'; }
+  if (IDC.enumIs(value, FontTypes.OPENTYPE_TT)) { return 'opentype_tt'; }
+  if (IDC.enumIs(value, FontTypes.OPENTYPE_CID)) { return 'opentype_cid'; }
+  if (IDC.enumIs(value, FontTypes.CID)) { return 'cid'; }
+  if (IDC.enumIs(value, FontTypes.ATC)) { return 'atc'; }
+  if (IDC.enumIs(value, FontTypes.BITMAP)) { return 'bitmap'; }
+  if (IDC.enumIs(value, FontTypes.OCF)) { return 'ocf'; }
+  return 'unknown';
+}
+
+function idcBaseName(path) {
+  return String(path).replace(/^.*[\/\\]/, '');
+}
+
+/* Dateinamen (klein geschrieben) im Ordner "Document fonts" des Pakets. */
+function idcPackagedFontFiles(folder) {
+  var out = { exists: false, names: [] };
+  var base = IDC.fsPath(folder);
+  var sub, files, i, entry, name;
+  if (base === '') { return out; }
+  try { sub = IDC.folderFor(base + '/Document fonts'); } catch (e0) { return out; }
+  try { if (sub.exists !== true) { return out; } } catch (e1) { return out; }
+  out.exists = true;
+  try {
+    files = sub.getFiles();
+    for (i = 0; i < files.length; i++) {
+      entry = files[i];
+      name = null;
+      try { if (entry && entry.name !== undefined) { name = String(entry.name); } } catch (e2) { name = null; }
+      if (name === null) { name = idcBaseName(entry); }
+      out.names.push(name.toLowerCase());
+    }
+  } catch (e3) { /* Liste bleibt, so weit sie kam */ }
+  return out;
+}
+
+function idcIsAdobeFontsLocation(location) {
+  var text = String(location).toLowerCase();
+  return text.indexOf('/coresync/') >= 0 || text.indexOf('livetype') >= 0 || text.indexOf('/adobe fonts') >= 0;
+}
+
+/* Schriften des Dokuments mit Paketstatus. */
+function idcPackagedFontReport(doc, folder, copyFonts) {
+  var files = copyFonts ? idcPackagedFontFiles(folder) : { exists: false, names: [] };
+  var out = { fonts: [], packaged_count: 0, not_packaged: [], folder: files.exists ? IDC.fsPath(folder) + '/Document fonts' : null };
+  var i, j, font, entry, location, base, status;
+  try {
+    for (i = 0; i < doc.fonts.length; i++) {
+      font = doc.fonts.item(i);
+      entry = { family: null, style: null, name: null, postscript_name: null, type: null, status: 'installed', location: null, packaged: null, reason: null };
+      try { entry.family = String(font.fontFamily); } catch (e0) { /* bleibt null */ }
+      try { entry.style = String(font.fontStyleName); } catch (e1) { /* bleibt null */ }
+      try { entry.name = String(font.name); } catch (e2) { /* bleibt null */ }
+      try { entry.postscript_name = String(font.postscriptName); } catch (e3) { /* bleibt null */ }
+      try { entry.type = idcFontTypeName(font.fontType); } catch (e4) { /* bleibt null */ }
+      try { status = font.status; entry.status = idcFontStatusName(status); } catch (e5) { entry.status = 'installed'; }
+      location = '';
+      try { location = String(font.location); } catch (e6) { location = ''; }
+      entry.location = location === '' ? null : location;
+      if (!copyFonts) {
+        entry.packaged = false;
+        entry.reason = 'copy_fonts_off';
+      } else if (entry.status !== 'installed') {
+        entry.packaged = false;
+        entry.reason = 'not_installed';
+      } else if (location === '' || !files.exists) {
+        entry.packaged = null;
+        entry.reason = files.exists ? 'location_unknown' : 'fonts_folder_missing';
+      } else {
+        base = idcBaseName(location).toLowerCase();
+        entry.packaged = false;
+        for (j = 0; j < files.names.length; j++) {
+          if (files.names[j] === base) { entry.packaged = true; break; }
+        }
+        if (!entry.packaged) {
+          entry.reason = idcIsAdobeFontsLocation(location) ? 'adobe_fonts' : 'not_copied';
+        }
+      }
+      if (entry.packaged === true) { out.packaged_count += 1; }
+      if (entry.packaged === false && entry.reason !== 'copy_fonts_off') { out.not_packaged.push(entry.name === null ? String(entry.family) : entry.name); }
+      out.fonts.push(entry);
+    }
+  } catch (e7) { /* Liste bleibt, so weit sie kam */ }
+  return out;
+}
+