@vertexvis/doc-viewer 0.24.5-canary.8

package/dist/index.cjs.js

@@ -0,0 +1 @@
+module.exports = require('./cjs/index.cjs.js');

package/dist/index.js

@@ -0,0 +1 @@
+export * from './esm/index.js';

package/dist/types/__mocks__/pdfjs-mock.d.ts

@@ -0,0 +1,30 @@
+import type { PDFDocumentProxy } from 'pdfjs-dist/legacy/build/pdf.mjs';
+export declare class MockOptionalContentConfig extends Map {
+    setVisibility: jest.Mock<any, any, any>;
+}
+export declare const mockGetViewport: jest.Mock<{
+    width: number;
+    height: number;
+}, [], any>;
+export declare const mockPageRender: jest.Mock<{
+    promise: Promise<void>;
+}, [], any>;
+export declare const mockGetPage: jest.Mock<{
+    getTextContent: jest.Mock<{
+        items: never[];
+    }, [], any>;
+    render: jest.Mock<{
+        promise: Promise<void>;
+    }, [], any>;
+    getViewport: jest.Mock<{
+        width: number;
+        height: number;
+    }, [], any>;
+}, [], any>;
+export declare const mockDestroy: jest.Mock<any, any, any>;
+export declare const mockGetDocument: jest.Mock<any, [], any>;
+export declare const mockPdfDocument: PDFDocumentProxy;
+export declare const GlobalWorkerOptions: {
+    workerSrc: string;
+};
+export declare const getDocument: jest.Mock<any, [], any>;

package/dist/types/__setup__/polyfills.d.ts

@@ -0,0 +1 @@
+import 'abortcontroller-polyfill/dist/polyfill-patch-fetch';

package/dist/types/__setup__/resize-observer.d.ts

@@ -0,0 +1 @@
+export declare const triggerResizeObserver: jest.Mock<any, any, any>;

package/dist/types/components/document-viewer/document-viewer.d.ts

