@prose-reader/streamer 0.0.22

package/dist/archives/createArchiveFromArrayBufferList.d.ts

@@ -0,0 +1,10 @@
+import { Archive } from "./types";
+export declare const createArchiveFromArrayBufferList: (list: {
+    isDir: boolean;
+    name: string;
+    size: number;
+    data: () => Promise<ArrayBuffer>;
+}[], { orderByAlpha, name }?: {
+    orderByAlpha?: boolean | undefined;
+    name?: string | undefined;
+}) => Promise<Archive>;

package/dist/archives/createArchiveFromArrayBufferList.js

@@ -0,0 +1,35 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { sortByTitleComparator } from "../utils/sortByTitleComparator";
+import { getUriBasename } from "../utils/uri";
+export const createArchiveFromArrayBufferList = (list, { orderByAlpha, name } = {}) => __awaiter(void 0, void 0, void 0, function* () {
+    let files = list;
+    if (orderByAlpha) {
+        files = files.sort((a, b) => sortByTitleComparator(a.name, b.name));
+    }
+    return {
+        filename: name || ``,
+        files: files.map(file => ({
+            dir: file.isDir,
+            basename: getUriBasename(file.name),
+            uri: file.name,
+            blob: () => __awaiter(void 0, void 0, void 0, function* () { return new Blob([yield file.data()]); }),
+            string: () => __awaiter(void 0, void 0, void 0, function* () {
+                const data = yield file.data();
+                return String.fromCharCode.apply(null, Array.from(new Uint16Array(data)));
+            }),
+            base64: () => __awaiter(void 0, void 0, void 0, function* () {
+                // @todo not used for now, lets implement it later if needed
+                return ``;
+            }),
+            size: file.size
+        }))
+    };
+});

package/dist/archives/createArchiveFromJszip.d.ts

@@ -0,0 +1,34 @@
+/// <reference types="node" />
+import { Archive, StreamResult } from "./types";
+interface OutputByType {
+    base64: string;
+    string: string;
+    text: string;
+    binarystring: string;
+    array: number[];
+    uint8array: Uint8Array;
+    arraybuffer: ArrayBuffer;
+    blob: Blob;
+    nodebuffer: Buffer;
+}
+declare type OutputType = keyof OutputByType;
+interface JSZipObject {
+    name: string;
+    dir: boolean;
+    date: Date;
+    comment: string;
+    unixPermissions: number | string | null;
+    dosPermissions: number | null;
+    async<T extends OutputType>(type: T): Promise<OutputByType[T]>;
+    internalStream?: (type?: `uint8array`) => StreamResult;
+}
+interface JSZip {
+    files: {
+        [key: string]: JSZipObject;
+    };
+}
+export declare const createArchiveFromJszip: (jszip: JSZip, { orderByAlpha, name }?: {
+    orderByAlpha?: boolean | undefined;
+    name?: string | undefined;
+}) => Promise<Archive>;
+export {};

package/dist/archives/createArchiveFromJszip.js

@@ -0,0 +1,26 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { sortByTitleComparator } from "../utils/sortByTitleComparator";
+import { getUriBasename } from "../utils/uri";
+export const createArchiveFromJszip = (jszip, { orderByAlpha, name } = {}) => __awaiter(void 0, void 0, void 0, function* () {
+    let files = Object.values(jszip.files);
+    if (orderByAlpha) {
+        files = files.sort((a, b) => sortByTitleComparator(a.name, b.name));
+    }
+    return {
+        filename: name || ``,
+        files: files.map(file => (Object.assign(Object.assign({ dir: file.dir, basename: getUriBasename(file.name), uri: file.name, blob: () => file.async(`blob`), string: () => file.async(`string`), base64: () => file.async(`base64`) }, file.internalStream && {
+            stream: file.internalStream
+        }), { 
+            // this is private API
+            // @ts-ignore
+            size: file._data.uncompressedSize })))
+    };
+});

