Use generic PdfDataType structures

@@ -441,25 +441,25 @@ class PdfIndirect extends PdfDataType {
   int get hashCode => ser.hashCode + gen.hashCode;
   int get hashCode => ser.hashCode + gen.hashCode;
 }
 }
 
 
-class PdfArray extends PdfDataType {
-  PdfArray([Iterable<PdfDataType>? values]) {
+class PdfArray<T extends PdfDataType> extends PdfDataType {
+  PdfArray([Iterable<T>? values]) {
     if (values != null) {
     if (values != null) {
       this.values.addAll(values);
       this.values.addAll(values);
     }
     }
   }
   }
 
 
-  factory PdfArray.fromObjects(List<PdfObject?> objects) {
+  static PdfArray<PdfIndirect> fromObjects(List<PdfObject?> objects) {
     return PdfArray(
     return PdfArray(
         objects.map<PdfIndirect>((PdfObject? e) => e!.ref()).toList());
         objects.map<PdfIndirect>((PdfObject? e) => e!.ref()).toList());
   }
   }
 
 
-  factory PdfArray.fromNum(List<num?> list) {
+  static PdfArray<PdfNum> fromNum(List<num?> list) {
     return PdfArray(list.map<PdfNum>((num? e) => PdfNum(e!)).toList());
     return PdfArray(list.map<PdfNum>((num? e) => PdfNum(e!)).toList());
   }
   }
 
 
-  final List<PdfDataType> values = <PdfDataType>[];
+  final List<T> values = <T>[];
 
 
-  void add(PdfDataType v) {
+  void add(T v) {
     values.add(v);
     values.add(v);
   }
   }
 
 
@@ -489,7 +489,7 @@ class PdfArray extends PdfDataType {
     }
     }
 
 
     // ignore: prefer_collection_literals
     // ignore: prefer_collection_literals
-    final uniques = LinkedHashMap<PdfDataType, bool>();
+    final uniques = LinkedHashMap<T, bool>();
     for (final s in values) {
     for (final s in values) {
       uniques[s] = true;
       uniques[s] = true;
     }
     }
@@ -510,14 +510,14 @@ class PdfArray extends PdfDataType {
   int get hashCode => values.hashCode;
   int get hashCode => values.hashCode;
 }
 }
 
 
-class PdfDict extends PdfDataType {
-  PdfDict([Map<String, PdfDataType>? values]) {
+class PdfDict<T extends PdfDataType> extends PdfDataType {
+  PdfDict([Map<String, T>? values]) {
     if (values != null) {
     if (values != null) {
       this.values.addAll(values);
       this.values.addAll(values);
     }
     }
   }
   }
 
 
-  factory PdfDict.fromObjectMap(Map<String, PdfObject> objects) {
+  static PdfDict<PdfIndirect> fromObjectMap(Map<String, PdfObject> objects) {
     return PdfDict(
     return PdfDict(
       objects.map<String, PdfIndirect>(
       objects.map<String, PdfIndirect>(
         (String key, PdfObject value) =>
         (String key, PdfObject value) =>
@@ -526,22 +526,22 @@ class PdfDict extends PdfDataType {
     );
     );
   }
   }
 
 
-  final Map<String, PdfDataType> values = <String, PdfDataType>{};
+  final Map<String, T> values = <String, T>{};
 
 
   bool get isNotEmpty => values.isNotEmpty;
   bool get isNotEmpty => values.isNotEmpty;
 
 
-  operator []=(String k, PdfDataType v) {
+  operator []=(String k, T v) {
     values[k] = v;
     values[k] = v;
   }
   }
 
 
-  PdfDataType? operator [](String k) {
+  T? operator [](String k) {
     return values[k];
     return values[k];
   }
   }
 
 
   @override
   @override
   void output(PdfStream s) {
   void output(PdfStream s) {
     s.putBytes(const <int>[0x3c, 0x3c]);
     s.putBytes(const <int>[0x3c, 0x3c]);
-    values.forEach((String k, PdfDataType v) {
+    values.forEach((String k, T v) {
       s.putString(k);
       s.putString(k);
       if (v is PdfNum || v is PdfBool || v is PdfNull || v is PdfIndirect) {
       if (v is PdfNum || v is PdfBool || v is PdfNull || v is PdfIndirect) {
         s.putByte(0x20);
         s.putByte(0x20);
@@ -555,7 +555,7 @@ class PdfDict extends PdfDataType {
     return values.containsKey(key);
     return values.containsKey(key);
   }
   }
 
 
-  void merge(PdfDict other) {
+  void merge(PdfDict<T> other) {
     for (final key in other.values.keys) {
     for (final key in other.values.keys) {
       final value = other[key]!;
       final value = other[key]!;
       final current = values[key];
       final current = values[key];
@@ -572,7 +572,7 @@ class PdfDict extends PdfDataType {
     }
     }
   }
   }
 
 
-  void addAll(PdfDict other) {
+  void addAll(PdfDict<T> other) {
     values.addAll(other.values);
     values.addAll(other.values);
   }
   }
 
 

@@ -99,14 +99,14 @@ class PdfPage extends PdfObject with PdfGraphicStream {
         PdfArray.fromNum(<double>[0, 0, pageFormat.width, pageFormat.height]);
         PdfArray.fromNum(<double>[0, 0, pageFormat.width, pageFormat.height]);
 
 
     // The graphic operations to draw the page
     // The graphic operations to draw the page
-    if (contents.isNotEmpty) {
     final contentList = PdfArray.fromObjects(contents);
     final contentList = PdfArray.fromObjects(contents);
 
 
     if (params.containsKey('/Contents')) {
     if (params.containsKey('/Contents')) {
       final prevContent = params['/Contents']!;
       final prevContent = params['/Contents']!;
       if (prevContent is PdfArray) {
       if (prevContent is PdfArray) {
-          contentList.values.insertAll(0, prevContent.values);
-        } else {
+        contentList.values
+            .insertAll(0, prevContent.values.whereType<PdfIndirect>());
+      } else if (prevContent is PdfIndirect) {
         contentList.values.insert(0, prevContent);
         contentList.values.insert(0, prevContent);
       }
       }
     }
     }
@@ -115,10 +115,9 @@ class PdfPage extends PdfObject with PdfGraphicStream {
 
 
     if (contentList.values.length == 1) {
     if (contentList.values.length == 1) {
       params['/Contents'] = contentList.values.first;
       params['/Contents'] = contentList.values.first;
-      } else {
+    } else if (contents.isNotEmpty) {
       params['/Contents'] = contentList;
       params['/Contents'] = contentList;
     }
     }
-    }
 
 
     // The /Annots object
     // The /Annots object
     if (annotations.isNotEmpty) {
     if (annotations.isNotEmpty) {