@@ -0,0 +1,132 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { Point } from '@vertexvis/geometry';
+import { PartialConfig } from '../../lib/config';
+import { DocumentApiState } from '../../lib/document/api';
+import { DocumentLayersController } from '../../lib/document/layers/controller';
+import { DocumentProvider } from '../../lib/document/provider';
+export type InteractionMode = 'none' | 'pan';
+export declare class VertexDocumentViewer {
+    /**
+     * A URI of the document to load when the component is mounted in the DOM tree.
+     * Currently only supports URLs for client-side rendering.
+     */
+    src?: string;
+    /**
+     * The ID of the loaded `Document`. This ID is required to enable persistence of
+     * annotations.
+     *
+     * Note that this is different than a `File` ID within the Vertex Platform, and must
+     * be created separately using the `/documents` endpoints.
+     * See https://docs.vertex3d.com/ for more details.
+     */
+    documentId?: string;
+    /**
+     * The provider used to create the document API and renderer.
+     */
+    provider: DocumentProvider;
+    /**
+     * The interaction mode for the viewer. When set to `'pan'`, click and drag
+     * will pan the document. When set to `'none'`, no pointer interactions
+     * are registered.
+     */
+    interactionMode: InteractionMode;
+    /**
+     * Common state of the current document. This value includes information common to all
+     * types of documents, including state like zoom percentage, viewport definition, and offsets.
+     */
+    documentState?: DocumentApiState;
+    /**
+     * Controller for interacting with layers in the currently loaded document.
+     *
+     * This controller will automatically be created along with the loaded document.
+     * Note that the methods available on this controller will only be supported if
+     * the underlying document type supports layers.
+     */
+    layers?: DocumentLayersController;
+    /**
+     * Configuration values for the document viewer. See {@link Config} for more information
+     * on the available configuration options.
+     */
+    config?: PartialConfig;
+    /**
+     * An optional value that will debounce image updates when resizing
+     * this viewer element.
+     */
+    resizeDebounce: number;
+    /**
+     * Emits an event when the document is ready to be interacted with.
+     */
+    documentReady: EventEmitter<void>;
+    /**
+     * Emits an event when the document state changes.
+     */
+    documentStateChanged: EventEmitter<DocumentApiState>;
+    /**
+     * Emits an event when a page has been loaded or reloaded prior to being
+     * drawn to the canvas.
+     */
+    pageLoaded: EventEmitter<DocumentApiState>;
+    /**
+     * Emits an event when a page has been drawn to the canvas.
+     */
+    pageDrawn: EventEmitter<DocumentApiState>;
+    private hostEl;
+    private viewerContainerElement?;
+    private canvasContainerElement?;
+    private canvasEl?;
+    private dimensions;
+    private resizeObserver?;
+    private resizeTimer?;
+    private documentRenderer?;
+    private documentApi?;
+    private panInteractionHandler?;
+    private documentApiStateChangedDisposable?;
+    private pageLoadedDisposable?;
+    private pageDrawnDisposable?;
+    protected componentWillLoad(): void;
+    protected componentShouldUpdate(newValue: unknown, oldValue: unknown, propName: string): boolean;
+    protected componentDidLoad(): void;
+    protected disconnectedCallback(): void;
+    /**
+     * Pans the currently loaded document by the specified delta.
+     *
+     * This method will be bounded to the visible portion of the document to ensure
+     * at least a portion of the document is always visible, and the `canvas` does not
+     * appear blank.
+     *
+     * @param delta The delta to pan the document by.
+     */
+    panByDelta(delta: Point.Point): Promise<void>;
+    /**
+     * Zooms the currently loaded document to the specified zoom percentage.
+     *
+     * This method will automatically adjust existing offsets to maintain the
+     * same center point of the document where possible.
+     *
+     * @param percentage The zoom percentage to set.
+     */
+    zoomTo(percentage: number): Promise<void>;
+    /**
+     * Loads a specific page of the currently loaded document.
+     *
+     * Note that any offset applied by panning the document will be reset when loading
+     * a new page.
+     *
+     * @param pageNumber The page number to load.
+     */
+    loadPage(pageNumber: number): Promise<void>;
+    protected handleSrcChange(): Promise<void>;
+    protected handleConfigChange(): void;
+    protected handleInteractionModeChange(): void;
+    render(): void;
+    private getDocumentApi;
+    private clearCurrentDocument;
+    private handleDocumentApiStateChanged;
+    private handlePageLoaded;
+    private handlePageDrawn;
+    private updateDocumentApiListeners;
+    private updateInteractionHandler;
+    private updateComponentDimensions;
+    private handleElementResize;
+    private restartResizeTimer;
+}

package/dist/types/components.d.ts