package/dist/archives/createArchiveFromText.d.ts

@@ -0,0 +1,7 @@
+import { Archive } from "./types";
+/**
+ * Useful to create archive from txt content
+ */
+export declare const createArchiveFromText: (content: string | Blob | File, options?: {
+    direction: `ltr` | `rtl`;
+} | undefined) => Promise<Archive>;

package/dist/archives/createArchiveFromText.js

@@ -0,0 +1,67 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { blobToBase64 } from "../utils/blobToBAse64";
+import { getUriBasename } from "../utils/uri";
+/**
+ * Useful to create archive from txt content
+ */
+export const createArchiveFromText = (content, options) => __awaiter(void 0, void 0, void 0, function* () {
+    const txtOpfContent = `
+      <?xml version="1.0" encoding="UTF-8"?>
+      <package xmlns="http://www.idpf.org/2007/opf" version="3.0" xml:lang="ja" prefix="rendition: http://www.idpf.org/vocab/rendition/#"
+        unique-identifier="ootuya-id">
+        <metadata xmlns:opf="http://www.idpf.org/2007/opf" xmlns:dc="http://purl.org/dc/elements/1.1/"
+              xmlns:dcterms="http://purl.org/dc/terms/">
+              <meta property="rendition:layout">reflowable</meta>
+        </metadata>
+        <manifest>
+            <item id="p01" href="p01.txt" media-type="text/plain"/>
+        </manifest>
+        <spine page-progression-direction="${(options === null || options === void 0 ? void 0 : options.direction) || `ltr`}">
+          <itemref idref="p01" />
+        </spine>
+      </package>
+    `;
+    const archive = {
+        filename: `content.txt`,
+        files: [{
+                dir: false,
+                basename: getUriBasename(`generated.opf`),
+                uri: `generated.opf`,
+                blob: () => __awaiter(void 0, void 0, void 0, function* () { return new Blob([txtOpfContent]); }),
+                string: () => __awaiter(void 0, void 0, void 0, function* () { return txtOpfContent; }),
+                base64: () => __awaiter(void 0, void 0, void 0, function* () { return btoa(txtOpfContent); }),
+                size: 0
+            },
+            {
+                dir: false,
+                basename: getUriBasename(`p01.txt`),
+                uri: `p01.txt`,
+                blob: () => __awaiter(void 0, void 0, void 0, function* () {
+                    if (typeof content === `string`)
+                        return new Blob([content]);
+                    return content;
+                }),
+                string: () => __awaiter(void 0, void 0, void 0, function* () {
+                    if (typeof content === `string`)
+                        return content;
+                    return content.text();
+                }),
+                base64: () => __awaiter(void 0, void 0, void 0, function* () {
+                    if (typeof content === `string`)
+                        return btoa(content);
+                    return blobToBase64(content);
+                }),
+                size: typeof content === `string` ? content.length : content.size,
+                encodingFormat: `text/plain`
+            }]
+    };
+    return archive;
+});

package/dist/archives/createArchiveFromUrls.d.ts

@@ -0,0 +1,7 @@
+import { Archive } from "./types";
+/**
+ * @important
+ * Make sure the urls are on the same origin or the cors header is set otherwise
+ * the resource cannot be consumed as it is on the web.
+ */
+export declare const createArchiveFromUrls: (urls: string[]) => Promise<Archive>;

package/dist/archives/createArchiveFromUrls.js

@@ -0,0 +1,29 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { getUriBasename } from "../utils/uri";
+/**
+ * @important
+ * Make sure the urls are on the same origin or the cors header is set otherwise
+ * the resource cannot be consumed as it is on the web.
+ */
+export const createArchiveFromUrls = (urls) => __awaiter(void 0, void 0, void 0, function* () {
+    return {
+        filename: ``,
+        files: urls.map(url => ({
+            dir: false,
+            basename: getUriBasename(url),
+            uri: url,
+            size: 100 / urls.length,
+            base64: () => __awaiter(void 0, void 0, void 0, function* () { return ``; }),
+            blob: () => __awaiter(void 0, void 0, void 0, function* () { return new Blob(); }),
+            string: () => __awaiter(void 0, void 0, void 0, function* () { return ``; })
+        }))
+    };
+});

