@gjsify/fetch 0.0.4 → 0.1.1

package/lib/utils/multipart-parser.js

@@ -0,0 +1,396 @@
+import { File } from './blob-from.js';
+import { FormData } from '@gjsify/formdata';
+// let s = 0;
+// const S = {
+// 	START_BOUNDARY: s++,
+// 	HEADER_FIELD_START: s++,
+// 	HEADER_FIELD: s++,
+// 	HEADER_VALUE_START: s++,
+// 	HEADER_VALUE: s++,
+// 	HEADER_VALUE_ALMOST_DONE: s++,
+// 	HEADERS_ALMOST_DONE: s++,
+// 	PART_DATA_START: s++,
+// 	PART_DATA: s++,
+// 	END: s++
+// };
+var S;
+(function (S) {
+    S[S["START_BOUNDARY"] = 0] = "START_BOUNDARY";
+    S[S["HEADER_FIELD_START"] = 1] = "HEADER_FIELD_START";
+    S[S["HEADER_FIELD"] = 2] = "HEADER_FIELD";
+    S[S["HEADER_VALUE_START"] = 3] = "HEADER_VALUE_START";
+    S[S["HEADER_VALUE"] = 4] = "HEADER_VALUE";
+    S[S["HEADER_VALUE_ALMOST_DONE"] = 5] = "HEADER_VALUE_ALMOST_DONE";
+    S[S["HEADERS_ALMOST_DONE"] = 6] = "HEADERS_ALMOST_DONE";
+    S[S["PART_DATA_START"] = 7] = "PART_DATA_START";
+    S[S["PART_DATA"] = 8] = "PART_DATA";
+    S[S["END"] = 9] = "END";
+})(S || (S = {}));
+let f = 1;
+const F = {
+    PART_BOUNDARY: f,
+    LAST_BOUNDARY: f *= 2
+};
+const LF = 10;
+const CR = 13;
+const SPACE = 32;
+const HYPHEN = 45;
+const COLON = 58;
+const A = 97;
+const Z = 122;
+const lower = c => c | 0x20;
+const noop = (..._args) => { };
+class MultipartParser {
+    index = 0;
+    flags = 0;
+    boundary;
+    lookbehind;
+    state = S.START_BOUNDARY;
+    onHeaderEnd = noop;
+    onHeaderField = noop;
+    onHeadersEnd = noop;
+    onHeaderValue = noop;
+    onPartBegin = noop;
+    onPartData = noop;
+    onPartEnd = noop;
+    boundaryChars = {};
+    /**
+     * @param boundary
+     */
+    constructor(boundary) {
+        boundary = '\r\n--' + boundary;
+        const ui8a = new Uint8Array(boundary.length);
+        for (let i = 0; i < boundary.length; i++) {
+            ui8a[i] = boundary.charCodeAt(i);
+            this.boundaryChars[ui8a[i]] = true;
+        }
+        this.boundary = ui8a;
+        this.lookbehind = new Uint8Array(this.boundary.length + 8);
+    }
+    /**
+     * @param data
+     */
+    write(data) {
+        let i = 0;
+        const length_ = data.length;
+        let previousIndex = this.index;
+        let { lookbehind, boundary, boundaryChars, index, state, flags } = this;
+        const boundaryLength = this.boundary.length;
+        const boundaryEnd = boundaryLength - 1;
+        const bufferLength = data.length;
+        let c;
+        let cl;
+        const mark = (name) => {
+            this[name + 'Mark'] = i;
+        };
+        const clear = (name) => {
+            delete this[name + 'Mark'];
+        };
+        const callback = (callbackSymbol, start, end, ui8a) => {
+            if (start === undefined || start !== end) {
+                this[callbackSymbol](ui8a && ui8a.subarray(start, end));
+            }
+        };
+        const dataCallback = (name, clear = false) => {
+            const markSymbol = name + 'Mark';
+            if (!(markSymbol in this)) {
+                return;
+            }
+            if (clear) {
+                callback(name, this[markSymbol], i, data);
+                delete this[markSymbol];
+            }
+            else {
+                callback(name, this[markSymbol], data.length, data);
+                this[markSymbol] = 0;
+            }
+        };
+        for (i = 0; i < length_; i++) {
+            c = data[i];
+            switch (state) {
+                case S.START_BOUNDARY:
+                    if (index === boundary.length - 2) {
+                        if (c === HYPHEN) {
+                            flags |= F.LAST_BOUNDARY;
+                        }
+                        else if (c !== CR) {
+                            return;
+                        }
+                        index++;
+                        break;
+                    }
+                    else if (index - 1 === boundary.length - 2) {
+                        if (flags & F.LAST_BOUNDARY && c === HYPHEN) {
+                            state = S.END;
+                            flags = 0;
+                        }
+                        else if (!(flags & F.LAST_BOUNDARY) && c === LF) {
+                            index = 0;
+                            callback('onPartBegin');
+                            state = S.HEADER_FIELD_START;
+                        }
+                        else {
+                            return;
+                        }
+                        break;
+                    }
+                    if (c !== boundary[index + 2]) {
+                        index = -2;
+                    }
+                    if (c === boundary[index + 2]) {
+                        index++;
+                    }
+                    break;
+                case S.HEADER_FIELD_START:
+                    state = S.HEADER_FIELD;
+                    mark('onHeaderField');
+                    index = 0;
+                // falls through
+                case S.HEADER_FIELD:
+                    if (c === CR) {
+                        clear('onHeaderField');
+                        state = S.HEADERS_ALMOST_DONE;
+                        break;
+                    }
+                    index++;
+                    if (c === HYPHEN) {
+                        break;
+                    }
+                    if (c === COLON) {
+                        if (index === 1) {
+                            // empty header field
+                            return;
+                        }
+                        dataCallback('onHeaderField', true);
+                        state = S.HEADER_VALUE_START;
+                        break;
+                    }
+                    cl = lower(c);
+                    if (cl < A || cl > Z) {
+                        return;
+                    }
+                    break;
+                case S.HEADER_VALUE_START:
+                    if (c === SPACE) {
+                        break;
+                    }
+                    mark('onHeaderValue');
+                    state = S.HEADER_VALUE;
+                // falls through
+                case S.HEADER_VALUE:
+                    if (c === CR) {
+                        dataCallback('onHeaderValue', true);
+                        callback('onHeaderEnd');
+                        state = S.HEADER_VALUE_ALMOST_DONE;
+                    }
+                    break;
+                case S.HEADER_VALUE_ALMOST_DONE:
+                    if (c !== LF) {
+                        return;
+                    }
+                    state = S.HEADER_FIELD_START;
+                    break;
+                case S.HEADERS_ALMOST_DONE:
+                    if (c !== LF) {
+                        return;
+                    }
+                    callback('onHeadersEnd');
+                    state = S.PART_DATA_START;
+                    break;
+                case S.PART_DATA_START:
+                    state = S.PART_DATA;
+                    mark('onPartData');
+                // falls through
+                case S.PART_DATA:
+                    previousIndex = index;
+                    if (index === 0) {
+                        // boyer-moore derrived algorithm to safely skip non-boundary data
+                        i += boundaryEnd;
+                        while (i < bufferLength && !(data[i] in boundaryChars)) {
+                            i += boundaryLength;
+                        }
+                        i -= boundaryEnd;
+                        c = data[i];
+                    }
+                    if (index < boundary.length) {
+                        if (boundary[index] === c) {
+                            if (index === 0) {
+                                dataCallback('onPartData', true);
+                            }
+                            index++;
+                        }
+                        else {
+                            index = 0;
+                        }
+                    }
+                    else if (index === boundary.length) {
+                        index++;
+                        if (c === CR) {
+                            // CR = part boundary
+                            flags |= F.PART_BOUNDARY;
+                        }
+                        else if (c === HYPHEN) {
+                            // HYPHEN = end boundary
+                            flags |= F.LAST_BOUNDARY;
+                        }
+                        else {
+                            index = 0;
+                        }
+                    }
+                    else if (index - 1 === boundary.length) {
+                        if (flags & F.PART_BOUNDARY) {
+                            index = 0;
+                            if (c === LF) {
+                                // unset the PART_BOUNDARY flag
+                                flags &= ~F.PART_BOUNDARY;
+                                callback('onPartEnd');
+                                callback('onPartBegin');
+                                state = S.HEADER_FIELD_START;
+                                break;
+                            }
+                        }
+                        else if (flags & F.LAST_BOUNDARY) {
+                            if (c === HYPHEN) {
+                                callback('onPartEnd');
+                                state = S.END;
+                                flags = 0;
+                            }
+                            else {
+                                index = 0;
+                            }
+                        }
+                        else {
+                            index = 0;
+                        }
+                    }
+                    if (index > 0) {
+                        // when matching a possible boundary, keep a lookbehind reference
+                        // in case it turns out to be a false lead
+                        lookbehind[index - 1] = c;
+                    }
+                    else if (previousIndex > 0) {
+                        // if our boundary turned out to be rubbish, the captured lookbehind
+                        // belongs to partData
+                        const _lookbehind = new Uint8Array(lookbehind.buffer, lookbehind.byteOffset, lookbehind.byteLength);
+                        callback('onPartData', 0, previousIndex, _lookbehind);
+                        previousIndex = 0;
+                        mark('onPartData');
+                        // reconsider the current character even so it interrupted the sequence
+                        // it could be the beginning of a new sequence
+                        i--;
+                    }
+                    break;
+                case S.END:
+                    break;
+                default:
+                    throw new Error(`Unexpected state entered: ${state}`);
+            }
+        }
+        dataCallback('onHeaderField');
+        dataCallback('onHeaderValue');
+        dataCallback('onPartData');
+        // Update properties for the next call
+        this.index = index;
+        this.state = state;
+        this.flags = flags;
+    }
+    end() {
+        if ((this.state === S.HEADER_FIELD_START && this.index === 0) ||
+            (this.state === S.PART_DATA && this.index === this.boundary.length)) {
+            this.onPartEnd();
+        }
+        else if (this.state !== S.END) {
+            throw new Error('MultipartParser.end(): stream ended unexpectedly');
+        }
+    }
+}
+function _fileName(headerValue) {
+    // matches either a quoted-string or a token (RFC 2616 section 19.5.1)
+    const m = headerValue.match(/\bfilename=("(.*?)"|([^()<>@,;:\\"/[\]?={}\s\t]+))($|;\s)/i);
+    if (!m) {
+        return;
+    }
+    const match = m[2] || m[3] || '';
+    let filename = match.slice(match.lastIndexOf('\\') + 1);
+    filename = filename.replace(/%22/g, '"');
+    filename = filename.replace(/&#(\d{4});/g, (m, code) => {
+        return String.fromCharCode(code);
+    });
+    return filename;
+}
+export async function toFormData(Body, ct) {
+    if (!/multipart/i.test(ct)) {
+        throw new TypeError('Failed to fetch');
+    }
+    const m = ct.match(/boundary=(?:"([^"]+)"|([^;]+))/i);
+    if (!m) {
+        throw new TypeError('no or bad content-type header, no multipart boundary');
+    }
+    const parser = new MultipartParser(m[1] || m[2]);
+    let headerField;
+    let headerValue;
+    let entryValue;
+    let entryName;
+    let contentType;
+    let filename;
+    const entryChunks = [];
+    const formData = new FormData();
+    const onPartData = (ui8a) => {
+        entryValue += decoder.decode(ui8a, { stream: true });
+    };
+    const appendToFile = (ui8a) => {
+        entryChunks.push(ui8a);
+    };
+    const appendFileToFormData = () => {
+        const file = new File(entryChunks, filename, { type: contentType });
+        formData.append(entryName, file);
+    };
+    const appendEntryToFormData = () => {
+        formData.append(entryName, entryValue);
+    };
+    const decoder = new TextDecoder('utf-8');
+    decoder.decode();
+    parser.onPartBegin = function () {
+        parser.onPartData = onPartData;
+        parser.onPartEnd = appendEntryToFormData;
+        headerField = '';
+        headerValue = '';
+        entryValue = '';
+        entryName = '';
+        contentType = '';
+        filename = null;
+        entryChunks.length = 0;
+    };
+    parser.onHeaderField = function (ui8a) {
+        headerField += decoder.decode(ui8a, { stream: true });
+    };
+    parser.onHeaderValue = function (ui8a) {
+        headerValue += decoder.decode(ui8a, { stream: true });
+    };
+    parser.onHeaderEnd = function () {
+        headerValue += decoder.decode();
+        headerField = headerField.toLowerCase();
+        if (headerField === 'content-disposition') {
+            // matches either a quoted-string or a token (RFC 2616 section 19.5.1)
+            const m = headerValue.match(/\bname=("([^"]*)"|([^()<>@,;:\\"/[\]?={}\s\t]+))/i);
+            if (m) {
+                entryName = m[2] || m[3] || '';
+            }
+            filename = _fileName(headerValue);
+            if (filename) {
+                parser.onPartData = appendToFile;
+                parser.onPartEnd = appendFileToFormData;
+            }
+        }
+        else if (headerField === 'content-type') {
+            contentType = headerValue;
+        }
+        headerValue = '';
+        headerField = '';
+    };
+    for await (const chunk of Body) {
+        parser.write(chunk);
+    }
+    parser.end();
+    return formData;
+}

