exifreader 4.39.1 → 4.40.1
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 +324 -166
- package/bin/profile-diff.js +171 -0
- package/bin/profile.js +852 -0
- package/dist/exif-reader.js +1 -1
- package/dist/exif-reader.js.map +1 -1
- package/exif-reader.d.ts +53 -10
- package/package.json +7 -7
- package/src/exif-reader.js +50 -143
- package/src/file-loaders.js +313 -0
- package/src/image-header-avif.js +8 -5
- package/src/image-header-gif.js +21 -1
- package/src/image-header-heic.js +8 -5
- package/src/image-header-iso-bmff-utils.js +11 -0
- package/src/image-header-iso-bmff.js +226 -53
- package/src/image-header-jpeg.js +53 -1
- package/src/image-header-jxl.js +63 -12
- package/src/image-header-png.js +68 -17
- package/src/image-header-webp.js +32 -2
- package/src/image-header.js +32 -12
- package/src/load-auto.js +305 -0
- package/src/loadview-pipeline.js +66 -1
- package/src/mpf-tags.js +19 -15
- package/src/pentax-tags.js +26 -22
- package/src/utils.js +3 -1
- package/src/vp8x-tags.js +5 -0
- package/src/xml.js +39 -1
|
@@ -0,0 +1,313 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* ExifReader
|
|
3
|
+
* http://github.com/mattiasw/exifreader
|
|
4
|
+
* Copyright (C) 2011-2026 Mattias Wallander <mattias@wallander.eu>
|
|
5
|
+
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
6
|
+
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
7
|
+
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
|
|
8
|
+
*/
|
|
9
|
+
/* global Buffer, __non_webpack_require__ */
|
|
10
|
+
|
|
11
|
+
import {dataUriToBuffer} from './utils.js';
|
|
12
|
+
|
|
13
|
+
export const HTTP_STATUS_OK = 200;
|
|
14
|
+
export const HTTP_STATUS_SUCCESS_MAX = 299;
|
|
15
|
+
export const HTTP_STATUS_RANGE_NOT_SATISFIABLE = 416;
|
|
16
|
+
|
|
17
|
+
export function isFilePathOrURL(data) {
|
|
18
|
+
return typeof data === 'string';
|
|
19
|
+
}
|
|
20
|
+
|
|
21
|
+
export function isBrowserFileObject(data) {
|
|
22
|
+
return (typeof File !== 'undefined') && (data instanceof File);
|
|
23
|
+
}
|
|
24
|
+
|
|
25
|
+
export function isDataUri(filename) {
|
|
26
|
+
return /^data:[^;,]*(;base64)?,/.test(filename);
|
|
27
|
+
}
|
|
28
|
+
|
|
29
|
+
/**
|
|
30
|
+
* Routes URL / data-URI / file path to the right range-aware primitive and
|
|
31
|
+
* resolves with a plain buffer. Used by the numeric-`length` code path
|
|
32
|
+
* in `load()`.
|
|
33
|
+
*
|
|
34
|
+
* @param {string} filename URL, data URI, or local file path.
|
|
35
|
+
* @param {{length?: number}} [options]
|
|
36
|
+
* @returns {Promise<ArrayBuffer|Buffer>} The whole file, or its first `length` bytes if specified.
|
|
37
|
+
*/
|
|
38
|
+
export function loadFile(filename, options) {
|
|
39
|
+
if (/^\w+:\/\//.test(filename)) {
|
|
40
|
+
if (typeof fetch !== 'undefined') {
|
|
41
|
+
return fetchRange(filename, legacyRange(options)).then((r) => r.buffer);
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
return nodeGetRange(filename, legacyRange(options)).then((r) => r.buffer);
|
|
45
|
+
}
|
|
46
|
+
|
|
47
|
+
if (isDataUri(filename)) {
|
|
48
|
+
return Promise.resolve(dataUriToBuffer(filename));
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
return readLocalFileRange(filename, legacyRange(options)).then((r) => r.buffer);
|
|
52
|
+
}
|
|
53
|
+
|
|
54
|
+
/**
|
|
55
|
+
* Browser `File` equivalent of `loadFile`. Used by the numeric-`length`
|
|
56
|
+
* code path in `load()`.
|
|
57
|
+
*
|
|
58
|
+
* @param {File} file
|
|
59
|
+
* @param {{length?: number}} [options]
|
|
60
|
+
* @returns {Promise<ArrayBuffer>}
|
|
61
|
+
*/
|
|
62
|
+
export function loadFileObject(file, options) {
|
|
63
|
+
return readFileObjectRange(file, legacyRange(options)).then((r) => r.buffer);
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
function legacyRange(options) {
|
|
67
|
+
if (options && Number.isInteger(options.length) && options.length >= 0) {
|
|
68
|
+
return {start: 0, end: options.length};
|
|
69
|
+
}
|
|
70
|
+
return {start: 0};
|
|
71
|
+
}
|
|
72
|
+
|
|
73
|
+
/**
|
|
74
|
+
* Range-aware browser `fetch`. Sets an HTTP `Range` header when the
|
|
75
|
+
* requested range is not the whole file.
|
|
76
|
+
*
|
|
77
|
+
* @param {string} url
|
|
78
|
+
* @param {{start?: number, end?: number}} [range] `end` is exclusive. Omit (or pass `Infinity`) to read to EOF.
|
|
79
|
+
* @returns {Promise<{buffer: ArrayBuffer, totalSize: number|undefined, status: number|undefined}>}
|
|
80
|
+
* `totalSize` is taken from the `Content-Range` or `Content-Length` response header when present.
|
|
81
|
+
*/
|
|
82
|
+
export function fetchRange(url, {start = 0, end} = {}) {
|
|
83
|
+
const options = {method: 'GET'};
|
|
84
|
+
if (start > 0 || (end !== undefined && end !== Infinity)) {
|
|
85
|
+
options.headers = {range: buildRangeHeader(start, end)};
|
|
86
|
+
}
|
|
87
|
+
return fetch(url, options).then((response) => {
|
|
88
|
+
const totalSize = totalSizeFromFetchResponse(response);
|
|
89
|
+
const status = response && typeof response.status === 'number' ? response.status : undefined;
|
|
90
|
+
return Promise.resolve(response.arrayBuffer()).then((buffer) => ({buffer, totalSize, status}));
|
|
91
|
+
});
|
|
92
|
+
}
|
|
93
|
+
|
|
94
|
+
function buildRangeHeader(start, end) {
|
|
95
|
+
if (end === undefined || end === Infinity) {
|
|
96
|
+
return `bytes=${start}-`;
|
|
97
|
+
}
|
|
98
|
+
return `bytes=${start}-${end - 1}`;
|
|
99
|
+
}
|
|
100
|
+
|
|
101
|
+
function totalSizeFromFetchResponse(response) {
|
|
102
|
+
if (!response || !response.headers || typeof response.headers.get !== 'function') {
|
|
103
|
+
return undefined;
|
|
104
|
+
}
|
|
105
|
+
const contentRange = response.headers.get('Content-Range');
|
|
106
|
+
if (contentRange) {
|
|
107
|
+
const match = /\/(\d+|\*)$/.exec(contentRange);
|
|
108
|
+
if (match && match[1] !== '*') {
|
|
109
|
+
return parseInt(match[1], 10);
|
|
110
|
+
}
|
|
111
|
+
}
|
|
112
|
+
const contentLength = response.headers.get('Content-Length');
|
|
113
|
+
if (contentLength) {
|
|
114
|
+
const n = parseInt(contentLength, 10);
|
|
115
|
+
if (Number.isFinite(n)) {
|
|
116
|
+
return n;
|
|
117
|
+
}
|
|
118
|
+
}
|
|
119
|
+
return undefined;
|
|
120
|
+
}
|
|
121
|
+
|
|
122
|
+
/**
|
|
123
|
+
* Range-aware Node `http(s).get`. Same contract as `fetchRange`. Rejects
|
|
124
|
+
* on non-2xx responses with the status line in the error message.
|
|
125
|
+
*
|
|
126
|
+
* @param {string} url
|
|
127
|
+
* @param {{start?: number, end?: number}} [range] `end` is exclusive. Omit (or pass `Infinity`) to read to EOF.
|
|
128
|
+
* @returns {Promise<{buffer: Buffer, totalSize: number|undefined, status: number|undefined}>}
|
|
129
|
+
*/
|
|
130
|
+
export function nodeGetRange(url, {start = 0, end} = {}) {
|
|
131
|
+
return new Promise((resolve, reject) => {
|
|
132
|
+
const options = {};
|
|
133
|
+
if (start > 0 || (end !== undefined && end !== Infinity)) {
|
|
134
|
+
options.headers = {range: buildRangeHeader(start, end)};
|
|
135
|
+
}
|
|
136
|
+
|
|
137
|
+
const get = requireNodeGet(url);
|
|
138
|
+
get(url, options, (response) => {
|
|
139
|
+
if ((response.statusCode >= HTTP_STATUS_OK) && (response.statusCode <= HTTP_STATUS_SUCCESS_MAX)) {
|
|
140
|
+
const totalSize = totalSizeFromNodeResponse(response);
|
|
141
|
+
const data = [];
|
|
142
|
+
response.on('data', (chunk) => data.push(Buffer.from(chunk)));
|
|
143
|
+
response.on('error', (error) => reject(error));
|
|
144
|
+
response.on('end', () => resolve({
|
|
145
|
+
buffer: Buffer.concat(data),
|
|
146
|
+
totalSize,
|
|
147
|
+
status: response.statusCode,
|
|
148
|
+
}));
|
|
149
|
+
} else if (response.statusCode === HTTP_STATUS_RANGE_NOT_SATISFIABLE) {
|
|
150
|
+
// Resolve (rather than reject) so the adaptive `length: 'auto'`
|
|
151
|
+
// loop can fall back to a full read, mirroring the fetch path.
|
|
152
|
+
response.resume();
|
|
153
|
+
resolve({buffer: Buffer.alloc(0), totalSize: totalSizeFromNodeResponse(response), status: response.statusCode});
|
|
154
|
+
} else {
|
|
155
|
+
reject(`Could not fetch file: ${response.statusCode} ${response.statusMessage}`);
|
|
156
|
+
response.resume();
|
|
157
|
+
}
|
|
158
|
+
}).on('error', (error) => reject(error));
|
|
159
|
+
});
|
|
160
|
+
}
|
|
161
|
+
|
|
162
|
+
function totalSizeFromNodeResponse(response) {
|
|
163
|
+
if (!response || !response.headers) {
|
|
164
|
+
return undefined;
|
|
165
|
+
}
|
|
166
|
+
const contentRange = response.headers['content-range'];
|
|
167
|
+
if (contentRange) {
|
|
168
|
+
const match = /\/(\d+|\*)$/.exec(contentRange);
|
|
169
|
+
if (match && match[1] !== '*') {
|
|
170
|
+
return parseInt(match[1], 10);
|
|
171
|
+
}
|
|
172
|
+
}
|
|
173
|
+
const contentLength = response.headers['content-length'];
|
|
174
|
+
if (contentLength) {
|
|
175
|
+
const n = parseInt(contentLength, 10);
|
|
176
|
+
if (Number.isFinite(n)) {
|
|
177
|
+
return n;
|
|
178
|
+
}
|
|
179
|
+
}
|
|
180
|
+
return undefined;
|
|
181
|
+
}
|
|
182
|
+
|
|
183
|
+
function requireNodeGet(url) {
|
|
184
|
+
if (/^https:\/\//.test(url)) {
|
|
185
|
+
return __non_webpack_require__('https').get;
|
|
186
|
+
}
|
|
187
|
+
return __non_webpack_require__('http').get;
|
|
188
|
+
}
|
|
189
|
+
|
|
190
|
+
/**
|
|
191
|
+
* Range-aware local file reader (Node `fs`). Opens, reads `[start, end)`,
|
|
192
|
+
* closes.
|
|
193
|
+
*
|
|
194
|
+
* @param {string} filename
|
|
195
|
+
* @param {{start?: number, end?: number, totalSize?: number}} [options]
|
|
196
|
+
* Pass `totalSize` (a previously-`stat`-ed size) to skip the
|
|
197
|
+
* `fs.stat` call on subsequent reads of the same file.
|
|
198
|
+
* @returns {Promise<{buffer: Buffer, totalSize: number}>}
|
|
199
|
+
*/
|
|
200
|
+
export function readLocalFileRange(filename, {start = 0, end, totalSize} = {}) {
|
|
201
|
+
return new Promise((resolve, reject) => {
|
|
202
|
+
const fs = requireNodeFs();
|
|
203
|
+
fs.open(filename, (openErr, fd) => {
|
|
204
|
+
if (openErr) {
|
|
205
|
+
return reject(openErr);
|
|
206
|
+
}
|
|
207
|
+
resolveTotalSize(fs, filename, totalSize, (statErr, total) => {
|
|
208
|
+
if (statErr) {
|
|
209
|
+
return fs.close(fd, () => reject(statErr));
|
|
210
|
+
}
|
|
211
|
+
const effectiveEnd = (end === undefined || end === Infinity || end > total) ? total : end;
|
|
212
|
+
const effectiveStart = Math.min(Math.max(0, start), effectiveEnd);
|
|
213
|
+
const size = effectiveEnd - effectiveStart;
|
|
214
|
+
const buffer = Buffer.alloc(size);
|
|
215
|
+
if (size === 0) {
|
|
216
|
+
return fs.close(fd, (closeErr) => finishLocalRead(filename, closeErr, buffer, total, resolve));
|
|
217
|
+
}
|
|
218
|
+
fs.read(fd, {buffer, length: size, position: effectiveStart}, (readErr) => {
|
|
219
|
+
if (readErr) {
|
|
220
|
+
return fs.close(fd, () => reject(readErr));
|
|
221
|
+
}
|
|
222
|
+
fs.close(fd, (closeErr) => finishLocalRead(filename, closeErr, buffer, total, resolve));
|
|
223
|
+
});
|
|
224
|
+
});
|
|
225
|
+
});
|
|
226
|
+
});
|
|
227
|
+
}
|
|
228
|
+
|
|
229
|
+
function resolveTotalSize(fs, filename, totalSize, cb) {
|
|
230
|
+
if (totalSize !== undefined) {
|
|
231
|
+
return cb(null, totalSize);
|
|
232
|
+
}
|
|
233
|
+
fs.stat(filename, (err, stat) => cb(err, err ? undefined : stat.size));
|
|
234
|
+
}
|
|
235
|
+
|
|
236
|
+
function finishLocalRead(filename, closeErr, buffer, total, resolve) {
|
|
237
|
+
if (closeErr) {
|
|
238
|
+
console.warn(`Could not close file ${filename}:`, closeErr); // eslint-disable-line no-console
|
|
239
|
+
}
|
|
240
|
+
resolve({buffer, totalSize: total});
|
|
241
|
+
}
|
|
242
|
+
|
|
243
|
+
function requireNodeFs() {
|
|
244
|
+
try {
|
|
245
|
+
return __non_webpack_require__('fs');
|
|
246
|
+
} catch (error) {
|
|
247
|
+
return undefined;
|
|
248
|
+
}
|
|
249
|
+
}
|
|
250
|
+
|
|
251
|
+
/**
|
|
252
|
+
* Range-aware browser `File` reader. Uses `file.slice(start, end)` plus
|
|
253
|
+
* `FileReader.readAsArrayBuffer`.
|
|
254
|
+
*
|
|
255
|
+
* @param {File} file
|
|
256
|
+
* @param {{start?: number, end?: number}} [range]
|
|
257
|
+
* @returns {Promise<{buffer: ArrayBuffer, totalSize: number|undefined}>}
|
|
258
|
+
*/
|
|
259
|
+
export function readFileObjectRange(file, {start = 0, end} = {}) {
|
|
260
|
+
return new Promise((resolve, reject) => {
|
|
261
|
+
const reader = new FileReader();
|
|
262
|
+
const totalSize = typeof file.size === 'number' ? file.size : undefined;
|
|
263
|
+
reader.onload = (readerEvent) => resolve({buffer: readerEvent.target.result, totalSize});
|
|
264
|
+
reader.onerror = () => reject(reader.error);
|
|
265
|
+
const hasSlice = file && typeof file.slice === 'function';
|
|
266
|
+
if (hasSlice && (start > 0 || (end !== undefined && end !== Infinity))) {
|
|
267
|
+
const sliceEnd = (end === undefined || end === Infinity) ? totalSize : end;
|
|
268
|
+
reader.readAsArrayBuffer(file.slice(start, sliceEnd));
|
|
269
|
+
} else {
|
|
270
|
+
reader.readAsArrayBuffer(file);
|
|
271
|
+
}
|
|
272
|
+
});
|
|
273
|
+
}
|
|
274
|
+
|
|
275
|
+
/**
|
|
276
|
+
* Concatenate two buffers. Returns a Node `Buffer` when both arguments
|
|
277
|
+
* are Buffers, otherwise an `ArrayBuffer`. Either argument may be
|
|
278
|
+
* nullish, in which case the other is returned as-is.
|
|
279
|
+
*
|
|
280
|
+
* @param {ArrayBuffer|Buffer|null|undefined} a
|
|
281
|
+
* @param {ArrayBuffer|Buffer|null|undefined} b
|
|
282
|
+
* @returns {ArrayBuffer|Buffer}
|
|
283
|
+
*/
|
|
284
|
+
export function concatBuffers(a, b) {
|
|
285
|
+
if (!a) {
|
|
286
|
+
return b;
|
|
287
|
+
}
|
|
288
|
+
if (!b) {
|
|
289
|
+
return a;
|
|
290
|
+
}
|
|
291
|
+
if (typeof Buffer !== 'undefined' && Buffer.isBuffer(a) && Buffer.isBuffer(b)) {
|
|
292
|
+
return Buffer.concat([a, b]);
|
|
293
|
+
}
|
|
294
|
+
const aBytes = bufferToBytes(a);
|
|
295
|
+
const bBytes = bufferToBytes(b);
|
|
296
|
+
const out = new Uint8Array(aBytes.byteLength + bBytes.byteLength);
|
|
297
|
+
out.set(aBytes, 0);
|
|
298
|
+
out.set(bBytes, aBytes.byteLength);
|
|
299
|
+
return out.buffer;
|
|
300
|
+
}
|
|
301
|
+
|
|
302
|
+
function bufferToBytes(b) {
|
|
303
|
+
if (b instanceof ArrayBuffer) {
|
|
304
|
+
return new Uint8Array(b);
|
|
305
|
+
}
|
|
306
|
+
if (typeof Buffer !== 'undefined' && Buffer.isBuffer(b)) {
|
|
307
|
+
return new Uint8Array(b.buffer, b.byteOffset, b.byteLength);
|
|
308
|
+
}
|
|
309
|
+
if (ArrayBuffer.isView(b)) {
|
|
310
|
+
return new Uint8Array(b.buffer, b.byteOffset, b.byteLength);
|
|
311
|
+
}
|
|
312
|
+
return new Uint8Array(b);
|
|
313
|
+
}
|
package/src/image-header-avif.js
CHANGED
|
@@ -25,7 +25,7 @@ function isAvifFile(dataView) {
|
|
|
25
25
|
|
|
26
26
|
try {
|
|
27
27
|
const headerBox = parseBox(dataView, 0);
|
|
28
|
-
return headerBox && headerBox.majorBrand === 'avif';
|
|
28
|
+
return headerBox !== undefined && headerBox.majorBrand === 'avif';
|
|
29
29
|
} catch (error) {
|
|
30
30
|
return false;
|
|
31
31
|
}
|
|
@@ -34,9 +34,12 @@ function isAvifFile(dataView) {
|
|
|
34
34
|
/**
|
|
35
35
|
* Finds the offsets of an AVIF file in the provided data view.
|
|
36
36
|
*
|
|
37
|
-
* @param {DataView} dataView
|
|
38
|
-
* @
|
|
37
|
+
* @param {DataView} dataView The data view to find offsets in.
|
|
38
|
+
* @param {Array<Object>=} metadataBlocks Optional out-array. Forwarded to
|
|
39
|
+
* the shared ISO-BMFF findOffsets.
|
|
40
|
+
* @returns {Object} TIFF header offset, XMP chunks, ICC chunks, and whether
|
|
41
|
+
* any were found.
|
|
39
42
|
*/
|
|
40
|
-
function findAvifOffsets(dataView) {
|
|
41
|
-
return findOffsets(dataView);
|
|
43
|
+
function findAvifOffsets(dataView, metadataBlocks) {
|
|
44
|
+
return findOffsets(dataView, metadataBlocks);
|
|
42
45
|
}
|
package/src/image-header-gif.js
CHANGED
|
@@ -12,11 +12,31 @@ export default {
|
|
|
12
12
|
const GIF_SIGNATURE_SIZE = 6;
|
|
13
13
|
const GIF_SIGNATURES = ['GIF87a', 'GIF89a'];
|
|
14
14
|
|
|
15
|
+
// 6-byte signature plus 7-byte logical screen descriptor.
|
|
16
|
+
const GIF_HEADER_SIZE = 13;
|
|
17
|
+
|
|
18
|
+
/**
|
|
19
|
+
* Checks if the provided data view represents a GIF file.
|
|
20
|
+
*
|
|
21
|
+
* @param {DataView} dataView The data view to check.
|
|
22
|
+
* @returns {boolean} True if the data view starts with a GIF signature.
|
|
23
|
+
*/
|
|
15
24
|
function isGifFile(dataView) {
|
|
16
25
|
return !!dataView && GIF_SIGNATURES.includes(getStringFromDataView(dataView, 0, GIF_SIGNATURE_SIZE));
|
|
17
26
|
}
|
|
18
27
|
|
|
19
|
-
|
|
28
|
+
/**
|
|
29
|
+
* Finds the GIF logical screen descriptor offset.
|
|
30
|
+
*
|
|
31
|
+
* @param {DataView} _dataView The data view (unused).
|
|
32
|
+
* @param {Array<Object>=} metadataBlocks Optional out-array. When provided,
|
|
33
|
+
* receives one `gif` block covering the GIF header bytes.
|
|
34
|
+
* @returns {{gifHeaderOffset: number}}
|
|
35
|
+
*/
|
|
36
|
+
function findOffsets(_dataView, metadataBlocks) {
|
|
37
|
+
if (metadataBlocks) {
|
|
38
|
+
metadataBlocks.push({type: 'gif', start: 0, end: GIF_HEADER_SIZE});
|
|
39
|
+
}
|
|
20
40
|
return {
|
|
21
41
|
gifHeaderOffset: 0
|
|
22
42
|
};
|
package/src/image-header-heic.js
CHANGED
|
@@ -24,7 +24,7 @@ function isHeicFile(dataView) {
|
|
|
24
24
|
|
|
25
25
|
try {
|
|
26
26
|
const headerBox = parseBox(dataView, 0);
|
|
27
|
-
return headerBox && HEIC_MAJOR_BRANDS.indexOf(headerBox.majorBrand) !== -1;
|
|
27
|
+
return headerBox !== undefined && HEIC_MAJOR_BRANDS.indexOf(headerBox.majorBrand) !== -1;
|
|
28
28
|
} catch (error) {
|
|
29
29
|
return false;
|
|
30
30
|
}
|
|
@@ -33,9 +33,12 @@ function isHeicFile(dataView) {
|
|
|
33
33
|
/**
|
|
34
34
|
* Finds the offsets of a HEIC file in the provided data view.
|
|
35
35
|
*
|
|
36
|
-
* @param {DataView} dataView
|
|
37
|
-
* @
|
|
36
|
+
* @param {DataView} dataView The data view to find offsets in.
|
|
37
|
+
* @param {Array<Object>=} metadataBlocks Optional out-array. Forwarded to
|
|
38
|
+
* the shared ISO-BMFF findOffsets.
|
|
39
|
+
* @returns {Object} TIFF header offset, XMP chunks, ICC chunks, and whether
|
|
40
|
+
* any were found.
|
|
38
41
|
*/
|
|
39
|
-
function findHeicOffsets(dataView) {
|
|
40
|
-
return findOffsets(dataView);
|
|
42
|
+
function findHeicOffsets(dataView, metadataBlocks) {
|
|
43
|
+
return findOffsets(dataView, metadataBlocks);
|
|
41
44
|
}
|
|
@@ -3,3 +3,14 @@ export function get64BitValue(dataView, offset) {
|
|
|
3
3
|
// wait until there are real-world examples where it is necessary.
|
|
4
4
|
return dataView.getUint32(offset + 4);
|
|
5
5
|
}
|
|
6
|
+
|
|
7
|
+
/**
|
|
8
|
+
* @param {DataView} dataView
|
|
9
|
+
* @param {number} offset
|
|
10
|
+
* @param {number} length
|
|
11
|
+
* @returns {boolean} Whether [offset, offset + length) is within the DataView,
|
|
12
|
+
* i.e. those bytes can be read without a RangeError.
|
|
13
|
+
*/
|
|
14
|
+
export function hasBytes(dataView, offset, length) {
|
|
15
|
+
return offset + length <= dataView.byteLength;
|
|
16
|
+
}
|