minerender 2.0.0-alpha.8 → 2.1.0-alpha.0

package/src/assets/AssetKey.ts

@@ -1,97 +0,0 @@
-import { Serializable } from "../Serializable";
-import { DEFAULT_NAMESPACE, DEFAULT_ROOT } from "./Assets";
-import { AssetLoader } from "./AssetLoader";
-
-export type AssetType = "models" | "textures" | "blockstates" | string;
-
-export class BasicAssetKey implements Serializable {
-
-    readonly namespace: string;
-    readonly path: string;
-
-    constructor(key: BasicAssetKey);
-    constructor(namespace: string, path: string);
-    constructor(namespaceOrKey: string | BasicAssetKey, path?: string) {
-        if (path) {
-            this.namespace = namespaceOrKey as string;
-            this.path = path;
-        } else {
-            this.namespace = (namespaceOrKey as BasicAssetKey).namespace;
-            this.path = (namespaceOrKey as BasicAssetKey).path
-        }
-    }
-
-    toNamespacedString() {
-        return this.namespace + ":" + this.path;
-    }
-
-    toString() {
-        return this.toNamespacedString();
-    }
-
-    serialize(): string {
-        return this.toString();
-    }
-}
-
-export class AssetKey extends BasicAssetKey {
-
-    constructor(
-        readonly namespace: string, readonly path: string,
-        public assetType?: AssetType,
-        public type?: string,
-        public rootType: "assets" | "data" | string = "assets",
-        public extension: ".json" | ".png" | string = ".json",
-        public root?: string,
-    ) {
-        super(namespace, path);
-    }
-
-
-    public static parse(assetType: AssetType, str: string, origin?: AssetKey): AssetKey {
-        let namespace = origin?.namespace || DEFAULT_NAMESPACE;
-        if (str.includes(":")) {
-            let split = str.split("\:");
-            namespace = split[0];
-            str = split[1];
-        }
-
-        let split = str.split("\/");
-        let type: string | undefined = undefined;
-        if (split.length > 1) {
-            type = split[0];
-            split.shift();
-        }
-        let path = split.join("/");
-
-        let extension = assetType === "models" ? ".json" :
-            assetType === "textures" ? ".png" :
-                origin?.assetType || "";
-
-        return new AssetKey(namespace, path, assetType, type, "assets", extension, origin?.root);
-    }
-
-    toString(): string {
-        let a = [
-            (typeof this.root !== 'undefined' || AssetLoader.ROOT !== DEFAULT_ROOT) ? (this.root ?? AssetLoader.ROOT) : "__root__",
-            this.rootType ?? "__rootType__",
-            this.assetType ?? "__assetType__",
-            this.type ?? "__type__",
-            this.namespace,
-            this.path
-        ];
-        return a.join("/");
-    }
-
-    serialize(): string {
-        return this.toString();
-    }
-}
-
-export function isBasicAssetKey(obj: any): obj is BasicAssetKey {
-    return "namespace" in obj && "path" in obj;
-}
-
-export function isAssetKey(obj: any): obj is AssetKey {
-    return isBasicAssetKey(obj) && "parse" in obj;
-}

package/src/assets/AssetLoader.ts

@@ -1,51 +0,0 @@
-import { Model, TextureAsset } from "../model/Model";
-import { Maybe } from "../util/util";
-import { Requests } from "../request/Requests";
-import { AxiosRequestConfig, AxiosResponse } from "axios";
-import { MinecraftAsset } from "../MinecraftAsset";
-import { ImageInfo, ImageLoader } from "../image/ImageLoader";
-import { MinecraftTextureMeta } from "../MinecraftTextureMeta";
-import { BlockState } from "../model/block/BlockState";
-import { DEFAULT_NAMESPACE, DEFAULT_ROOT } from "./Assets";
-import { ListAsset } from "../ListAsset";
-import { AssetKey } from "./AssetKey";
-import { NBTAsset, NBTHelper } from "../nbt/NBTHelper";
-import { prefix } from "../util/log";
-import { AssetSource } from "./source/AssetSource";
-import { AssetParser } from "./source/parser/AssetParsers";
-import { HostedAssetSource } from "./source";
-
-const p = prefix("AssetLoader");
-
-
-export class AssetLoader {
-
-    static ROOT: string = DEFAULT_ROOT;
-
-    private static _SOURCES: AssetSourceReference[] = [];
-
-    public static addSource(key: string, source: AssetSource) {
-        this._SOURCES.unshift({key, source});
-        console.log(p, "Added AssetSource", key);
-    }
-
-    static {
-        this.addSource("mcassets", new HostedAssetSource(DEFAULT_ROOT));
-    }
-
-    public static async get<T extends MinecraftAsset>(key: AssetKey, parser: AssetParser | string): Promise<Maybe<T>> {
-        for (const source of this._SOURCES) {
-            const result = await source.source.get<T>(key, parser);
-            if (result) {
-                return result;
-            }
-        }
-        return undefined;
-    }
-
-}
-
-interface AssetSourceReference {
-    key: string;
-    source: AssetSource;
-}