package/lib/utils/referrer.d.ts

@@ -0,0 +1,76 @@
+import { URL } from '@gjsify/url';
+import Request from '../request.js';
+/**
+ * @external URL
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/URL URL}
+ */
+/**
+ * @module utils/referrer
+ * @private
+ */
+/**
+ * @see {@link https://w3c.github.io/webappsec-referrer-policy/#strip-url Referrer Policy §8.4. Strip url for use as a referrer}
+ * @param url
+ * @param originOnly
+ */
+export declare function stripURLForUseAsAReferrer(url: null | URL | "no-referrer", originOnly?: boolean): URL | "no-referrer";
+/**
+ * @see {@link https://w3c.github.io/webappsec-referrer-policy/#enumdef-referrerpolicy enum ReferrerPolicy}
+ */
+export declare const ReferrerPolicy: Set<string>;
+/**
+ * @see {@link https://w3c.github.io/webappsec-referrer-policy/#default-referrer-policy default referrer policy}
+ */
+export declare const DEFAULT_REFERRER_POLICY = "strict-origin-when-cross-origin";
+/**
+ * @see {@link https://w3c.github.io/webappsec-referrer-policy/#referrer-policies Referrer Policy §3. Referrer Policies}
+ * @param referrerPolicy
+ * @returns referrerPolicy
+ */
+export declare function validateReferrerPolicy(referrerPolicy: ReferrerPolicy): ReferrerPolicy;
+/**
+ * @see {@link https://w3c.github.io/webappsec-secure-contexts/#is-origin-trustworthy Referrer Policy §3.2. Is origin potentially trustworthy?}
+ * @param url
+ * @returns `true`: "Potentially Trustworthy", `false`: "Not Trustworthy"
+ */
+export declare function isOriginPotentiallyTrustworthy(url: URL): boolean;
+/**
+ * @see {@link https://w3c.github.io/webappsec-secure-contexts/#is-url-trustworthy Referrer Policy §3.3. Is url potentially trustworthy?}
+ * @param url
+ * @returns `true`: "Potentially Trustworthy", `false`: "Not Trustworthy"
+ */
+export declare function isUrlPotentiallyTrustworthy(url: URL | 'no-referrer'): boolean;
+/**
+ * Modifies the referrerURL to enforce any extra security policy considerations.
+ * @see {@link https://w3c.github.io/webappsec-referrer-policy/#determine-requests-referrer Referrer Policy §8.3. Determine request's Referrer}, step 7
+ * @callback module:utils/referrer~referrerURLCallback
+ * @param {external:URL} referrerURL
+ * @returns {external:URL} modified referrerURL
+ */
+/**
+ * Modifies the referrerOrigin to enforce any extra security policy considerations.
+ * @see {@link https://w3c.github.io/webappsec-referrer-policy/#determine-requests-referrer Referrer Policy §8.3. Determine request's Referrer}, step 7
+ * @callback module:utils/referrer~referrerOriginCallback
+ * @param {external:URL} referrerOrigin
+ * @returns {external:URL} modified referrerOrigin
+ */
+/**
+ * @see {@link https://w3c.github.io/webappsec-referrer-policy/#determine-requests-referrer Referrer Policy §8.3. Determine request's Referrer}
+ * @param request
+ * @param {object} o
+ * @param {module:utils/referrer~referrerURLCallback} o.referrerURLCallback
+ * @param {module:utils/referrer~referrerOriginCallback} o.referrerOriginCallback
+ * @returns {external:URL} Request's referrer
+ */
+export declare function determineRequestsReferrer(request: Request, obj?: {
+    referrerURLCallback?: (url: URL | 'no-referrer') => URL;
+    referrerOriginCallback?: (url: URL | 'no-referrer') => URL;
+}): URL | string;
+/**
+ * @see {@link https://w3c.github.io/webappsec-referrer-policy/#parse-referrer-policy-from-header|Referrer Policy §8.1. Parse a referrer policy from a Referrer-Policy header}
+ * @param {Headers} headers Response headers
+ * @returns {string} policy
+ */
+export declare function parseReferrerPolicyFromHeader(headers: {
+    get(name: string): string | null;
+}): ReferrerPolicy;