exifreader 4.14.1 → 4.15.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +34 -30
- package/bin/build.js +8 -8
- package/dist/exif-reader.js +1 -1
- package/dist/exif-reader.js.gz +0 -0
- package/dist/exif-reader.js.map +1 -1
- package/package.json +27 -31
- package/src/exif-reader.js +2 -1
- package/src/mpf-tags.js +150 -0
- package/src/tags-helpers.js +187 -0
- package/src/tags.js +2 -315
- package/src/utils.js +3 -3
- package/src/xmp-tags.js +36 -8
- package/webpack.config.js +1 -1
package/src/tags.js
CHANGED
|
@@ -2,32 +2,17 @@
|
|
|
2
2
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
3
3
|
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
|
|
4
4
|
|
|
5
|
-
import Constants from './constants.js';
|
|
6
5
|
import {objectAssign} from './utils.js';
|
|
7
6
|
import ByteOrder from './byte-order.js';
|
|
8
|
-
import
|
|
9
|
-
import
|
|
10
|
-
import {deferInit, getBase64Image} from './utils.js';
|
|
7
|
+
import {IFD_TYPE_0TH, IFD_TYPE_EXIF, IFD_TYPE_GPS, IFD_TYPE_INTEROPERABILITY} from './tag-names.js';
|
|
8
|
+
import {readIfd, get0thIfdOffset} from './tags-helpers.js';
|
|
11
9
|
|
|
12
10
|
const EXIF_IFD_POINTER_KEY = 'Exif IFD Pointer';
|
|
13
11
|
const GPS_INFO_IFD_POINTER_KEY = 'GPS Info IFD Pointer';
|
|
14
12
|
const INTEROPERABILITY_IFD_POINTER_KEY = 'Interoperability IFD Pointer';
|
|
15
13
|
|
|
16
|
-
const getTagValueAt = {
|
|
17
|
-
1: Types.getByteAt,
|
|
18
|
-
2: Types.getAsciiAt,
|
|
19
|
-
3: Types.getShortAt,
|
|
20
|
-
4: Types.getLongAt,
|
|
21
|
-
5: Types.getRationalAt,
|
|
22
|
-
7: Types.getUndefinedAt,
|
|
23
|
-
9: Types.getSlongAt,
|
|
24
|
-
10: Types.getSrationalAt,
|
|
25
|
-
13: Types.getIfdPointerAt
|
|
26
|
-
};
|
|
27
|
-
|
|
28
14
|
export default {
|
|
29
15
|
read,
|
|
30
|
-
readMpf
|
|
31
16
|
};
|
|
32
17
|
|
|
33
18
|
function read(dataView, tiffHeaderOffset, includeUnknown) {
|
|
@@ -44,10 +29,6 @@ function read0thIfd(dataView, tiffHeaderOffset, byteOrder, includeUnknown) {
|
|
|
44
29
|
return readIfd(dataView, IFD_TYPE_0TH, tiffHeaderOffset, get0thIfdOffset(dataView, tiffHeaderOffset, byteOrder), byteOrder, includeUnknown);
|
|
45
30
|
}
|
|
46
31
|
|
|
47
|
-
function get0thIfdOffset(dataView, tiffHeaderOffset, byteOrder) {
|
|
48
|
-
return tiffHeaderOffset + Types.getLongAt(dataView, tiffHeaderOffset + 4, byteOrder);
|
|
49
|
-
}
|
|
50
|
-
|
|
51
32
|
function readExifIfd(tags, dataView, tiffHeaderOffset, byteOrder, includeUnknown) {
|
|
52
33
|
if (tags[EXIF_IFD_POINTER_KEY] !== undefined) {
|
|
53
34
|
return objectAssign(tags, readIfd(dataView, IFD_TYPE_EXIF, tiffHeaderOffset, tiffHeaderOffset + tags[EXIF_IFD_POINTER_KEY].value, byteOrder, includeUnknown));
|
|
@@ -71,297 +52,3 @@ function readInteroperabilityIfd(tags, dataView, tiffHeaderOffset, byteOrder, in
|
|
|
71
52
|
|
|
72
53
|
return tags;
|
|
73
54
|
}
|
|
74
|
-
|
|
75
|
-
function readMpf(dataView, dataOffset, includeUnknown) {
|
|
76
|
-
const byteOrder = ByteOrder.getByteOrder(dataView, dataOffset);
|
|
77
|
-
const tags = readIfd(dataView, IFD_TYPE_MPF, dataOffset, get0thIfdOffset(dataView, dataOffset, byteOrder), byteOrder, includeUnknown);
|
|
78
|
-
return addMpfImages(dataView, dataOffset, tags, byteOrder);
|
|
79
|
-
}
|
|
80
|
-
|
|
81
|
-
function addMpfImages(dataView, dataOffset, tags, byteOrder) {
|
|
82
|
-
const ENTRY_SIZE = 16;
|
|
83
|
-
|
|
84
|
-
if (!tags['MPEntry']) {
|
|
85
|
-
return tags;
|
|
86
|
-
}
|
|
87
|
-
|
|
88
|
-
const images = [];
|
|
89
|
-
for (let i = 0; i < Math.ceil(tags['MPEntry'].value.length / ENTRY_SIZE); i++) {
|
|
90
|
-
images[i] = {};
|
|
91
|
-
|
|
92
|
-
const attributes = getImageNumberValue(tags['MPEntry'].value, i * ENTRY_SIZE, Types.getTypeSize('LONG'), byteOrder);
|
|
93
|
-
images[i]['ImageFlags'] = getImageFlags(attributes);
|
|
94
|
-
images[i]['ImageFormat'] = getImageFormat(attributes);
|
|
95
|
-
images[i]['ImageType'] = getImageType(attributes);
|
|
96
|
-
|
|
97
|
-
const imageSize = getImageNumberValue(tags['MPEntry'].value, i * ENTRY_SIZE + 4, Types.getTypeSize('LONG'), byteOrder);
|
|
98
|
-
images[i]['ImageSize'] = {
|
|
99
|
-
value: imageSize,
|
|
100
|
-
description: '' + imageSize
|
|
101
|
-
};
|
|
102
|
-
|
|
103
|
-
const imageOffset = isFirstIndividualImage(i) ? 0 : getImageNumberValue(tags['MPEntry'].value, i * ENTRY_SIZE + 8, Types.getTypeSize('LONG'), byteOrder) + dataOffset;
|
|
104
|
-
images[i]['ImageOffset'] = {
|
|
105
|
-
value: imageOffset,
|
|
106
|
-
description: '' + imageOffset
|
|
107
|
-
};
|
|
108
|
-
|
|
109
|
-
const dependentImage1EntryNumber =
|
|
110
|
-
getImageNumberValue(tags['MPEntry'].value, i * ENTRY_SIZE + 12, Types.getTypeSize('SHORT'), byteOrder);
|
|
111
|
-
images[i]['DependentImage1EntryNumber'] = {
|
|
112
|
-
value: dependentImage1EntryNumber,
|
|
113
|
-
description: '' + dependentImage1EntryNumber
|
|
114
|
-
};
|
|
115
|
-
|
|
116
|
-
const dependentImage2EntryNumber =
|
|
117
|
-
getImageNumberValue(tags['MPEntry'].value, i * ENTRY_SIZE + 14, Types.getTypeSize('SHORT'), byteOrder);
|
|
118
|
-
images[i]['DependentImage2EntryNumber'] = {
|
|
119
|
-
value: dependentImage2EntryNumber,
|
|
120
|
-
description: '' + dependentImage2EntryNumber
|
|
121
|
-
};
|
|
122
|
-
|
|
123
|
-
images[i].image = dataView.buffer.slice(imageOffset, imageOffset + imageSize);
|
|
124
|
-
deferInit(images[i], 'base64', function () {
|
|
125
|
-
return getBase64Image(this.image);
|
|
126
|
-
});
|
|
127
|
-
}
|
|
128
|
-
|
|
129
|
-
tags['Images'] = images;
|
|
130
|
-
|
|
131
|
-
return tags;
|
|
132
|
-
}
|
|
133
|
-
|
|
134
|
-
function getImageNumberValue(entries, offset, size, byteOrder) {
|
|
135
|
-
if (byteOrder === ByteOrder.LITTLE_ENDIAN) {
|
|
136
|
-
let value = 0;
|
|
137
|
-
for (let i = 0; i < size; i++) {
|
|
138
|
-
value += entries[offset + i] << (8 * i);
|
|
139
|
-
}
|
|
140
|
-
return value;
|
|
141
|
-
}
|
|
142
|
-
|
|
143
|
-
let value = 0;
|
|
144
|
-
for (let i = 0; i < size; i++) {
|
|
145
|
-
value += entries[offset + i] << (8 * (size - 1 - i));
|
|
146
|
-
}
|
|
147
|
-
return value;
|
|
148
|
-
}
|
|
149
|
-
|
|
150
|
-
function getImageFlags(attributes) {
|
|
151
|
-
const flags = [
|
|
152
|
-
(attributes >> 31) & 0x1,
|
|
153
|
-
(attributes >> 30) & 0x1,
|
|
154
|
-
(attributes >> 29) & 0x1
|
|
155
|
-
];
|
|
156
|
-
|
|
157
|
-
const flagsDescription = [];
|
|
158
|
-
|
|
159
|
-
if (flags[0]) {
|
|
160
|
-
flagsDescription.push('Dependent Parent Image');
|
|
161
|
-
}
|
|
162
|
-
if (flags[1]) {
|
|
163
|
-
flagsDescription.push('Dependent Child Image');
|
|
164
|
-
}
|
|
165
|
-
if (flags[2]) {
|
|
166
|
-
flagsDescription.push('Representative Image');
|
|
167
|
-
}
|
|
168
|
-
|
|
169
|
-
return {
|
|
170
|
-
value: flags,
|
|
171
|
-
description: flagsDescription.join(', ') || 'None'
|
|
172
|
-
};
|
|
173
|
-
}
|
|
174
|
-
|
|
175
|
-
function getImageFormat(attributes) {
|
|
176
|
-
const imageFormat = attributes >> 24 & 0x7;
|
|
177
|
-
return {
|
|
178
|
-
value: imageFormat,
|
|
179
|
-
description: imageFormat === 0 ? 'JPEG' : 'Unknown'
|
|
180
|
-
};
|
|
181
|
-
}
|
|
182
|
-
|
|
183
|
-
function getImageType(attributes) {
|
|
184
|
-
const type = attributes & 0xffffff;
|
|
185
|
-
const descriptions = {
|
|
186
|
-
0x30000: 'Baseline MP Primary Image',
|
|
187
|
-
0x10001: 'Large Thumbnail (VGA equivalent)',
|
|
188
|
-
0x10002: 'Large Thumbnail (Full HD equivalent)',
|
|
189
|
-
0x20001: 'Multi-Frame Image (Panorama)',
|
|
190
|
-
0x20002: 'Multi-Frame Image (Disparity)',
|
|
191
|
-
0x20003: 'Multi-Frame Image (Multi-Angle)',
|
|
192
|
-
0x0: 'Undefined',
|
|
193
|
-
};
|
|
194
|
-
|
|
195
|
-
return {
|
|
196
|
-
value: type,
|
|
197
|
-
description: descriptions[type] || 'Unknown'
|
|
198
|
-
};
|
|
199
|
-
}
|
|
200
|
-
|
|
201
|
-
function isFirstIndividualImage(i) {
|
|
202
|
-
return i === 0;
|
|
203
|
-
}
|
|
204
|
-
|
|
205
|
-
function readIfd(dataView, ifdType, tiffHeaderOffset, offset, byteOrder, includeUnknown) {
|
|
206
|
-
const FIELD_COUNT_SIZE = Types.getTypeSize('SHORT');
|
|
207
|
-
const FIELD_SIZE = 12;
|
|
208
|
-
|
|
209
|
-
const tags = {};
|
|
210
|
-
const numberOfFields = getNumberOfFields(dataView, offset, byteOrder);
|
|
211
|
-
|
|
212
|
-
offset += FIELD_COUNT_SIZE;
|
|
213
|
-
for (let fieldIndex = 0; fieldIndex < numberOfFields; fieldIndex++) {
|
|
214
|
-
if (offset + FIELD_SIZE > dataView.byteLength) {
|
|
215
|
-
break;
|
|
216
|
-
}
|
|
217
|
-
|
|
218
|
-
const tag = readTag(dataView, ifdType, tiffHeaderOffset, offset, byteOrder, includeUnknown);
|
|
219
|
-
if (tag !== undefined) {
|
|
220
|
-
tags[tag.name] = {
|
|
221
|
-
'id': tag.id,
|
|
222
|
-
'value': tag.value,
|
|
223
|
-
'description': tag.description
|
|
224
|
-
};
|
|
225
|
-
}
|
|
226
|
-
|
|
227
|
-
offset += FIELD_SIZE;
|
|
228
|
-
}
|
|
229
|
-
|
|
230
|
-
if (Constants.USE_THUMBNAIL && (offset < dataView.byteLength - Types.getTypeSize('LONG'))) {
|
|
231
|
-
const nextIfdOffset = Types.getLongAt(dataView, offset, byteOrder);
|
|
232
|
-
if (nextIfdOffset !== 0 && ifdType === IFD_TYPE_0TH) {
|
|
233
|
-
tags['Thumbnail'] = readIfd(dataView, IFD_TYPE_1ST, tiffHeaderOffset, tiffHeaderOffset + nextIfdOffset, byteOrder, true);
|
|
234
|
-
}
|
|
235
|
-
}
|
|
236
|
-
|
|
237
|
-
return tags;
|
|
238
|
-
}
|
|
239
|
-
|
|
240
|
-
function getNumberOfFields(dataView, offset, byteOrder) {
|
|
241
|
-
if (offset + Types.getTypeSize('SHORT') <= dataView.byteLength) {
|
|
242
|
-
return Types.getShortAt(dataView, offset, byteOrder);
|
|
243
|
-
}
|
|
244
|
-
return 0;
|
|
245
|
-
}
|
|
246
|
-
|
|
247
|
-
function readTag(dataView, ifdType, tiffHeaderOffset, offset, byteOrder, includeUnknown) {
|
|
248
|
-
const TAG_CODE_IPTC_NAA = 0x83bb;
|
|
249
|
-
const TAG_TYPE_OFFSET = Types.getTypeSize('SHORT');
|
|
250
|
-
const TAG_COUNT_OFFSET = TAG_TYPE_OFFSET + Types.getTypeSize('SHORT');
|
|
251
|
-
const TAG_VALUE_OFFSET = TAG_COUNT_OFFSET + Types.getTypeSize('LONG');
|
|
252
|
-
|
|
253
|
-
const tagCode = Types.getShortAt(dataView, offset, byteOrder);
|
|
254
|
-
const tagType = Types.getShortAt(dataView, offset + TAG_TYPE_OFFSET, byteOrder);
|
|
255
|
-
const tagCount = Types.getLongAt(dataView, offset + TAG_COUNT_OFFSET, byteOrder);
|
|
256
|
-
let tagValue;
|
|
257
|
-
|
|
258
|
-
if (Types.typeSizes[tagType] === undefined || (!includeUnknown && TagNames[ifdType][tagCode] === undefined)) {
|
|
259
|
-
return undefined;
|
|
260
|
-
}
|
|
261
|
-
|
|
262
|
-
if (tagValueFitsInOffsetSlot(tagType, tagCount)) {
|
|
263
|
-
tagValue = getTagValue(dataView, offset + TAG_VALUE_OFFSET, tagType, tagCount, byteOrder);
|
|
264
|
-
} else {
|
|
265
|
-
const tagValueOffset = Types.getLongAt(dataView, offset + TAG_VALUE_OFFSET, byteOrder);
|
|
266
|
-
if (tagValueFitsInDataView(dataView, tiffHeaderOffset, tagValueOffset, tagType, tagCount)) {
|
|
267
|
-
const forceByteType = tagCode === TAG_CODE_IPTC_NAA;
|
|
268
|
-
tagValue = getTagValue(dataView, tiffHeaderOffset + tagValueOffset, tagType, tagCount, byteOrder, forceByteType);
|
|
269
|
-
} else {
|
|
270
|
-
tagValue = '<faulty value>';
|
|
271
|
-
}
|
|
272
|
-
}
|
|
273
|
-
|
|
274
|
-
if (tagType === Types.tagTypes['ASCII']) {
|
|
275
|
-
tagValue = splitNullSeparatedAsciiString(tagValue);
|
|
276
|
-
tagValue = decodeAsciiValue(tagValue);
|
|
277
|
-
}
|
|
278
|
-
|
|
279
|
-
let tagName = `undefined-${tagCode}`;
|
|
280
|
-
let tagDescription = tagValue;
|
|
281
|
-
|
|
282
|
-
if (TagNames[ifdType][tagCode] !== undefined) {
|
|
283
|
-
if ((TagNames[ifdType][tagCode]['name'] !== undefined) && (TagNames[ifdType][tagCode]['description'] !== undefined)) {
|
|
284
|
-
tagName = TagNames[ifdType][tagCode]['name'];
|
|
285
|
-
try {
|
|
286
|
-
tagDescription = TagNames[ifdType][tagCode]['description'](tagValue);
|
|
287
|
-
} catch (error) {
|
|
288
|
-
tagDescription = getDescriptionFromTagValue(tagValue);
|
|
289
|
-
}
|
|
290
|
-
} else if ((tagType === Types.tagTypes['RATIONAL']) || (tagType === Types.tagTypes['SRATIONAL'])) {
|
|
291
|
-
tagName = TagNames[ifdType][tagCode];
|
|
292
|
-
tagDescription = '' + (tagValue[0] / tagValue[1]);
|
|
293
|
-
} else {
|
|
294
|
-
tagName = TagNames[ifdType][tagCode];
|
|
295
|
-
tagDescription = getDescriptionFromTagValue(tagValue);
|
|
296
|
-
}
|
|
297
|
-
}
|
|
298
|
-
|
|
299
|
-
return {
|
|
300
|
-
id: tagCode,
|
|
301
|
-
name: tagName,
|
|
302
|
-
value: tagValue,
|
|
303
|
-
description: tagDescription
|
|
304
|
-
};
|
|
305
|
-
}
|
|
306
|
-
|
|
307
|
-
function tagValueFitsInOffsetSlot(tagType, tagCount) {
|
|
308
|
-
return Types.typeSizes[tagType] * tagCount <= Types.getTypeSize('LONG');
|
|
309
|
-
}
|
|
310
|
-
|
|
311
|
-
function getTagValue(dataView, offset, type, count, byteOrder, forceByteType = false) {
|
|
312
|
-
let value = [];
|
|
313
|
-
|
|
314
|
-
if (forceByteType) {
|
|
315
|
-
count = count * Types.typeSizes[type];
|
|
316
|
-
type = Types.tagTypes['BYTE'];
|
|
317
|
-
}
|
|
318
|
-
for (let valueIndex = 0; valueIndex < count; valueIndex++) {
|
|
319
|
-
value.push(getTagValueAt[type](dataView, offset, byteOrder));
|
|
320
|
-
offset += Types.typeSizes[type];
|
|
321
|
-
}
|
|
322
|
-
|
|
323
|
-
if (type === Types.tagTypes['ASCII']) {
|
|
324
|
-
value = Types.getAsciiValue(value);
|
|
325
|
-
} else if (value.length === 1) {
|
|
326
|
-
value = value[0];
|
|
327
|
-
}
|
|
328
|
-
|
|
329
|
-
return value;
|
|
330
|
-
}
|
|
331
|
-
|
|
332
|
-
function tagValueFitsInDataView(dataView, tiffHeaderOffset, tagValueOffset, tagType, tagCount) {
|
|
333
|
-
return tiffHeaderOffset + tagValueOffset + Types.typeSizes[tagType] * tagCount <= dataView.byteLength;
|
|
334
|
-
}
|
|
335
|
-
|
|
336
|
-
function splitNullSeparatedAsciiString(string) {
|
|
337
|
-
const tagValue = [];
|
|
338
|
-
let i = 0;
|
|
339
|
-
|
|
340
|
-
for (let j = 0; j < string.length; j++) {
|
|
341
|
-
if (string[j] === '\x00') {
|
|
342
|
-
i++;
|
|
343
|
-
continue;
|
|
344
|
-
}
|
|
345
|
-
if (tagValue[i] === undefined) {
|
|
346
|
-
tagValue[i] = '';
|
|
347
|
-
}
|
|
348
|
-
tagValue[i] += string[j];
|
|
349
|
-
}
|
|
350
|
-
|
|
351
|
-
return tagValue;
|
|
352
|
-
}
|
|
353
|
-
|
|
354
|
-
function decodeAsciiValue(asciiValue) {
|
|
355
|
-
try {
|
|
356
|
-
return asciiValue.map((value) => decodeURIComponent(escape(value)));
|
|
357
|
-
} catch (error) {
|
|
358
|
-
return asciiValue;
|
|
359
|
-
}
|
|
360
|
-
}
|
|
361
|
-
|
|
362
|
-
function getDescriptionFromTagValue(tagValue) {
|
|
363
|
-
if (tagValue instanceof Array) {
|
|
364
|
-
return tagValue.join(', ');
|
|
365
|
-
}
|
|
366
|
-
return tagValue;
|
|
367
|
-
}
|
package/src/utils.js
CHANGED
|
@@ -68,7 +68,7 @@ export function getBase64Image(image) {
|
|
|
68
68
|
if (typeof Buffer === 'undefined') {
|
|
69
69
|
return undefined;
|
|
70
70
|
}
|
|
71
|
-
if (typeof Buffer.from !== undefined) { // eslint-disable-line no-undef
|
|
71
|
+
if (typeof Buffer.from !== 'undefined') { // eslint-disable-line no-undef
|
|
72
72
|
return Buffer.from(image).toString('base64'); // eslint-disable-line no-undef
|
|
73
73
|
}
|
|
74
74
|
return (new Buffer(image)).toString('base64'); // eslint-disable-line no-undef
|
|
@@ -84,7 +84,7 @@ export function dataUriToBuffer(dataUri) {
|
|
|
84
84
|
if (typeof Buffer === 'undefined') {
|
|
85
85
|
return undefined;
|
|
86
86
|
}
|
|
87
|
-
if (typeof Buffer.from !== undefined) { // eslint-disable-line no-undef
|
|
87
|
+
if (typeof Buffer.from !== 'undefined') { // eslint-disable-line no-undef
|
|
88
88
|
return Buffer.from(data, 'base64'); // eslint-disable-line no-undef
|
|
89
89
|
}
|
|
90
90
|
return new Buffer(data, 'base64'); // eslint-disable-line no-undef
|
|
@@ -92,7 +92,7 @@ export function dataUriToBuffer(dataUri) {
|
|
|
92
92
|
|
|
93
93
|
const decodedData = decodeURIComponent(data);
|
|
94
94
|
if (typeof Buffer !== 'undefined') {
|
|
95
|
-
if (typeof Buffer.from !== undefined) { // eslint-disable-line no-undef
|
|
95
|
+
if (typeof Buffer.from !== 'undefined') { // eslint-disable-line no-undef
|
|
96
96
|
return Buffer.from(decodedData); // eslint-disable-line no-undef
|
|
97
97
|
}
|
|
98
98
|
return new Buffer(decodedData); // eslint-disable-line no-undef
|
package/src/xmp-tags.js
CHANGED
|
@@ -221,12 +221,16 @@ function parseNodeAttributesAsTags(attributes) {
|
|
|
221
221
|
const tags = {};
|
|
222
222
|
|
|
223
223
|
for (const name in attributes) {
|
|
224
|
-
|
|
225
|
-
|
|
226
|
-
|
|
227
|
-
|
|
228
|
-
|
|
229
|
-
|
|
224
|
+
try {
|
|
225
|
+
if (isTagAttribute(name)) {
|
|
226
|
+
tags[getLocalName(name)] = {
|
|
227
|
+
value: attributes[name],
|
|
228
|
+
attributes: {},
|
|
229
|
+
description: getDescription(attributes[name], name)
|
|
230
|
+
};
|
|
231
|
+
}
|
|
232
|
+
} catch (error) {
|
|
233
|
+
// Keep going and try to parse the rest of the tags.
|
|
230
234
|
}
|
|
231
235
|
}
|
|
232
236
|
|
|
@@ -321,8 +325,12 @@ function parseNodeChildrenAsTags(children) {
|
|
|
321
325
|
const tags = {};
|
|
322
326
|
|
|
323
327
|
for (const name in children) {
|
|
324
|
-
|
|
325
|
-
|
|
328
|
+
try {
|
|
329
|
+
if (!isNamespaceDefinition(name)) {
|
|
330
|
+
tags[getLocalName(name)] = parseNodeAsTag(children[name], name);
|
|
331
|
+
}
|
|
332
|
+
} catch (error) {
|
|
333
|
+
// Keep going and try to parse the rest of the tags.
|
|
326
334
|
}
|
|
327
335
|
}
|
|
328
336
|
|
|
@@ -330,6 +338,12 @@ function parseNodeChildrenAsTags(children) {
|
|
|
330
338
|
}
|
|
331
339
|
|
|
332
340
|
function parseNodeAsTag(node, name) {
|
|
341
|
+
if (isDuplicateTag(node)) {
|
|
342
|
+
return parseNodeAsDuplicateTag(node, name);
|
|
343
|
+
}
|
|
344
|
+
if (isEmptyResourceTag(node)) {
|
|
345
|
+
return {value: '', attributes: {}, description: ''};
|
|
346
|
+
}
|
|
333
347
|
if (hasNestedSimpleRdfDescription(node)) {
|
|
334
348
|
return parseNodeAsSimpleRdfDescription(node, name);
|
|
335
349
|
}
|
|
@@ -345,6 +359,20 @@ function parseNodeAsTag(node, name) {
|
|
|
345
359
|
return parseNodeAsSimpleValue(node, name);
|
|
346
360
|
}
|
|
347
361
|
|
|
362
|
+
function isEmptyResourceTag(node) {
|
|
363
|
+
return (node.attributes['rdf:parseType'] === 'Resource')
|
|
364
|
+
&& (typeof node.value === 'string')
|
|
365
|
+
&& (node.value.trim() === '');
|
|
366
|
+
}
|
|
367
|
+
|
|
368
|
+
function isDuplicateTag(node) {
|
|
369
|
+
return Array.isArray(node);
|
|
370
|
+
}
|
|
371
|
+
|
|
372
|
+
function parseNodeAsDuplicateTag(node, name) {
|
|
373
|
+
return parseNodeAsSimpleValue(node[node.length - 1], name);
|
|
374
|
+
}
|
|
375
|
+
|
|
348
376
|
function hasNestedSimpleRdfDescription(node) {
|
|
349
377
|
return ((node.attributes['rdf:parseType'] === 'Resource') && (node.value['rdf:value'] !== undefined))
|
|
350
378
|
|| ((node.value['rdf:Description'] !== undefined) && (node.value['rdf:Description'].value['rdf:value'] !== undefined));
|