@@ -0,0 +1,176 @@
+/* eslint-disable */
+/* tslint:disable */
+/**
+ * This is an autogenerated file created by the Stencil compiler.
+ * It contains typing information for all components that exist in this project.
+ */
+import { HTMLStencilElement, JSXBase } from "./stencil-public-runtime";
+import { DocumentProvider } from "./lib/document/provider";
+import { InteractionMode } from "./components/document-viewer/document-viewer";
+import { DocumentApiState } from "./lib/document/api";
+import { DocumentLayersController } from "./lib/document/layers/controller";
+import { PartialConfig } from "./lib/config";
+import { Point } from "@vertexvis/geometry";
+export { DocumentProvider } from "./lib/document/provider";
+export { InteractionMode } from "./components/document-viewer/document-viewer";
+export { DocumentApiState } from "./lib/document/api";
+export { DocumentLayersController } from "./lib/document/layers/controller";
+export { PartialConfig } from "./lib/config";
+export { Point } from "@vertexvis/geometry";
+export namespace Components {
+    interface VertexDocumentViewer {
+        /**
+          * Configuration values for the document viewer. See {@link Config } for more information on the available configuration options.
+         */
+        "config"?: PartialConfig;
+        /**
+          * The ID of the loaded `Document`. This ID is required to enable persistence of annotations.  Note that this is different than a `File` ID within the Vertex Platform, and must be created separately using the `/documents` endpoints. See https://docs.vertex3d.com/ for more details.
+         */
+        "documentId"?: string;
+        /**
+          * Common state of the current document. This value includes information common to all types of documents, including state like zoom percentage, viewport definition, and offsets.
+         */
+        "documentState"?: DocumentApiState;
+        /**
+          * The interaction mode for the viewer. When set to `'pan'`, click and drag will pan the document. When set to `'none'`, no pointer interactions are registered.
+          * @default 'pan'
+         */
+        "interactionMode": InteractionMode;
+        /**
+          * Controller for interacting with layers in the currently loaded document.  This controller will automatically be created along with the loaded document. Note that the methods available on this controller will only be supported if the underlying document type supports layers.
+         */
+        "layers"?: DocumentLayersController;
+        /**
+          * Loads a specific page of the currently loaded document.  Note that any offset applied by panning the document will be reset when loading a new page.
+          * @param pageNumber The page number to load.
+         */
+        "loadPage": (pageNumber: number) => Promise<void>;
+        /**
+          * Pans the currently loaded document by the specified delta.  This method will be bounded to the visible portion of the document to ensure at least a portion of the document is always visible, and the `canvas` does not appear blank.
+          * @param delta The delta to pan the document by.
+         */
+        "panByDelta": (delta: Point.Point) => Promise<void>;
+        /**
+          * The provider used to create the document API and renderer.
+          * @default new PdfJsProvider()
+         */
+        "provider": DocumentProvider;
+        /**
+          * An optional value that will debounce image updates when resizing this viewer element.
+          * @default 100
+         */
+        "resizeDebounce": number;
+        /**
+          * A URI of the document to load when the component is mounted in the DOM tree. Currently only supports URLs for client-side rendering.
+         */
+        "src"?: string;
+        /**
+          * Zooms the currently loaded document to the specified zoom percentage.  This method will automatically adjust existing offsets to maintain the same center point of the document where possible.
+          * @param percentage The zoom percentage to set.
+         */
+        "zoomTo": (percentage: number) => Promise<void>;
+    }
+}
+export interface VertexDocumentViewerCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLVertexDocumentViewerElement;
+}
+declare global {
+    interface HTMLVertexDocumentViewerElementEventMap {
+        "documentReady": void;
+        "documentStateChanged": DocumentApiState;
+        "pageLoaded": DocumentApiState;
+        "pageDrawn": DocumentApiState;
+    }
+    interface HTMLVertexDocumentViewerElement extends Components.VertexDocumentViewer, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLVertexDocumentViewerElementEventMap>(type: K, listener: (this: HTMLVertexDocumentViewerElement, ev: VertexDocumentViewerCustomEvent<HTMLVertexDocumentViewerElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLVertexDocumentViewerElementEventMap>(type: K, listener: (this: HTMLVertexDocumentViewerElement, ev: VertexDocumentViewerCustomEvent<HTMLVertexDocumentViewerElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLVertexDocumentViewerElement: {
+        prototype: HTMLVertexDocumentViewerElement;
+        new (): HTMLVertexDocumentViewerElement;
+    };
+    interface HTMLElementTagNameMap {
+        "vertex-document-viewer": HTMLVertexDocumentViewerElement;
+    }
+}
+declare namespace LocalJSX {
+    interface VertexDocumentViewer {
+        /**
+          * Configuration values for the document viewer. See {@link Config } for more information on the available configuration options.
+         */
+        "config"?: PartialConfig;
+        /**
+          * The ID of the loaded `Document`. This ID is required to enable persistence of annotations.  Note that this is different than a `File` ID within the Vertex Platform, and must be created separately using the `/documents` endpoints. See https://docs.vertex3d.com/ for more details.
+         */
+        "documentId"?: string;
+        /**
+          * Common state of the current document. This value includes information common to all types of documents, including state like zoom percentage, viewport definition, and offsets.
+         */
+        "documentState"?: DocumentApiState;
+        /**
+          * The interaction mode for the viewer. When set to `'pan'`, click and drag will pan the document. When set to `'none'`, no pointer interactions are registered.
+          * @default 'pan'
+         */
+        "interactionMode"?: InteractionMode;
+        /**
+          * Controller for interacting with layers in the currently loaded document.  This controller will automatically be created along with the loaded document. Note that the methods available on this controller will only be supported if the underlying document type supports layers.
+         */
+        "layers"?: DocumentLayersController;
+        /**
+          * Emits an event when the document is ready to be interacted with.
+         */
+        "onDocumentReady"?: (event: VertexDocumentViewerCustomEvent<void>) => void;
+        /**
+          * Emits an event when the document state changes.
+         */
+        "onDocumentStateChanged"?: (event: VertexDocumentViewerCustomEvent<DocumentApiState>) => void;
+        /**
+          * Emits an event when a page has been drawn to the canvas.
+         */
+        "onPageDrawn"?: (event: VertexDocumentViewerCustomEvent<DocumentApiState>) => void;
+        /**
+          * Emits an event when a page has been loaded or reloaded prior to being drawn to the canvas.
+         */
+        "onPageLoaded"?: (event: VertexDocumentViewerCustomEvent<DocumentApiState>) => void;
+        /**
+          * The provider used to create the document API and renderer.
+          * @default new PdfJsProvider()
+         */
+        "provider"?: DocumentProvider;
+        /**
+          * An optional value that will debounce image updates when resizing this viewer element.
+          * @default 100
+         */
+        "resizeDebounce"?: number;
+        /**
+          * A URI of the document to load when the component is mounted in the DOM tree. Currently only supports URLs for client-side rendering.
+         */
+        "src"?: string;
+    }
+
+    interface VertexDocumentViewerAttributes {
+        "src": string;
+        "documentId": string;
+        "interactionMode": InteractionMode;
+        "resizeDebounce": number;
+    }
+
+    interface IntrinsicElements {
+        "vertex-document-viewer": Omit<VertexDocumentViewer, keyof VertexDocumentViewerAttributes> & { [K in keyof VertexDocumentViewer & keyof VertexDocumentViewerAttributes]?: VertexDocumentViewer[K] } & { [K in keyof VertexDocumentViewer & keyof VertexDocumentViewerAttributes as `attr:${K}`]?: VertexDocumentViewerAttributes[K] } & { [K in keyof VertexDocumentViewer & keyof VertexDocumentViewerAttributes as `prop:${K}`]?: VertexDocumentViewer[K] };
+    }
+}
+export { LocalJSX as JSX };
+declare module "@stencil/core" {
+    export namespace JSX {
+        interface IntrinsicElements {
+            "vertex-document-viewer": LocalJSX.IntrinsicElements["vertex-document-viewer"] & JSXBase.HTMLAttributes<HTMLVertexDocumentViewerElement>;
+        }
+    }
+}

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './components';
+export * from './lib';

package/dist/types/lib/config.d.ts

@@ -0,0 +1,8 @@
+import { DeepPartial } from '@vertexvis/utils';
+export interface PdfJsConfig {
+    workerSrc: string;
+}
+export interface Config {
+    pdfJs: PdfJsConfig;
+}
+export type PartialConfig = DeepPartial<Config>;

package/dist/types/lib/document/api.d.ts

@@ -0,0 +1,51 @@
+import { Dimensions, Point } from '@vertexvis/geometry';
+import { Disposable, EventDispatcher, Listener } from '@vertexvis/utils';
+export declare const MAX_ZOOM_PERCENTAGE = 600;
+export declare const MIN_ZOOM_PERCENTAGE = 10;
+export interface DocumentApiState {
+    readonly zoomPercentage: number;
+    readonly viewport?: Dimensions.Dimensions;
+    readonly contentDimensions?: Dimensions.Dimensions;
+    readonly panOffset: Point.Point;
+    readonly loadedPageNumber?: number;
+    readonly totalPageCount?: number;
+}
+/**
+ * Base class for all document APIs. This class provides implementations for
+ * operations common to all document types, such as viewport changes and loading
+ * of pages.
+ */
+export declare abstract class DocumentApi<T extends DocumentApiState = DocumentApiState> {
+    protected readonly defaultState: T;
+    protected state: T;
+    protected readonly stateChanged: EventDispatcher<T>;
+    constructor(defaultState: T);
+    protected updateState(state: Partial<T>): void;
+    onStateChanged(listener: Listener<T>): Disposable;
+    updateViewport(viewport: Dimensions.Dimensions): Promise<void>;
+    /**
+     * Updates the pan offset for this API, and emits new state with the updated
+     * offset.
+     *
+     * This method will be bounded to the visible portion of the document to ensure
+     * at least a portion of the document is always visible, and the `canvas` does not
+     * appear blank.
+     *
+     * @param delta The delta to pan the document by.
+     */
+    panByDelta(delta: Point.Point): Promise<void>;
+    /**
+     * Updates the zoom percentage for this API, and emits new state with the updated
+     * percentage and adjusted pan offset.
+     *
+     * This method will automatically adjust existing offsets to maintain the
+     * same center point of the document where possible.
+     *
+     * @param percentage The zoom percentage to set.
+     */
+    zoomTo(percentage: number): Promise<void>;
+    private constrainPanOffset;
+    abstract dispose(): void;
+    abstract load(uri: string): Promise<void>;
+    abstract loadPage(pageNumber: number): Promise<void>;
+}

package/dist/types/lib/document/layers/controller.d.ts

@@ -0,0 +1,24 @@
+import { DocumentApi } from '../api';
+import { DocumentLayer } from './types';
+export declare class DocumentLayersController {
+    private apiSupportsLayers;
+    private api?;
+    constructor(api: DocumentApi);
+    /**
+     * Returns a boolean indicating whether the document supports layers.
+     */
+    get enabled(): boolean;
+    /**
+     * Retrieves the layers of the document.
+     *
+     * @throws {Error} if the loaded document does not support layers.
+     */
+    getLayers(): Promise<DocumentLayer[]>;
+    /**
+     * Sets the visibility of a layer by ID.
+     *
+     * @throws {Error} if the loaded document does not support layers.
+     */
+    setLayerVisibility(id: string, visible: boolean): Promise<void>;
+    private getApi;
+}

package/dist/types/lib/document/layers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './controller';
+export * from './types';

package/dist/types/lib/document/layers/types.d.ts

@@ -0,0 +1,15 @@
+import { DocumentApi } from '../api';
+export interface DocumentLayer {
+    readonly id: string;
+    readonly name: string;
+    readonly visible: boolean;
+}
+export interface LayerSupport {
+    readonly getLayers: () => DocumentLayer[] | Promise<DocumentLayer[]>;
+    readonly setLayerVisibility: (id: string, visible: boolean) => void | Promise<void>;
+}
+export type LayerSupportedApi = DocumentApi & LayerSupport;
+/**
+ * Returns a boolean indicating whether the provided document API supports layers.
+ */
+export declare function apiSupportsLayers(api: DocumentApi): api is LayerSupportedApi;

package/dist/types/lib/document/provider.d.ts

@@ -0,0 +1,16 @@
+import { Config } from '../config';
+import { DocumentApi } from './api';
+import { DocumentRenderer } from './renderer';
+export interface DocumentInterface {
+    readonly api: DocumentApi;
+    readonly renderer: DocumentRenderer;
+}
+/**
+ * A provider that is responsible for creating an interface for a document. This
+ * interface is expected to create a `DocumentApi` and a `DocumentRenderer`, which
+ * can be used to perform operations against the document and visualize the resulting
+ * image on the provided canvas element.
+ */
+export interface DocumentProvider {
+    create(canvas: HTMLCanvasElement, config?: Config): DocumentInterface;
+}

package/dist/types/lib/document/renderer.d.ts

@@ -0,0 +1,16 @@
+import { Disposable, EventDispatcher, Listener } from '@vertexvis/utils';
+import { DocumentApi, DocumentApiState } from './api';
+/**
+ * A renderer that is responsible for listening to state changes in a `DocumentApi`
+ * and rendering resulting images to the provided canvas element.
+ */
+export declare abstract class DocumentRenderer implements Disposable {
+    protected readonly api: DocumentApi;
+    protected readonly canvas: HTMLCanvasElement;
+    protected readonly pageLoaded: EventDispatcher<DocumentApiState>;
+    protected readonly pageDrawn: EventDispatcher<DocumentApiState>;
+    constructor(api: DocumentApi, canvas: HTMLCanvasElement);
+    onPageLoaded(listener: Listener<DocumentApiState>): Disposable;
+    onPageDrawn(listener: Listener<DocumentApiState>): Disposable;
+    abstract dispose(): void | Promise<void>;
+}

package/dist/types/lib/dom.d.ts

@@ -0,0 +1 @@
+export declare function getElementBoundingClientRect(element: HTMLElement): ClientRect;

package/dist/types/lib/index.d.ts

@@ -0,0 +1 @@
+export * from './config';

package/dist/types/lib/interactions/pan-interaction-handler.d.ts

@@ -0,0 +1,16 @@
+import { Disposable } from '@vertexvis/utils';
+import { DocumentApi } from '../document/api';
+export declare class PanInteractionHandler implements Disposable {
+    private element;
+    private api;
+    private lastPosition?;
+    private isDragging;
+    private downPosition?;
+    constructor(element: HTMLElement, api: DocumentApi);
+    dispose(): void;
+    private handleWheel;
+    private handlePointerDown;
+    private handlePointerMove;
+    private handlePointerUp;
+    private removeWindowListeners;
+}

package/dist/types/lib/pdf/pdfjs-api.d.ts

@@ -0,0 +1,19 @@
+import * as pdfjs from 'pdfjs-dist/legacy/build/pdf.mjs';
+import type { OptionalContentConfig } from 'pdfjs-dist/types/src/display/optional_content_config.d.js';
+import { Config } from '../config';
+import { DocumentApi, DocumentApiState } from '../document/api';
+import { DocumentLayer, LayerSupport } from '../document/layers';
+export interface PdfJsApiState extends DocumentApiState {
+    readonly document?: pdfjs.PDFDocumentProxy;
+    readonly optionalContentConfig?: OptionalContentConfig;
+    readonly layers?: DocumentLayer[];
+}
+export declare class PdfJsApi extends DocumentApi<PdfJsApiState> implements LayerSupport {
+    private readonly config?;
+    constructor(config?: Config | undefined);
+    dispose(): void;
+    load(uri: string): Promise<void>;
+    loadPage(pageNumber: number): Promise<void>;
+    getLayers(): DocumentLayer[];
+    setLayerVisibility(id: string, visible: boolean): void;
+}

package/dist/types/lib/pdf/pdfjs-provider.d.ts

@@ -0,0 +1,10 @@
+import { Config } from '../config';
+import { DocumentApi } from '../document/api';
+import { DocumentProvider } from '../document/provider';
+import { DocumentRenderer } from '../document/renderer';
+export declare class PdfJsProvider implements DocumentProvider {
+    create(canvas: HTMLCanvasElement, config?: Config): {
+        api: DocumentApi;
+        renderer: DocumentRenderer;
+    };
+}

package/dist/types/lib/pdf/pdfjs-renderer.d.ts

@@ -0,0 +1,11 @@
+import { DocumentRenderer } from '../document/renderer';
+import { PdfJsApi } from './pdfjs-api';
+export declare class PdfJsRenderer extends DocumentRenderer {
+    private stateChangedDisposable;
+    private state;
+    private offscreenCanvas;
+    constructor(api: PdfJsApi, canvas: HTMLCanvasElement);
+    dispose(): void;
+    private handleStateChanged;
+    private renderPage;
+}

package/dist/types/lib/types/loadableResource.d.ts

@@ -0,0 +1,11 @@
+interface UrlResource {
+    type: 'url';
+    url: string;
+}
+export type LoadableResource = UrlResource;
+export interface Resource {
+    resource: LoadableResource;
+}
+export declare function fromUri(uri: string): Resource;
+export declare function fromUrl(url: string): Resource;
+export {};

package/dist/types/polyfill/index.d.ts

@@ -0,0 +1 @@
+export default function (): void;

package/dist/types/polyfill/resize-observer.d.ts

@@ -0,0 +1 @@
+export default function (): void;