package/src/assets/Assets.ts

@@ -1,28 +0,0 @@
-import { Models } from "./Models";
-import { Model } from "../model/Model";
-import { Maybe } from "../util/util";
-import { BlockState } from "../model/block/BlockState";
-import { BlockStates } from "./BlockStates";
-import { AssetKey, AssetType } from "./AssetKey";
-
-export const DEFAULT_ROOT = "https://cdn.mcasset.cloud/file/minecraft-assets/1.17.1";
-export const DEFAULT_NAMESPACE = "minecraft";
-
-export class Assets {
-
-    /**
-     * @deprecated
-     */
-    public static parseAssetKey(assetType: AssetType, str: string, origin?: AssetKey): AssetKey {
-        return AssetKey.parse(assetType, str, origin);
-    }
-
-    public static async getModel(key: AssetKey): Promise<Maybe<Model>> {
-        return Models.getMerged(key);
-    }
-
-    public static async getBlockState(key: AssetKey): Promise<Maybe<BlockState>> {
-        return BlockStates.get(key);
-    }
-
-}

package/src/assets/BlockStates.ts

@@ -1,68 +0,0 @@
-import { Maybe } from "../util/util";
-import { BlockState } from "../model/block/BlockState";
-import { Caching } from "../cache/Caching";
-import { AssetLoader } from "./AssetLoader";
-import { DEFAULT_NAMESPACE, DEFAULT_ROOT } from "./Assets";
-import { Memoize } from "typescript-memoize";
-import defaultBlockStates from "../model/defaultBlockStates.json";
-import { BlockStateProperties, BlockStatePropertyDefaults } from "../model/block/BlockStateProperties";
-import { AssetKey } from "./AssetKey";
-import { PersistentCache } from "../cache/PersistentCache";
-import { AssetParser } from "./source/parser/AssetParsers";
-import { ListAsset } from "../ListAsset";
-
-export class BlockStates {
-
-    private static PERSISTENT_CACHE = PersistentCache.open("minerender-blockstates");
-
-    // BlockState names are hardcoded
-    @Memoize()
-    public static async getList(): Promise<string[]> {
-        return AssetLoader.get<ListAsset>(new AssetKey(
-            DEFAULT_NAMESPACE,
-            "_list",
-            "blockstates",
-            undefined,
-            "assets",
-            ".json",
-            DEFAULT_ROOT
-        ), AssetParser.LIST).then(r => r?.files ?? []);
-    }
-
-    public static getDefaultState(key: AssetKey): Maybe<BlockStatePropertyDefaults> {
-        return defaultBlockStates["minecraft:" + key.path] as BlockStatePropertyDefaults;
-    }
-
-    public static async get(key: AssetKey): Promise<Maybe<BlockState>> {
-        if (!key.assetType) {
-            key.assetType = "blockstates";
-        }
-        if (!key.extension) {
-            key.extension = ".json";
-        }
-        const keyStr = key.serialize();
-        return Caching.blockStateCache.get(keyStr, k => {
-            return this.PERSISTENT_CACHE.getOrLoad(keyStr, k1 => {
-                return AssetLoader.get<BlockState>(key, AssetParser.BLOCKSTATE);
-            })
-        }).then(asset => {
-            if (asset) {
-                asset.key = key;
-            }
-            return asset;
-        })
-    }
-
-    public static getAll(keys: AssetKey[] | Iterable<AssetKey>): Promise<Maybe<BlockState>[]> {
-        const promises: Promise<Maybe<BlockState>>[] = [];
-        for (let key of keys) {
-            promises.push(this.get(key));
-        }
-        return Promise.all(promises);
-    }
-
-    public static async clearCache() {
-        await this.PERSISTENT_CACHE.clear();
-    }
-
-}

