@remotion/renderer 4.0.0-imgloading.2 → 4.0.0-lambda.3

package/dist/browser/NetworkManager.js

@@ -0,0 +1,284 @@
+"use strict";
+/**
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _NetworkManager_instances, _NetworkManager_client, _NetworkManager_frameManager, _NetworkManager_networkEventManager, _NetworkManager_extraHTTPHeaders, _NetworkManager_attemptedAuthentications, _NetworkManager_onRequestWillBeSent, _NetworkManager_onAuthRequired, _NetworkManager_onRequestPaused, _NetworkManager_patchRequestEventHeaders, _NetworkManager_onRequest, _NetworkManager_onRequestServedFromCache, _NetworkManager_handleRequestRedirect, _NetworkManager_emitResponseEvent, _NetworkManager_onResponseReceived, _NetworkManager_onResponseReceivedExtraInfo, _NetworkManager_forgetRequest, _NetworkManager_onLoadingFinished, _NetworkManager_emitLoadingFinished, _NetworkManager_onLoadingFailed, _NetworkManager_emitLoadingFailed;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkManager = exports.NetworkManagerEmittedEvents = void 0;
+const assert_1 = require("./assert");
+const EventEmitter_1 = require("./EventEmitter");
+const HTTPRequest_1 = require("./HTTPRequest");
+const HTTPResponse_1 = require("./HTTPResponse");
+const NetworkEventManager_1 = require("./NetworkEventManager");
+const util_1 = require("./util");
+exports.NetworkManagerEmittedEvents = {
+    Request: Symbol('NetworkManager.Request'),
+};
+class NetworkManager extends EventEmitter_1.EventEmitter {
+    constructor(client, frameManager) {
+        super();
+        _NetworkManager_instances.add(this);
+        _NetworkManager_client.set(this, void 0);
+        _NetworkManager_frameManager.set(this, void 0);
+        _NetworkManager_networkEventManager.set(this, new NetworkEventManager_1.NetworkEventManager());
+        _NetworkManager_extraHTTPHeaders.set(this, {});
+        _NetworkManager_attemptedAuthentications.set(this, new Set());
+        __classPrivateFieldSet(this, _NetworkManager_client, client, "f");
+        __classPrivateFieldSet(this, _NetworkManager_frameManager, frameManager, "f");
+        __classPrivateFieldGet(this, _NetworkManager_client, "f").on('Fetch.requestPaused', __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_onRequestPaused).bind(this));
+        __classPrivateFieldGet(this, _NetworkManager_client, "f").on('Fetch.authRequired', __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_onAuthRequired).bind(this));
+        __classPrivateFieldGet(this, _NetworkManager_client, "f").on('Network.requestWillBeSent', __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_onRequestWillBeSent).bind(this));
+        __classPrivateFieldGet(this, _NetworkManager_client, "f").on('Network.requestServedFromCache', __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_onRequestServedFromCache).bind(this));
+        __classPrivateFieldGet(this, _NetworkManager_client, "f").on('Network.responseReceived', __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_onResponseReceived).bind(this));
+        __classPrivateFieldGet(this, _NetworkManager_client, "f").on('Network.loadingFinished', __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_onLoadingFinished).bind(this));
+        __classPrivateFieldGet(this, _NetworkManager_client, "f").on('Network.loadingFailed', __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_onLoadingFailed).bind(this));
+        __classPrivateFieldGet(this, _NetworkManager_client, "f").on('Network.responseReceivedExtraInfo', __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_onResponseReceivedExtraInfo).bind(this));
+    }
+    async initialize() {
+        await __classPrivateFieldGet(this, _NetworkManager_client, "f").send('Network.enable');
+    }
+    async setExtraHTTPHeaders(extraHTTPHeaders) {
+        __classPrivateFieldSet(this, _NetworkManager_extraHTTPHeaders, {}, "f");
+        for (const key of Object.keys(extraHTTPHeaders)) {
+            const value = extraHTTPHeaders[key];
+            (0, assert_1.assert)((0, util_1.isString)(value), `Expected value of header "${key}" to be String, but "${typeof value}" is found.`);
+            __classPrivateFieldGet(this, _NetworkManager_extraHTTPHeaders, "f")[key.toLowerCase()] = value;
+        }
+        await __classPrivateFieldGet(this, _NetworkManager_client, "f").send('Network.setExtraHTTPHeaders', {
+            headers: __classPrivateFieldGet(this, _NetworkManager_extraHTTPHeaders, "f"),
+        });
+    }
+    extraHTTPHeaders() {
+        return { ...__classPrivateFieldGet(this, _NetworkManager_extraHTTPHeaders, "f") };
+    }
+    numRequestsInProgress() {
+        return __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").numRequestsInProgress();
+    }
+}
+exports.NetworkManager = NetworkManager;
+_NetworkManager_client = new WeakMap(), _NetworkManager_frameManager = new WeakMap(), _NetworkManager_networkEventManager = new WeakMap(), _NetworkManager_extraHTTPHeaders = new WeakMap(), _NetworkManager_attemptedAuthentications = new WeakMap(), _NetworkManager_instances = new WeakSet(), _NetworkManager_onRequestWillBeSent = function _NetworkManager_onRequestWillBeSent(event) {
+    __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_onRequest).call(this, event, undefined);
+}, _NetworkManager_onAuthRequired = function _NetworkManager_onAuthRequired(event) {
+    let response = 'Default';
+    if (__classPrivateFieldGet(this, _NetworkManager_attemptedAuthentications, "f").has(event.requestId)) {
+        response = 'CancelAuth';
+    }
+    const { username, password } = {
+        username: undefined,
+        password: undefined,
+    };
+    __classPrivateFieldGet(this, _NetworkManager_client, "f")
+        .send('Fetch.continueWithAuth', {
+        requestId: event.requestId,
+        authChallengeResponse: { response, username, password },
+    })
+        .catch(() => undefined);
+}, _NetworkManager_onRequestPaused = function _NetworkManager_onRequestPaused(event) {
+    const { networkId: networkRequestId, requestId: fetchRequestId } = event;
+    if (!networkRequestId) {
+        return;
+    }
+    const requestWillBeSentEvent = (() => {
+        const _requestWillBeSentEvent = __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").getRequestWillBeSent(networkRequestId);
+        // redirect requests have the same `requestId`,
+        if (_requestWillBeSentEvent &&
+            (_requestWillBeSentEvent.request.url !== event.request.url ||
+                _requestWillBeSentEvent.request.method !== event.request.method)) {
+            __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").forgetRequestWillBeSent(networkRequestId);
+            return;
+        }
+        return _requestWillBeSentEvent;
+    })();
+    if (requestWillBeSentEvent) {
+        __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_patchRequestEventHeaders).call(this, requestWillBeSentEvent, event);
+        __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_onRequest).call(this, requestWillBeSentEvent, fetchRequestId);
+    }
+    else {
+        __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").storeRequestPaused(networkRequestId, event);
+    }
+}, _NetworkManager_patchRequestEventHeaders = function _NetworkManager_patchRequestEventHeaders(requestWillBeSentEvent, requestPausedEvent) {
+    requestWillBeSentEvent.request.headers = {
+        ...requestWillBeSentEvent.request.headers,
+        // includes extra headers, like: Accept, Origin
+        ...requestPausedEvent.request.headers,
+    };
+}, _NetworkManager_onRequest = function _NetworkManager_onRequest(event, fetchRequestId) {
+    let redirectChain = [];
+    if (event.redirectResponse) {
+        // We want to emit a response and requestfinished for the
+        // redirectResponse, but we can't do so unless we have a
+        // responseExtraInfo ready to pair it up with. If we don't have any
+        // responseExtraInfos saved in our queue, they we have to wait until
+        // the next one to emit response and requestfinished, *and* we should
+        // also wait to emit this Request too because it should come after the
+        // response/requestfinished.
+        let redirectResponseExtraInfo = null;
+        if (event.redirectHasExtraInfo) {
+            redirectResponseExtraInfo = __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f")
+                .responseExtraInfo(event.requestId)
+                .shift();
+            if (!redirectResponseExtraInfo) {
+                __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").queueRedirectInfo(event.requestId, {
+                    event,
+                    fetchRequestId,
+                });
+                return;
+            }
+        }
+        const _request = __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").getRequest(event.requestId);
+        // If we connect late to the target, we could have missed the
+        // requestWillBeSent event.
+        if (_request) {
+            __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_handleRequestRedirect).call(this, _request, event.redirectResponse, redirectResponseExtraInfo);
+            redirectChain = _request._redirectChain;
+        }
+    }
+    const frame = event.frameId
+        ? __classPrivateFieldGet(this, _NetworkManager_frameManager, "f").frame(event.frameId)
+        : null;
+    const request = new HTTPRequest_1.HTTPRequest(frame, event, redirectChain);
+    __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").storeRequest(event.requestId, request);
+    this.emit(exports.NetworkManagerEmittedEvents.Request, request);
+}, _NetworkManager_onRequestServedFromCache = function _NetworkManager_onRequestServedFromCache(event) {
+    const request = __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").getRequest(event.requestId);
+    if (request) {
+        request._fromMemoryCache = true;
+    }
+}, _NetworkManager_handleRequestRedirect = function _NetworkManager_handleRequestRedirect(request, responsePayload, extraInfo) {
+    const response = new HTTPResponse_1.HTTPResponse(__classPrivateFieldGet(this, _NetworkManager_client, "f"), request, responsePayload, extraInfo);
+    request._response = response;
+    request._redirectChain.push(request);
+    response._resolveBody(new Error('Response body is unavailable for redirect responses'));
+    __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_forgetRequest).call(this, request, false);
+}, _NetworkManager_emitResponseEvent = function _NetworkManager_emitResponseEvent(responseReceived, extraInfo) {
+    const request = __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").getRequest(responseReceived.requestId);
+    // FileUpload sends a response without a matching request.
+    if (!request) {
+        return;
+    }
+    const extraInfos = __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").responseExtraInfo(responseReceived.requestId);
+    if (extraInfos.length) {
+        console.log(new Error('Unexpected extraInfo events for request ' +
+            responseReceived.requestId));
+    }
+    const response = new HTTPResponse_1.HTTPResponse(__classPrivateFieldGet(this, _NetworkManager_client, "f"), request, responseReceived.response, extraInfo);
+    request._response = response;
+}, _NetworkManager_onResponseReceived = function _NetworkManager_onResponseReceived(event) {
+    const request = __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").getRequest(event.requestId);
+    let extraInfo = null;
+    if (request && !request._fromMemoryCache && event.hasExtraInfo) {
+        extraInfo = __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f")
+            .responseExtraInfo(event.requestId)
+            .shift();
+        if (!extraInfo) {
+            // Wait until we get the corresponding ExtraInfo event.
+            __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").queueEventGroup(event.requestId, {
+                responseReceivedEvent: event,
+            });
+            return;
+        }
+    }
+    __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_emitResponseEvent).call(this, event, extraInfo);
+}, _NetworkManager_onResponseReceivedExtraInfo = function _NetworkManager_onResponseReceivedExtraInfo(event) {
+    // We may have skipped a redirect response/request pair due to waiting for
+    // this ExtraInfo event. If so, continue that work now that we have the
+    // request.
+    const redirectInfo = __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").takeQueuedRedirectInfo(event.requestId);
+    if (redirectInfo) {
+        __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").responseExtraInfo(event.requestId).push(event);
+        __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_onRequest).call(this, redirectInfo.event, redirectInfo.fetchRequestId);
+        return;
+    }
+    // We may have skipped response and loading events because we didn't have
+    // this ExtraInfo event yet. If so, emit those events now.
+    const queuedEvents = __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").getQueuedEventGroup(event.requestId);
+    if (queuedEvents) {
+        __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").forgetQueuedEventGroup(event.requestId);
+        __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_emitResponseEvent).call(this, queuedEvents.responseReceivedEvent, event);
+        if (queuedEvents.loadingFinishedEvent) {
+            __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_emitLoadingFinished).call(this, queuedEvents.loadingFinishedEvent);
+        }
+        if (queuedEvents.loadingFailedEvent) {
+            __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_emitLoadingFailed).call(this, queuedEvents.loadingFailedEvent);
+        }
+        return;
+    }
+    // Wait until we get another event that can use this ExtraInfo event.
+    __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").responseExtraInfo(event.requestId).push(event);
+}, _NetworkManager_forgetRequest = function _NetworkManager_forgetRequest(request, events) {
+    const requestId = request._requestId;
+    __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").forgetRequest(requestId);
+    if (events) {
+        __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").forget(requestId);
+    }
+}, _NetworkManager_onLoadingFinished = function _NetworkManager_onLoadingFinished(event) {
+    // If the response event for this request is still waiting on a
+    // corresponding ExtraInfo event, then wait to emit this event too.
+    const queuedEvents = __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").getQueuedEventGroup(event.requestId);
+    if (queuedEvents) {
+        queuedEvents.loadingFinishedEvent = event;
+    }
+    else {
+        __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_emitLoadingFinished).call(this, event);
+    }
+}, _NetworkManager_emitLoadingFinished = function _NetworkManager_emitLoadingFinished(event) {
+    var _a;
+    const request = __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").getRequest(event.requestId);
+    // For certain requestIds we never receive requestWillBeSent event.
+    // @see https://crbug.com/750469
+    if (!request) {
+        return;
+    }
+    // Under certain conditions we never get the Network.responseReceived
+    // event from protocol. @see https://crbug.com/883475
+    if (request.response()) {
+        (_a = request.response()) === null || _a === void 0 ? void 0 : _a._resolveBody(null);
+    }
+    __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_forgetRequest).call(this, request, true);
+}, _NetworkManager_onLoadingFailed = function _NetworkManager_onLoadingFailed(event) {
+    // If the response event for this request is still waiting on a
+    // corresponding ExtraInfo event, then wait to emit this event too.
+    const queuedEvents = __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").getQueuedEventGroup(event.requestId);
+    if (queuedEvents) {
+        queuedEvents.loadingFailedEvent = event;
+    }
+    else {
+        __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_emitLoadingFailed).call(this, event);
+    }
+}, _NetworkManager_emitLoadingFailed = function _NetworkManager_emitLoadingFailed(event) {
+    const request = __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").getRequest(event.requestId);
+    // For certain requestIds we never receive requestWillBeSent event.
+    // @see https://crbug.com/750469
+    if (!request) {
+        return;
+    }
+    request._failureText = event.errorText;
+    const response = request.response();
+    if (response) {
+        response._resolveBody(null);
+    }
+    __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_forgetRequest).call(this, request, true);
+};

package/dist/browser/NodeWebSocketTransport.d.ts

@@ -0,0 +1,11 @@
+import NodeWebSocket from 'ws';
+import { ConnectionTransport } from './ConnectionTransport';
+export declare class NodeWebSocketTransport implements ConnectionTransport {
+    #private;
+    static create(urlString: string): Promise<NodeWebSocketTransport>;
+    onmessage?: (message: NodeWebSocket.Data) => void;
+    onclose?: () => void;
+    constructor(ws: NodeWebSocket);
+    send(message: string): void;
+    close(): void;
+}

package/dist/browser/NodeWebSocketTransport.js

@@ -0,0 +1,90 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _NodeWebSocketTransport_ws;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeWebSocketTransport = void 0;
+/**
+ * Copyright 2018 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const dns_1 = require("dns");
+const url_1 = require("url");
+const ws_1 = __importDefault(require("ws"));
+class NodeWebSocketTransport {
+    constructor(ws) {
+        _NodeWebSocketTransport_ws.set(this, void 0);
+        __classPrivateFieldSet(this, _NodeWebSocketTransport_ws, ws, "f");
+        __classPrivateFieldGet(this, _NodeWebSocketTransport_ws, "f").addEventListener('message', (event) => {
+            if (this.onmessage) {
+                this.onmessage.call(null, event.data);
+            }
+        });
+        __classPrivateFieldGet(this, _NodeWebSocketTransport_ws, "f").addEventListener('close', () => {
+            if (this.onclose) {
+                this.onclose.call(null);
+            }
+        });
+        // Silently ignore all errors - we don't know what to do with them.
+        __classPrivateFieldGet(this, _NodeWebSocketTransport_ws, "f").addEventListener('error', () => undefined);
+    }
+    static async create(urlString) {
+        // TODO(jrandolf): Starting in Node 17, IPv6 is favoured over IPv4 due to a change
+        // in a default option:
+        // - https://github.com/nodejs/node/issues/40537,
+        // Due to this, for Firefox, we must parse and resolve the `localhost` hostname
+        // manually with the previous behavior according to:
+        // - https://nodejs.org/api/dns.html#dnslookuphostname-options-callback
+        // because of https://bugzilla.mozilla.org/show_bug.cgi?id=1769994.
+        const url = new url_1.URL(urlString);
+        if (url.hostname === 'localhost') {
+            const { address } = await dns_1.promises.lookup(url.hostname, { verbatim: false });
+            url.hostname = address;
+        }
+        return new Promise((resolve, reject) => {
+            const ws = new ws_1.default(url, [], {
+                followRedirects: true,
+                perMessageDeflate: false,
+                maxPayload: 256 * 1024 * 1024,
+                headers: {
+                    'User-Agent': `Remotion CLI`,
+                },
+            });
+            ws.addEventListener('open', () => {
+                return resolve(new NodeWebSocketTransport(ws));
+            });
+            ws.addEventListener('error', reject);
+        });
+    }
+    send(message) {
+        __classPrivateFieldGet(this, _NodeWebSocketTransport_ws, "f").send(message);
+    }
+    close() {
+        __classPrivateFieldGet(this, _NodeWebSocketTransport_ws, "f").close();
+    }
+}
+exports.NodeWebSocketTransport = NodeWebSocketTransport;
+_NodeWebSocketTransport_ws = new WeakMap();

package/dist/browser/PDFOptions.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Copyright 2020 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * @public
+ */
+export interface PDFMargin {
+    top?: string | number;
+    bottom?: string | number;
+    left?: string | number;
+    right?: string | number;
+}
+/**
+ * @public
+ */
+export declare type LowerCasePaperFormat = 'letter' | 'legal' | 'tabloid' | 'ledger' | 'a0' | 'a1' | 'a2' | 'a3' | 'a4' | 'a5' | 'a6';
+/**
+ * All the valid paper format types when printing a PDF.
+ *
+ * @remarks
+ *
+ * The sizes of each format are as follows:
+ * - `Letter`: 8.5in x 11in
+ *
+ * - `Legal`: 8.5in x 14in
+ *
+ * - `Tabloid`: 11in x 17in
+ *
+ * - `Ledger`: 17in x 11in
+ *
+ * - `A0`: 33.1in x 46.8in
+ *
+ * - `A1`: 23.4in x 33.1in
+ *
+ * - `A2`: 16.54in x 23.4in
+ *
+ * - `A3`: 11.7in x 16.54in
+ *
+ * - `A4`: 8.27in x 11.7in
+ *
+ * - `A5`: 5.83in x 8.27in
+ *
+ * - `A6`: 4.13in x 5.83in
+ *
+ * @public
+ */
+export declare type PaperFormat = Uppercase<LowerCasePaperFormat> | Capitalize<LowerCasePaperFormat> | LowerCasePaperFormat;
+/**
+ * Valid options to configure PDF generation via {@link Page.pdf}.
+ * @public
+ */
+export interface PDFOptions {
+    /**
+     * Scales the rendering of the web page. Amount must be between `0.1` and `2`.
+     * @defaultValue 1
+     */
+    scale?: number;
+    /**
+     * Whether to show the header and footer.
+     * @defaultValue false
+     */
+    displayHeaderFooter?: boolean;
+    /**
+     * HTML template for the print header. Should be valid HTML with the following
+     * classes used to inject values into them:
+     * - `date` formatted print date
+     *
+     * - `title` document title
+     *
+     * - `url` document location
+     *
+     * - `pageNumber` current page number
+     *
+     * - `totalPages` total pages in the document
+     */
+    headerTemplate?: string;
+    /**
+     * HTML template for the print footer. Has the same constraints and support
+     * for special classes as {@link PDFOptions.headerTemplate}.
+     */
+    footerTemplate?: string;
+    /**
+     * Set to `true` to print background graphics.
+     * @defaultValue false
+     */
+    printBackground?: boolean;
+    /**
+     * Whether to print in landscape orientation.
+     * @defaultValue = false
+     */
+    landscape?: boolean;
+    /**
+     * Paper ranges to print, e.g. `1-5, 8, 11-13`.
+     * @defaultValue The empty string, which means all pages are printed.
+     */
+    pageRanges?: string;
+    /**
+     * @remarks
+     * If set, this takes priority over the `width` and `height` options.
+     * @defaultValue `letter`.
+     */
+    format?: PaperFormat;
+    /**
+     * Sets the width of paper. You can pass in a number or a string with a unit.
+     */
+    width?: string | number;
+    /**
+     * Sets the height of paper. You can pass in a number or a string with a unit.
+     */
+    height?: string | number;
+    /**
+     * Give any CSS `@page` size declared in the page priority over what is
+     * declared in the `width` or `height` or `format` option.
+     * @defaultValue `false`, which will scale the content to fit the paper size.
+     */
+    preferCSSPageSize?: boolean;
+    /**
+     * Set the PDF margins.
+     * @defaultValue no margins are set.
+     */
+    margin?: PDFMargin;
+    /**
+     * The path to save the file to.
+     *
+     * @remarks
+     *
+     * If the path is relative, it's resolved relative to the current working directory.
+     *
+     * @defaultValue the empty string, which means the PDF will not be written to disk.
+     */
+    path?: string;
+    /**
+     * Hides default white background and allows generating pdfs with transparency.
+     * @defaultValue false
+     */
+    omitBackground?: boolean;
+    /**
+     * Timeout in milliseconds
+     * @defaultValue 30000
+     */
+    timeout?: number;
+}
+/**
+ * @internal
+ */
+export interface PaperFormatDimensions {
+    width: number;
+    height: number;
+}
+/**
+ * @internal
+ */
+export declare const _paperFormats: Record<LowerCasePaperFormat, PaperFormatDimensions>;

package/dist/browser/PDFOptions.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * Copyright 2020 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._paperFormats = void 0;
+/**
+ * @internal
+ */
+exports._paperFormats = {
+    letter: { width: 8.5, height: 11 },
+    legal: { width: 8.5, height: 14 },
+    tabloid: { width: 11, height: 17 },
+    ledger: { width: 17, height: 11 },
+    a0: { width: 33.1, height: 46.8 },
+    a1: { width: 23.4, height: 33.1 },
+    a2: { width: 16.54, height: 23.4 },
+    a3: { width: 11.7, height: 16.54 },
+    a4: { width: 8.27, height: 11.7 },
+    a5: { width: 5.83, height: 8.27 },
+    a6: { width: 4.13, height: 5.83 },
+};

package/dist/browser/PipeTransport.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import { ConnectionTransport } from './ConnectionTransport';
+export declare class PipeTransport implements ConnectionTransport {
+    #private;
+    onclose?: () => void;
+    onmessage?: (value: string) => void;
+    constructor(pipeWrite: NodeJS.WritableStream, pipeRead: NodeJS.ReadableStream);
+    send(message: string): void;
+    close(): void;
+}