package/dist/archives/getArchiveOpfInfo.d.ts

@@ -0,0 +1,15 @@
+import { Archive } from "./types";
+export declare const getArchiveOpfInfo: (archive: Archive) => {
+    data: {
+        dir: boolean;
+        basename: string;
+        uri: string;
+        blob: () => Promise<Blob>;
+        string: () => Promise<string>;
+        base64: () => Promise<string>;
+        stream?: (() => import("./types").StreamResult) | undefined;
+        size: number;
+        encodingFormat?: "text/plain" | undefined;
+    } | undefined;
+    basePath: string;
+};

package/dist/archives/getArchiveOpfInfo.js

@@ -0,0 +1,8 @@
+export const getArchiveOpfInfo = (archive) => {
+    const filesAsArray = Object.values(archive.files).filter(file => !file.dir);
+    const file = filesAsArray.find(file => file.uri.endsWith(`.opf`));
+    return {
+        data: file,
+        basePath: (file === null || file === void 0 ? void 0 : file.uri.substring(0, file.uri.lastIndexOf(`/`))) || ``
+    };
+};

package/dist/archives/types.d.ts

@@ -0,0 +1,20 @@
+export interface StreamResult {
+    on(e: `data`, cb: (data: Uint8Array) => void): void;
+    on(e: `error`, cb: (error: Error) => void): void;
+    on(e: `end`, cb: () => void): void;
+    resume(): void;
+}
+export declare type Archive = {
+    filename: string;
+    files: {
+        dir: boolean;
+        basename: string;
+        uri: string;
+        blob: () => Promise<Blob>;
+        string: () => Promise<string>;
+        base64: () => Promise<string>;
+        stream?: () => StreamResult;
+        size: number;
+        encodingFormat?: undefined | `text/plain`;
+    }[];
+};

package/dist/archives/types.js

@@ -0,0 +1 @@
+export {};

package/dist/generators/manifest.d.ts

@@ -0,0 +1,10 @@
+import xmldoc from 'xmldoc';
+import { Archive } from '..';
+export declare const getManifestFromArchive: (archive: Archive, { baseUrl }?: {
+    baseUrl?: string | undefined;
+}) => Promise<Response>;
+export declare const getItemsFromDoc: (doc: xmldoc.XmlDocument) => {
+    href: string;
+    id: string;
+    mediaType: string | undefined;
+}[];

package/dist/generators/manifest.js