package/src/assets/Entities.ts

@@ -1,40 +0,0 @@
-import blockEntityModels from "../entity/blockEntityModels.json";
-import entityModels from "../entity/entityModels.json";
-import { BasicAssetKey } from "./AssetKey";
-import { EntityModel } from "../entity/EntityModel";
-
-export class Entities {
-
-    // BlockEntity names are hardcoded
-    public static async getBlockList(): Promise<string[]> {
-        return Object.keys(blockEntityModels);
-    }
-
-    public static async getEntityList(): Promise<string[]> {
-        return Object.keys(entityModels);
-    }
-
-    public static async getBlock(modelKey: BasicAssetKey, textureKey?: BasicAssetKey): Promise<EntityModel> {
-        if (!textureKey) {
-            textureKey = modelKey
-        }
-        const baseKey = modelKey.path.includes("/") ? new BasicAssetKey(modelKey.namespace, modelKey.path.split("\/")[0]) : modelKey;
-        return {
-            key: textureKey,
-            parts: blockEntityModels[baseKey.toNamespacedString()]
-        }
-    }
-
-    public static async getEntity(modelKey: BasicAssetKey, textureKey?: BasicAssetKey): Promise<EntityModel> {
-        if (!textureKey) {
-            textureKey = modelKey
-        }
-        const baseKey = modelKey.path.includes("/") ? new BasicAssetKey(modelKey.namespace, modelKey.path.split("\/")[0]) : modelKey;
-        return {
-            key: textureKey,
-            parts: entityModels[baseKey.toNamespacedString()]
-        }
-    }
-
-
-}

package/src/assets/ModelTextures.ts

@@ -1,59 +0,0 @@
-import { Maybe } from "../util/util";
-import { TextureAsset } from "../model/Model";
-import { Caching } from "../cache/Caching";
-import { AssetLoader } from "./AssetLoader";
-import { CompatImage } from "../canvas/CanvasCompat";
-import { ImageLoader } from "../image/ImageLoader";
-import { ExtractableImageData } from "../ExtractableImageData";
-import { MinecraftTextureMeta } from "../MinecraftTextureMeta";
-import { PersistentCache } from "../cache/PersistentCache";
-import { keys } from "node-persist";
-import { AssetKey } from "./AssetKey";
-import { AssetParser } from "./source/parser/AssetParsers";
-
-export class ModelTextures {
-
-    private static PERSISTENT_META_CACHE = PersistentCache.open("minerender-texturemeta");
-
-    public static async get(key: AssetKey): Promise<Maybe<ExtractableImageData>> {
-        const asset = await this.preload(key);
-        if (asset) {
-            return ImageLoader.infoToCanvasData(asset);
-        }
-        return undefined;
-    }
-
-    public static async preload(key: AssetKey): Promise<Maybe<TextureAsset>> {
-        const keyStr = key.serialize();
-        return Caching.textureAssetCache.get(keyStr, k => {
-            return AssetLoader.get<TextureAsset>(key, AssetParser.IMAGE).then(asset => {
-                if (asset)
-                    asset.key = key;
-                return asset;
-            })
-        })
-    }
-
-    public static async getMeta(key: AssetKey): Promise<Maybe<MinecraftTextureMeta>> {
-        if (!key.extension || !key.extension.endsWith(".mcmeta")) {
-            key = Object.assign(new AssetKey("", ""), key);
-            key.extension += ".mcmeta";
-        }
-        const keyStr = key.serialize();
-
-        return Caching.textureMetaCache.get(keyStr, k => {
-            return this.PERSISTENT_META_CACHE.getOrLoad(keyStr, k1 => {
-                return AssetLoader.get<MinecraftTextureMeta>(key, AssetParser.META).then(asset => {
-                    if (asset)
-                        asset.key = key;
-                    return asset;
-                })
-            })
-        })
-    }
-
-    public static async clearCache() {
-        await this.PERSISTENT_META_CACHE.clear();
-    }
-
-}

package/src/assets/Models.ts

