| 'use strict' |
| |
| const { |
| kState, |
| kError, |
| kResult, |
| kAborted, |
| kLastProgressEventFired |
| } = require('./symbols') |
| const { ProgressEvent } = require('./progressevent') |
| const { getEncoding } = require('./encoding') |
| const { DOMException } = require('../fetch/constants') |
| const { serializeAMimeType, parseMIMEType } = require('../fetch/dataURL') |
| const { types } = require('util') |
| const { StringDecoder } = require('string_decoder') |
| const { btoa } = require('buffer') |
| |
| /** @type {PropertyDescriptor} */ |
| const staticPropertyDescriptors = { |
| enumerable: true, |
| writable: false, |
| configurable: false |
| } |
| |
| /** |
| * @see https://w3c.github.io/FileAPI/#readOperation |
| * @param {import('./filereader').FileReader} fr |
| * @param {import('buffer').Blob} blob |
| * @param {string} type |
| * @param {string?} encodingName |
| */ |
| function readOperation (fr, blob, type, encodingName) { |
| // 1. If fr’s state is "loading", throw an InvalidStateError |
| // DOMException. |
| if (fr[kState] === 'loading') { |
| throw new DOMException('Invalid state', 'InvalidStateError') |
| } |
| |
| // 2. Set fr’s state to "loading". |
| fr[kState] = 'loading' |
| |
| // 3. Set fr’s result to null. |
| fr[kResult] = null |
| |
| // 4. Set fr’s error to null. |
| fr[kError] = null |
| |
| // 5. Let stream be the result of calling get stream on blob. |
| /** @type {import('stream/web').ReadableStream} */ |
| const stream = blob.stream() |
| |
| // 6. Let reader be the result of getting a reader from stream. |
| const reader = stream.getReader() |
| |
| // 7. Let bytes be an empty byte sequence. |
| /** @type {Uint8Array[]} */ |
| const bytes = [] |
| |
| // 8. Let chunkPromise be the result of reading a chunk from |
| // stream with reader. |
| let chunkPromise = reader.read() |
| |
| // 9. Let isFirstChunk be true. |
| let isFirstChunk = true |
| |
| // 10. In parallel, while true: |
| // Note: "In parallel" just means non-blocking |
| // Note 2: readOperation itself cannot be async as double |
| // reading the body would then reject the promise, instead |
| // of throwing an error. |
| ;(async () => { |
| while (!fr[kAborted]) { |
| // 1. Wait for chunkPromise to be fulfilled or rejected. |
| try { |
| const { done, value } = await chunkPromise |
| |
| // 2. If chunkPromise is fulfilled, and isFirstChunk is |
| // true, queue a task to fire a progress event called |
| // loadstart at fr. |
| if (isFirstChunk && !fr[kAborted]) { |
| queueMicrotask(() => { |
| fireAProgressEvent('loadstart', fr) |
| }) |
| } |
| |
| // 3. Set isFirstChunk to false. |
| isFirstChunk = false |
| |
| // 4. If chunkPromise is fulfilled with an object whose |
| // done property is false and whose value property is |
| // a Uint8Array object, run these steps: |
| if (!done && types.isUint8Array(value)) { |
| // 1. Let bs be the byte sequence represented by the |
| // Uint8Array object. |
| |
| // 2. Append bs to bytes. |
| bytes.push(value) |
| |
| // 3. If roughly 50ms have passed since these steps |
| // were last invoked, queue a task to fire a |
| // progress event called progress at fr. |
| if ( |
| ( |
| fr[kLastProgressEventFired] === undefined || |
| Date.now() - fr[kLastProgressEventFired] >= 50 |
| ) && |
| !fr[kAborted] |
| ) { |
| fr[kLastProgressEventFired] = Date.now() |
| queueMicrotask(() => { |
| fireAProgressEvent('progress', fr) |
| }) |
| } |
| |
| // 4. Set chunkPromise to the result of reading a |
| // chunk from stream with reader. |
| chunkPromise = reader.read() |
| } else if (done) { |
| // 5. Otherwise, if chunkPromise is fulfilled with an |
| // object whose done property is true, queue a task |
| // to run the following steps and abort this algorithm: |
| queueMicrotask(() => { |
| // 1. Set fr’s state to "done". |
| fr[kState] = 'done' |
| |
| // 2. Let result be the result of package data given |
| // bytes, type, blob’s type, and encodingName. |
| try { |
| const result = packageData(bytes, type, blob.type, encodingName) |
| |
| // 4. Else: |
| |
| if (fr[kAborted]) { |
| return |
| } |
| |
| // 1. Set fr’s result to result. |
| fr[kResult] = result |
| |
| // 2. Fire a progress event called load at the fr. |
| fireAProgressEvent('load', fr) |
| } catch (error) { |
| // 3. If package data threw an exception error: |
| |
| // 1. Set fr’s error to error. |
| fr[kError] = error |
| |
| // 2. Fire a progress event called error at fr. |
| fireAProgressEvent('error', fr) |
| } |
| |
| // 5. If fr’s state is not "loading", fire a progress |
| // event called loadend at the fr. |
| if (fr[kState] !== 'loading') { |
| fireAProgressEvent('loadend', fr) |
| } |
| }) |
| |
| break |
| } |
| } catch (error) { |
| if (fr[kAborted]) { |
| return |
| } |
| |
| // 6. Otherwise, if chunkPromise is rejected with an |
| // error error, queue a task to run the following |
| // steps and abort this algorithm: |
| queueMicrotask(() => { |
| // 1. Set fr’s state to "done". |
| fr[kState] = 'done' |
| |
| // 2. Set fr’s error to error. |
| fr[kError] = error |
| |
| // 3. Fire a progress event called error at fr. |
| fireAProgressEvent('error', fr) |
| |
| // 4. If fr’s state is not "loading", fire a progress |
| // event called loadend at fr. |
| if (fr[kState] !== 'loading') { |
| fireAProgressEvent('loadend', fr) |
| } |
| }) |
| |
| break |
| } |
| } |
| })() |
| } |
| |
| /** |
| * @see https://w3c.github.io/FileAPI/#fire-a-progress-event |
| * @see https://dom.spec.whatwg.org/#concept-event-fire |
| * @param {string} e The name of the event |
| * @param {import('./filereader').FileReader} reader |
| */ |
| function fireAProgressEvent (e, reader) { |
| // The progress event e does not bubble. e.bubbles must be false |
| // The progress event e is NOT cancelable. e.cancelable must be false |
| const event = new ProgressEvent(e, { |
| bubbles: false, |
| cancelable: false |
| }) |
| |
| reader.dispatchEvent(event) |
| } |
| |
| /** |
| * @see https://w3c.github.io/FileAPI/#blob-package-data |
| * @param {Uint8Array[]} bytes |
| * @param {string} type |
| * @param {string?} mimeType |
| * @param {string?} encodingName |
| */ |
| function packageData (bytes, type, mimeType, encodingName) { |
| // 1. A Blob has an associated package data algorithm, given |
| // bytes, a type, a optional mimeType, and a optional |
| // encodingName, which switches on type and runs the |
| // associated steps: |
| |
| switch (type) { |
| case 'DataURL': { |
| // 1. Return bytes as a DataURL [RFC2397] subject to |
| // the considerations below: |
| // * Use mimeType as part of the Data URL if it is |
| // available in keeping with the Data URL |
| // specification [RFC2397]. |
| // * If mimeType is not available return a Data URL |
| // without a media-type. [RFC2397]. |
| |
| // https://datatracker.ietf.org/doc/html/rfc2397#section-3 |
| // dataurl := "data:" [ mediatype ] [ ";base64" ] "," data |
| // mediatype := [ type "/" subtype ] *( ";" parameter ) |
| // data := *urlchar |
| // parameter := attribute "=" value |
| let dataURL = 'data:' |
| |
| const parsed = parseMIMEType(mimeType || 'application/octet-stream') |
| |
| if (parsed !== 'failure') { |
| dataURL += serializeAMimeType(parsed) |
| } |
| |
| dataURL += ';base64,' |
| |
| const decoder = new StringDecoder('latin1') |
| |
| for (const chunk of bytes) { |
| dataURL += btoa(decoder.write(chunk)) |
| } |
| |
| dataURL += btoa(decoder.end()) |
| |
| return dataURL |
| } |
| case 'Text': { |
| // 1. Let encoding be failure |
| let encoding = 'failure' |
| |
| // 2. If the encodingName is present, set encoding to the |
| // result of getting an encoding from encodingName. |
| if (encodingName) { |
| encoding = getEncoding(encodingName) |
| } |
| |
| // 3. If encoding is failure, and mimeType is present: |
| if (encoding === 'failure' && mimeType) { |
| // 1. Let type be the result of parse a MIME type |
| // given mimeType. |
| const type = parseMIMEType(mimeType) |
| |
| // 2. If type is not failure, set encoding to the result |
| // of getting an encoding from type’s parameters["charset"]. |
| if (type !== 'failure') { |
| encoding = getEncoding(type.parameters.get('charset')) |
| } |
| } |
| |
| // 4. If encoding is failure, then set encoding to UTF-8. |
| if (encoding === 'failure') { |
| encoding = 'UTF-8' |
| } |
| |
| // 5. Decode bytes using fallback encoding encoding, and |
| // return the result. |
| return decode(bytes, encoding) |
| } |
| case 'ArrayBuffer': { |
| // Return a new ArrayBuffer whose contents are bytes. |
| const sequence = combineByteSequences(bytes) |
| |
| return sequence.buffer |
| } |
| case 'BinaryString': { |
| // Return bytes as a binary string, in which every byte |
| // is represented by a code unit of equal value [0..255]. |
| let binaryString = '' |
| |
| const decoder = new StringDecoder('latin1') |
| |
| for (const chunk of bytes) { |
| binaryString += decoder.write(chunk) |
| } |
| |
| binaryString += decoder.end() |
| |
| return binaryString |
| } |
| } |
| } |
| |
| /** |
| * @see https://encoding.spec.whatwg.org/#decode |
| * @param {Uint8Array[]} ioQueue |
| * @param {string} encoding |
| */ |
| function decode (ioQueue, encoding) { |
| const bytes = combineByteSequences(ioQueue) |
| |
| // 1. Let BOMEncoding be the result of BOM sniffing ioQueue. |
| const BOMEncoding = BOMSniffing(bytes) |
| |
| let slice = 0 |
| |
| // 2. If BOMEncoding is non-null: |
| if (BOMEncoding !== null) { |
| // 1. Set encoding to BOMEncoding. |
| encoding = BOMEncoding |
| |
| // 2. Read three bytes from ioQueue, if BOMEncoding is |
| // UTF-8; otherwise read two bytes. |
| // (Do nothing with those bytes.) |
| slice = BOMEncoding === 'UTF-8' ? 3 : 2 |
| } |
| |
| // 3. Process a queue with an instance of encoding’s |
| // decoder, ioQueue, output, and "replacement". |
| |
| // 4. Return output. |
| |
| const sliced = bytes.slice(slice) |
| return new TextDecoder(encoding).decode(sliced) |
| } |
| |
| /** |
| * @see https://encoding.spec.whatwg.org/#bom-sniff |
| * @param {Uint8Array} ioQueue |
| */ |
| function BOMSniffing (ioQueue) { |
| // 1. Let BOM be the result of peeking 3 bytes from ioQueue, |
| // converted to a byte sequence. |
| const [a, b, c] = ioQueue |
| |
| // 2. For each of the rows in the table below, starting with |
| // the first one and going down, if BOM starts with the |
| // bytes given in the first column, then return the |
| // encoding given in the cell in the second column of that |
| // row. Otherwise, return null. |
| if (a === 0xEF && b === 0xBB && c === 0xBF) { |
| return 'UTF-8' |
| } else if (a === 0xFE && b === 0xFF) { |
| return 'UTF-16BE' |
| } else if (a === 0xFF && b === 0xFE) { |
| return 'UTF-16LE' |
| } |
| |
| return null |
| } |
| |
| /** |
| * @param {Uint8Array[]} sequences |
| */ |
| function combineByteSequences (sequences) { |
| const size = sequences.reduce((a, b) => { |
| return a + b.byteLength |
| }, 0) |
| |
| let offset = 0 |
| |
| return sequences.reduce((a, b) => { |
| a.set(b, offset) |
| offset += b.byteLength |
| return a |
| }, new Uint8Array(size)) |
| } |
| |
| module.exports = { |
| staticPropertyDescriptors, |
| readOperation, |
| fireAProgressEvent |
| } |