@@ -0,0 +1,141 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import xmldoc from 'xmldoc';
+import { parseToc } from '../parsers/nav';
+import { extractKoboInformationFromArchive } from '../parsers/kobo';
+import { Report } from '../report';
+import { getArchiveOpfInfo } from '..';
+const generateManifestFromEpub = (archive, baseUrl) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const { data: opsFile, basePath: opfBasePath } = getArchiveOpfInfo(archive) || {};
+    const koboInformation = yield extractKoboInformationFromArchive(archive);
+    if (!opsFile) {
+        throw new Error(`No opf content`);
+    }
+    const data = yield opsFile.string();
+    Report.log(data, koboInformation);
+    const opfXmlDoc = new xmldoc.XmlDocument(data);
+    const toc = (yield parseToc(opfXmlDoc, archive, { baseUrl })) || [];
+    const metadataElm = opfXmlDoc.childNamed(`metadata`);
+    const manifestElm = opfXmlDoc.childNamed(`manifest`);
+    const spineElm = opfXmlDoc.childNamed(`spine`);
+    const guideElm = opfXmlDoc.childNamed(`guide`);
+    const titleElm = metadataElm === null || metadataElm === void 0 ? void 0 : metadataElm.childNamed(`dc:title`);
+    const metaElmChildren = (metadataElm === null || metadataElm === void 0 ? void 0 : metadataElm.childrenNamed(`meta`)) || [];
+    const metaElmWithRendition = metaElmChildren.find(meta => meta.attr.property === `rendition:layout`);
+    const metaElmWithRenditionFlow = metaElmChildren.find(meta => meta.attr.property === `rendition:flow`);
+    const metaElmWithRenditionSpread = metaElmChildren.find(meta => meta.attr.property === `rendition:spread`);
+    const publisherRenditionLayout = metaElmWithRendition === null || metaElmWithRendition === void 0 ? void 0 : metaElmWithRendition.val;
+    const publisherRenditionFlow = metaElmWithRenditionFlow === null || metaElmWithRenditionFlow === void 0 ? void 0 : metaElmWithRenditionFlow.val;
+    const renditionSpread = metaElmWithRenditionSpread === null || metaElmWithRenditionSpread === void 0 ? void 0 : metaElmWithRenditionSpread.val;
+    const title = (titleElm === null || titleElm === void 0 ? void 0 : titleElm.val) || ((_a = archive.files.find(({ dir }) => dir)) === null || _a === void 0 ? void 0 : _a.basename) || ``;
+    const pageProgressionDirection = spineElm === null || spineElm === void 0 ? void 0 : spineElm.attr[`page-progression-direction`];
+    const spineItemIds = spineElm === null || spineElm === void 0 ? void 0 : spineElm.childrenNamed(`itemref`).map((item) => item.attr.idref);
+    const manifestItemsFromSpine = (manifestElm === null || manifestElm === void 0 ? void 0 : manifestElm.childrenNamed(`item`).filter((item) => spineItemIds.includes(item.attr.id || ``))) || [];
+    const archiveSpineItems = archive.files.filter(file => {
+        return manifestItemsFromSpine.find(item => {
+            if (!opfBasePath)
+                return `${item.attr.href}` === file.uri;
+            return `${opfBasePath}/${item.attr.href}` === file.uri;
+        });
+    });
+    const totalSize = archiveSpineItems.reduce((size, file) => file.size + size, 1);
+    return {
+        filename: archive.filename,
+        nav: {
+            toc
+        },
+        renditionLayout: publisherRenditionLayout || koboInformation.renditionLayout || `reflowable`,
+        renditionFlow: publisherRenditionFlow || `auto`,
+        renditionSpread,
+        title,
+        readingDirection: pageProgressionDirection || `ltr`,
+        spineItems: (spineElm === null || spineElm === void 0 ? void 0 : spineElm.childrenNamed(`itemref`).map((itemrefElm) => {
+            var _a, _b;
+            const manifestItem = manifestElm === null || manifestElm === void 0 ? void 0 : manifestElm.childrenNamed(`item`).find((item) => item.attr.id === (itemrefElm === null || itemrefElm === void 0 ? void 0 : itemrefElm.attr.idref));
+            const href = (manifestItem === null || manifestItem === void 0 ? void 0 : manifestItem.attr.href) || ``;
+            const properties = (((_a = itemrefElm === null || itemrefElm === void 0 ? void 0 : itemrefElm.attr.properties) === null || _a === void 0 ? void 0 : _a.split(` `)) || []);
+            const itemSize = ((_b = archive.files.find(file => file.uri.endsWith(href))) === null || _b === void 0 ? void 0 : _b.size) || 0;
+            return Object.assign(Object.assign({ id: (manifestItem === null || manifestItem === void 0 ? void 0 : manifestItem.attr.id) || ``, path: opfBasePath ? `${opfBasePath}/${manifestItem === null || manifestItem === void 0 ? void 0 : manifestItem.attr.href}` : `${manifestItem === null || manifestItem === void 0 ? void 0 : manifestItem.attr.href}`, 
+                // href: opfBasePath ? `${baseUrl}/${opfBasePath}/${manifestItem?.attr['href']}` : `${baseUrl}/${manifestItem?.attr['href']}`,
+                href: opfBasePath ? `${baseUrl}/${opfBasePath}/${manifestItem === null || manifestItem === void 0 ? void 0 : manifestItem.attr.href}` : `${baseUrl}/${manifestItem === null || manifestItem === void 0 ? void 0 : manifestItem.attr.href}`, renditionLayout: publisherRenditionLayout || `reflowable` }, properties.find(property => property === `rendition:layout-reflowable`) && {
+                renditionLayout: `reflowable`
+            }), { progressionWeight: itemSize / totalSize, pageSpreadLeft: properties.some(property => property === `page-spread-left`) || undefined, pageSpreadRight: properties.some(property => property === `page-spread-right`) || undefined, 
+                // size: itemSize
+                mediaType: manifestItem === null || manifestItem === void 0 ? void 0 : manifestItem.attr[`media-type`] });
+        })) || [],
+        items: getItemsFromDoc(opfXmlDoc),
+        guide: guideElm === null || guideElm === void 0 ? void 0 : guideElm.childrenNamed(`reference`).map(elm => {
+            return {
+                href: elm.attr.href || ``,
+                title: elm.attr.title || ``,
+                type: elm.attr.type
+            };
+        })
+    };
+});
+/**
+ * Create a manifest from a generic archive.
+ * Will use direct
+ */
+const generateManifestFromArchive = (archive, baseUrl) => __awaiter(void 0, void 0, void 0, function* () {
+    var _b;
+    const files = Object.values(archive.files).filter(file => !file.dir);
+    return {
+        filename: archive.filename,
+        nav: {
+            toc: []
+        },
+        title: ((_b = archive.files.find(({ dir }) => dir)) === null || _b === void 0 ? void 0 : _b.basename.replace(/\/$/, ``)) || ``,
+        renditionLayout: `pre-paginated`,
+        renditionSpread: `auto`,
+        readingDirection: `ltr`,
+        spineItems: files.map((file) => ({
+            id: file.basename,
+            path: `${file.uri}`,
+            href: baseUrl ? `${baseUrl}/${file.uri}` : file.uri,
+            renditionLayout: `pre-paginated`,
+            progressionWeight: (1 / files.length),
+            pageSpreadLeft: undefined,
+            pageSpreadRight: undefined
+        })),
+        items: files.map((file) => ({
+            id: file.basename,
+            href: baseUrl ? `${baseUrl}/${file.uri}` : file.uri
+        }))
+    };
+});
+export const getManifestFromArchive = (archive, { baseUrl = `` } = {}) => __awaiter(void 0, void 0, void 0, function* () {
+    var _c;
+    const { data: opsFile } = getArchiveOpfInfo(archive) || {};
+    try {
+        if (opsFile) {
+            const manifest = yield generateManifestFromEpub(archive, baseUrl);
+            const data = JSON.stringify(manifest);
+            return new Response(data, { status: 200 });
+        }
+        const manifest = yield generateManifestFromArchive(archive, baseUrl);
+        const data = JSON.stringify(manifest);
+        return new Response(data, { status: 200 });
+    }
+    catch (e) {
+        Report.error(e);
+        return new Response((_c = e) === null || _c === void 0 ? void 0 : _c.message, { status: 500 });
+    }
+});
+export const getItemsFromDoc = (doc) => {
+    var _a;
+    const manifestElm = doc.childNamed(`manifest`);
+    return ((_a = manifestElm === null || manifestElm === void 0 ? void 0 : manifestElm.childrenNamed(`item`)) === null || _a === void 0 ? void 0 : _a.map((el) => ({
+        href: el.attr.href || ``,
+        id: el.attr.id || ``,
+        mediaType: el.attr[`media-type`]
+    }))) || [];
+};