@@ -1,81 +0,0 @@
-import { Model } from "../model/Model";
-import { Caching } from "../cache/Caching";
-import { Textures } from "../texture/Textures";
-import { Maybe } from "../util/util";
-import { ModelMerger } from "../model/ModelMerger";
-import { AssetLoader } from "./AssetLoader";
-import { Memoize } from "typescript-memoize";
-import { DEFAULT_NAMESPACE, DEFAULT_ROOT } from "./Assets";
-import { PersistentCache } from "../cache/PersistentCache";
-import { AssetKey } from "./AssetKey";
-import { ListAsset } from "../ListAsset";
-import { AssetParser } from "./source/parser/AssetParsers";
-
-export class Models {
-
-    private static PERSISTENT_CACHE = PersistentCache.open("minerender-models");
-
-    @Memoize()
-    public static async getItemList(): Promise<string[]> {
-        return AssetLoader.get<ListAsset>(new AssetKey(
-            DEFAULT_NAMESPACE,
-            "_list",
-            "models",
-            "item",
-            "assets",
-            ".json",
-            DEFAULT_ROOT
-        ), AssetParser.LIST).then(r => r?.files ?? []);
-    }
-
-    public static async loadAndMerge(key: AssetKey): Promise<Maybe<Model>> {
-        const model = await this.getRaw(key);
-        if (!model) {
-            return undefined;
-        }
-        return ModelMerger.mergeWithParents(model);
-    }
-
-    public static async getRaw(key: AssetKey): Promise<Maybe<Model>> {
-        if (!key.assetType) {
-            key.assetType = "models";
-        }
-        if (!key.extension) {
-            key.extension = ".json";
-        }
-        const keyStr = key.serialize();
-        return Caching.rawModelCache.get(keyStr, k => {
-            return this.PERSISTENT_CACHE.getOrLoad(keyStr, k1 => {
-                return AssetLoader.get<Model>(key, AssetParser.MODEL);
-            })
-        }).then(asset => {
-            if (asset) {
-                asset.key = key;
-            }
-            return asset;
-        })
-    }
-
-    public static async getMerged(key: AssetKey): Promise<Maybe<Model>> {
-        if (!key.assetType) {
-            key.assetType = "models";
-        }
-        if (!key.extension) {
-            key.extension = ".json";
-        }
-        const keyStr = key.serialize();
-        return Caching.mergedModelCache.get(keyStr, k => {
-            //TODO: persistent cache
-            return Models.loadAndMerge(key);
-        });
-    }
-
-    public static async get(key: AssetKey): Promise<Maybe<Model>> {
-        return this.getMerged(key);
-    }
-
-    public static async clearCache() {
-        return this.PERSISTENT_CACHE.clear();
-    }
-
-}

package/src/assets/index.ts

@@ -1,9 +0,0 @@
-// autogenerated
-export * from './AssetKey';
-export * from './AssetLoader';
-export * from './Assets';
-export * from './BlockStates';
-export * from './Entities';
-export * from './ModelTextures';
-export * from './Models';
-export * from './source';

package/src/assets/source/AssetSource.ts

@@ -1,13 +0,0 @@
-import { MinecraftAsset } from "../../MinecraftAsset";
-import { AssetKey } from "../AssetKey";
-import { Maybe } from "../../util";
-import { AssetParser } from "./parser/AssetParsers";
-
-export abstract class AssetSource {
-
-    protected constructor() {
-    }
-
-    public abstract get<T extends MinecraftAsset>(key: AssetKey, parser: AssetParser | string): Promise<Maybe<T>>;
-
-}

package/src/assets/source/HostedAssetSource.ts