package/dist/generators/resources.d.ts

@@ -0,0 +1,2 @@
+import { Archive } from '..';
+export declare const getResourceFromArchive: (archive: Archive, resourcePath: string) => Promise<Response>;

package/dist/generators/resources.js

@@ -0,0 +1,95 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import xmldoc from 'xmldoc';
+import { getArchiveOpfInfo } from '..';
+import { getItemsFromDoc } from "./manifest";
+export const getResourceFromArchive = (archive, resourcePath) => __awaiter(void 0, void 0, void 0, function* () {
+    const file = Object.values(archive.files).find(file => file.uri === resourcePath);
+    const metadata = yield getMetadata(archive, resourcePath);
+    if (!file) {
+        throw new Error(`no file found`);
+    }
+    const blob = yield file.blob();
+    // if (file.stream) {
+    //   const stream = file.stream()
+    //   console.log(file, stream)
+    //   stream.on(`data`, data => {
+    //     console.log(`data`, data)
+    //   })
+    //   stream.on(`error`, data => {
+    //     console.error(`error`, data)
+    //   })
+    //   stream.on(`end`, () => {
+    //     console.log(`end`)
+    //   })
+    // }
+    // const stream = file.stream!()
+    // const readableStream = new ReadableStream({
+    //   start(controller) {
+    //     function push() {
+    //       stream.on(`data`, data => {
+    //         controller.enqueue(data)
+    //       })
+    //       stream.on(`error`, data => {
+    //         console.error(`error`, data)
+    //       })
+    //       stream.on(`end`, () => {
+    //         controller.close()
+    //       })
+    //       stream.resume()
+    //     }
+    //     push();
+    //   }
+    // })
+    const response = new Response(blob, {
+        headers: Object.assign(Object.assign(Object.assign({}, blob.type && {
+            'Content-Type': blob.type
+        }), file.encodingFormat && {
+            'Content-Type': file.encodingFormat
+        }), metadata.mediaType && {
+            'Content-Type': metadata.mediaType
+        }
+        // 'Cache-Control': `no-cache, no-store, no-transform`
+        )
+    });
+    return response;
+});
+const getMetadata = (archive, resourcePath) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const opfInfo = getArchiveOpfInfo(archive);
+    const data = yield ((_a = opfInfo.data) === null || _a === void 0 ? void 0 : _a.string());
+    if (data) {
+        const opfXmlDoc = new xmldoc.XmlDocument(data);
+        const items = getItemsFromDoc(opfXmlDoc);
+        return {
+            mediaType: (_b = items.find((item) => resourcePath.endsWith(item.href))) === null || _b === void 0 ? void 0 : _b.mediaType
+        };
+    }
+    return {
+        mediaType: getContentTypeFromExtension(resourcePath)
+    };
+});
+const getContentTypeFromExtension = (uri) => {
+    if (uri.endsWith(`.css`)) {
+        return `text/css; charset=UTF-8`;
+    }
+    if (uri.endsWith(`.jpg`)) {
+        return `image/jpg`;
+    }
+    if (uri.endsWith(`.xhtml`)) {
+        return `application/xhtml+xml`;
+    }
+    if (uri.endsWith(`.mp4`)) {
+        return `video/mp4`;
+    }
+    if (uri.endsWith(`.svg`)) {
+        return `image/svg+xml`;
+    }
+};

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { getResourceFromArchive } from './generators/resources';
+export { getManifestFromArchive } from './generators/manifest';
+export type { Manifest } from '@prose-reader/shared';
+export { Report } from './report';
+export { Archive } from './archives/types';
+export { getArchiveOpfInfo } from './archives/getArchiveOpfInfo';
+export { createArchiveFromUrls } from './archives/createArchiveFromUrls';
+export { createArchiveFromText } from './archives/createArchiveFromText';
+export { createArchiveFromJszip } from './archives/createArchiveFromJszip';
+export { createArchiveFromArrayBufferList } from './archives/createArchiveFromArrayBufferList';