@@ -1,191 +0,0 @@
-import { AssetSource } from ".";
-import { BlockState, Model, TextureAsset } from "../../model";
-import { AxiosRequestConfig, AxiosResponse } from "axios";
-import { Maybe, prefix } from "../../util";
-import { MinecraftTextureMeta } from "../../MinecraftTextureMeta";
-import { NBTAsset, NBTHelper } from "../../nbt";
-import { ImageLoader } from "../../image";
-import { ListAsset } from "../../ListAsset";
-import { MinecraftAsset } from "../../MinecraftAsset";
-import { AssetKey } from "../AssetKey";
-import { DEFAULT_NAMESPACE, DEFAULT_ROOT } from "../Assets";
-import { Requests } from "../../request";
-import { AssetLoader } from "../AssetLoader";
-import { AssetParser } from "./parser";
-import { ResponseParser } from "./parser";
-import merge from "ts-deepmerge";
-
-const p = prefix("HostedAssetSource");
-
-const DEFAULT_OPTIONS: HostedAssetSourceOptions = {
-    retryDefaults: true
-}
-
-export class HostedAssetSource extends AssetSource {
-
-    static readonly MODEL: ResponseParser<Model> = {
-        config(request: AxiosRequestConfig) {
-        },
-        parse(response: AxiosResponse): Maybe<Model> {
-            return response.data as Model;
-        }
-    }
-    static readonly BLOCKSTATE: ResponseParser<BlockState> = {
-        config(request: AxiosRequestConfig) {
-        },
-        parse(response: AxiosResponse): Maybe<BlockState> {
-            return response.data as BlockState;
-        }
-    }
-    static readonly META: ResponseParser<MinecraftTextureMeta> = {
-        config(request: AxiosRequestConfig) {
-            // request.responseType = "arraybuffer";
-        },
-        parse(response: AxiosResponse): Maybe<MinecraftTextureMeta> {
-            return response.data as MinecraftTextureMeta;
-        }
-    }
-    static readonly NBT: ResponseParser<NBTAsset> = {
-        config(request: AxiosRequestConfig) {
-            request.responseType = "arraybuffer";
-        },
-        parse(response: AxiosResponse): Promise<Maybe<NBTAsset>> {
-            return NBTHelper.fromBuffer(Buffer.from(response.data));
-        }
-    }
-    static readonly IMAGE: ResponseParser<TextureAsset> = {
-        config(request: AxiosRequestConfig) {
-            request.responseType = "arraybuffer";
-        },
-        async parse(response: AxiosResponse): Promise<Maybe<TextureAsset>> {
-            return await ImageLoader.processResponse(response) as TextureAsset;
-        }
-    }
-    static readonly LIST: ResponseParser<ListAsset> = {
-        config(request: AxiosRequestConfig) {
-        },
-        parse(response: AxiosResponse): Maybe<ListAsset> {
-            return response.data as ListAsset;
-        }
-    }
-    static readonly JSON: ResponseParser<any> = {
-        config(request: AxiosRequestConfig) {
-        },
-        parse(response: AxiosResponse): Maybe<any> {
-            return response.data;
-        }
-    }
-
-    static readonly PARSER_MAP: Map<AssetParser, ResponseParser<any>> = new Map<AssetParser, ResponseParser<any>>([
-        [AssetParser.MODEL, HostedAssetSource.MODEL],
-        [AssetParser.BLOCKSTATE, HostedAssetSource.BLOCKSTATE],
-        [AssetParser.META, HostedAssetSource.META],
-        [AssetParser.NBT, HostedAssetSource.NBT],
-        [AssetParser.IMAGE, HostedAssetSource.IMAGE],
-        [AssetParser.LIST, HostedAssetSource.LIST],
-        [AssetParser.JSON, HostedAssetSource.JSON],
-    ]);
-
-    public async loadOrRetryWithDefaults<T extends MinecraftAsset>(key: AssetKey, parser: ResponseParser<T>): Promise<Maybe<T>> {
-        const direct = await this.load<T>(key, parser);
-        if (typeof direct !== "undefined") {
-            return direct;
-        }
-        if (key.namespace !== DEFAULT_NAMESPACE) {
-            console.info(p, "Retrying", key, "with default namespace");
-            // Try on the same host but with default minecraft: namespace
-            const namespaceKey = new AssetKey(DEFAULT_NAMESPACE, key.path, key.assetType, key.type, key.rootType, key.extension, key.root);
-            const namespaced = await this.load<T>(namespaceKey, parser);
-            if (typeof namespaced !== "undefined") {
-                return namespaced;
-            }
-            if ((typeof key.root !== "undefined" && key.root !== DEFAULT_ROOT) || (typeof this.root !== "undefined" && this.root !== DEFAULT_ROOT)) {
-                console.info(p, "Retrying", key, "with default root+namespace");
-                // Try both defaults
-                const namespacedRootedKey = new AssetKey(DEFAULT_NAMESPACE, key.path, key.assetType, key.type, key.rootType, key.extension, DEFAULT_ROOT);
-                const namespacedRooted = await this.load<T>(namespacedRootedKey, parser);
-                if (typeof namespacedRooted !== "undefined") {
-                    return namespacedRooted;
-                }
-            }
-        } else if ((typeof key.root !== "undefined" && key.root !== DEFAULT_ROOT) || (typeof this.root !== "undefined" && this.root !== DEFAULT_ROOT)) {
-            console.info(p, "Retrying", key, "with default root");
-            // Try on default root
-            const rootKey = new AssetKey(key.namespace, key.path, key.assetType, key.type, key.rootType, key.extension, DEFAULT_ROOT);
-            const rooted = await this.load<T>(rootKey, parser);
-            if (typeof rooted !== "undefined") {
-                return rooted;
-            }
-        }
-        return undefined;
-    }
-
-
-    protected async load<T extends MinecraftAsset>(key: AssetKey, parser: ResponseParser<T>): Promise<Maybe<T>> {
-        console.info(p, "Loading", key);
-        const url = `${ this.assetBasePath(key) }${ key.type !== undefined ? key.type + '/' : '' }${ key.path }${ key.extension }`;
-        console.debug(p, url);
-        let req: AxiosRequestConfig = {
-            url: url
-        };
-        parser.config(req);
-        // @ts-ignore
-        return await Requests.mcAssetRequest(req)
-            .then(response => {
-                if (response && response.data) {
-                    try {
-                        return parser.parse(response);
-                    } catch (e) {
-                        console.warn("Parser failed to process response", response, e);
-                        throw e;
-                    }
-                }
-                return undefined;
-            })
-            .catch(err => {
-                if (err.response) {
-                    let response = err.response as AxiosResponse;
-                    if (response.status === 404) {
-                        console.debug(p, key, "not found");
-                        return undefined;
-                    }
-                }
-                console.debug(p, "Failed to load", key, err?.message);
-                return undefined;
-            })
-    }
-
-    public assetBasePath(key: AssetKey) {
-        return `${ key.root ?? this.root ?? AssetLoader.ROOT }/${ key.rootType !== undefined ? key.rootType + '/' : '' }${ key.namespace !== undefined ? key.namespace + '/' : '' }${ key.assetType !== undefined ? key.assetType + '/' : '' }`;
-    }
-
-    private readonly _root: string;
-    private readonly _options: HostedAssetSourceOptions;
-
-    public constructor(root: string, options?: Partial<HostedAssetSourceOptions>) {
-        super();
-        this._root = root;
-        this._options = merge({}, DEFAULT_OPTIONS, options ?? {});
-    }
-
-    public get root(): string {
-        return this._root;
-    }
-
-    public get options(): HostedAssetSourceOptions {
-        return this._options;
-    }
-
-    public get<T extends MinecraftAsset>(key: AssetKey, parser: AssetParser): Promise<Maybe<T>> {
-        const responseParser = HostedAssetSource.PARSER_MAP.get(parser) as ResponseParser<T>;
-        if (this.options.retryDefaults) {
-            return this.loadOrRetryWithDefaults(key, responseParser);
-        }
-        return this.load(key, responseParser);
-    }
-
-}
-
-interface HostedAssetSourceOptions {
-    retryDefaults: boolean;
-}

package/src/assets/source/index.ts

@@ -1,4 +0,0 @@
-// autogenerated
-export * from './AssetSource';
-export * from './HostedAssetSource';
-export * from './parser';

package/src/assets/source/parser/AssetParsers.ts

@@ -1,11 +0,0 @@
-export enum AssetParser {
-
-    MODEL = "model",
-    BLOCKSTATE = "blockstate",
-    META = "meta",
-    NBT = "nbt",
-    IMAGE = "image",
-    LIST = "list",
-    JSON = "json",
-
-}

package/src/assets/source/parser/ResponseParser.ts

@@ -1,9 +0,0 @@
-import { AxiosRequestConfig, AxiosResponse } from "axios";
-import { Maybe } from "../../../util";
-import { MinecraftAsset } from "../../../MinecraftAsset";
-
-export interface ResponseParser<T extends MinecraftAsset> {
-    config(request: AxiosRequestConfig);
-
-    parse(response: AxiosResponse): Maybe<T> | Promise<Maybe<T>>;
-}

package/src/assets/source/parser/index.ts

@@ -1,3 +0,0 @@
-// autogenerated
-export * from './AssetParsers';
-export * from './ResponseParser';