@expofp/loader 1.0.78 → 1.0.91

package/dist/esm/offline/slugify.js

@@ -1,61 +0,0 @@
-// Module-level caches
-const inputToSlug = new Map();
-const slugToInput = new Map();
-const WINDOWS_RESERVED = new Set([
-    "con", "prn", "aux", "nul",
-    "com1", "com2", "com3", "com4", "com5", "com6", "com7", "com8", "com9",
-    "lpt1", "lpt2", "lpt3", "lpt4", "lpt5", "lpt6", "lpt7", "lpt8", "lpt9",
-]);
-function makeBaseSlug(input) {
-    let slug = input
-        .normalize("NFKD")
-        // All non letters/numbers → "-"
-        .replace(/[^\p{Letter}\p{Number}]+/gu, "-")
-        // Collapse multiple "-"
-        .replace(/-+/g, "-")
-        // Trim "-" from start/end
-        .replace(/^-|-$/g, "")
-        .toLowerCase();
-    // Strip forbidden Windows characters just in case
-    slug = slug.replace(/[<>:"/\\|?*]/g, "");
-    // Windows forbids trailing space/period
-    slug = slug.replace(/[. ]+$/g, "");
-    // Fallback if everything was stripped
-    if (!slug)
-        slug = "file";
-    // Avoid bare reserved device names
-    if (WINDOWS_RESERVED.has(slug)) {
-        slug += "-file";
-    }
-    return slug;
-}
-export function slugifyFsUnique(input) {
-    // If we've seen this exact input before, return the same slug
-    const existing = inputToSlug.get(input);
-    if (existing)
-        return existing;
-    const base = makeBaseSlug(input);
-    let candidate = base;
-    let counter = 2;
-    while (true) {
-        const existingInput = slugToInput.get(candidate);
-        if (!existingInput) {
-            // Free slug → claim it for this input
-            slugToInput.set(candidate, input);
-            inputToSlug.set(input, candidate);
-            return candidate;
-        }
-        if (existingInput === input) {
-            // Same input somehow (super defensive)
-            inputToSlug.set(input, candidate);
-            return candidate;
-        }
-        // Collision: same slug already used by different input → add suffix
-        candidate = `${base}-${counter++}`;
-    }
-}
-// // Optional: to reset between runs/tests
-// export function resetSlugCache() {
-//   inputToSlug.clear();
-//   slugToInput.clear();
-// }

package/dist/esm/offline/tools.d.ts

@@ -1,3 +0,0 @@
-export declare function makeUniqueJsonTargetPathFromString(str: string, namespace?: string): string;
-export declare function relativeUrlToFilePath(relativeUrl: string): string;
-export declare function makeTargetPathFromUrl(url: string, prefix?: string): string;

package/dist/esm/offline/tools.js

@@ -1,85 +0,0 @@
-import debug from 'debug';
-import { hashString } from './hashString';
-import { slugifyFsUnique } from './slugify';
-const log = debug('efp:loader:offline');
-export function makeUniqueJsonTargetPathFromString(str, namespace = '') {
-    // const hash = hashString(str);
-    let result = slugifyFsUnique(str); // + '-' + hash;
-    if (namespace) {
-        result = `${slugifyFsUnique(namespace)}$${result}`;
-    }
-    if (result.endsWith('/')) {
-        result += 'index.json';
-    }
-    else if (!result.endsWith('.json')) {
-        result += '.json';
-    }
-    return './' + result;
-    // handle directory case
-}
-export function relativeUrlToFilePath(relativeUrl) {
-    const urlObj = new URL(relativeUrl, 'http://example.com');
-    const pathname = relativeUrl.startsWith('/') ? urlObj.pathname : urlObj.pathname.slice(1);
-    const search = urlObj.search;
-    return pathnameSearchToPahthname(pathname, search);
-}
-const MAX_PATHNAME_LENGTH = 120;
-function pathnameSearchToPahthname(pathname, search) {
-    // for directory
-    if (pathname.endsWith('/')) {
-        // just trust it for now
-        // TODO: need to combine with the logic below
-    }
-    else {
-        // if path doesn't end with extension, throw
-        if (!pathname.match(/\.[^\/]+$/)) {
-            throw new Error(`Cannot make target path from URL without file extension: ${pathname}`);
-        }
-        const extension = pathname.substring(pathname.lastIndexOf('.'));
-        let pathnameWithoutExtension = pathname.substring(0, pathname.lastIndexOf('.'));
-        // check the pathname contains only valid fs characters
-        const invalidPathnameChars = pathnameWithoutExtension.match(/[^a-zA-Z0-9\-._\/]/g);
-        if (invalidPathnameChars) {
-            const fixedPathnameWithoutExtension = slugifyFsUnique(pathnameWithoutExtension);
-            log(`Pathname contains invalid filesystem characters (${[...new Set(invalidPathnameChars)].join(', ')}), slugifying it: ${pathnameWithoutExtension}${extension} => ${fixedPathnameWithoutExtension}${extension}`);
-            pathnameWithoutExtension = fixedPathnameWithoutExtension;
-        }
-        pathname = pathnameWithoutExtension + extension;
-        if (pathname.length > MAX_PATHNAME_LENGTH) {
-            log(`Pathname is too long (${pathname.length} characters), truncating to ${MAX_PATHNAME_LENGTH} characters: ${pathname}`);
-            pathname = pathname.substring(0, MAX_PATHNAME_LENGTH - extension.length) + extension;
-        }
-        if (search) {
-            // create a hash from search params
-            const hash = hashString(search);
-            const dotIndex = pathname.lastIndexOf('.');
-            if (dotIndex !== -1) {
-                pathname = `${pathname.slice(0, dotIndex)}.${hash}${pathname.slice(dotIndex)}`;
-            }
-            else {
-                pathname = `${pathname}${hash}`;
-            }
-        }
-    }
-    return pathname;
-}
-export function makeTargetPathFromUrl(url, prefix = '') {
-    // https://example.com/dir1/dir2/a.js => "{prefix}{origin-slug}/dir1/dir2/a.js";
-    // https://example.com/dir1/dir2/a.js?params => "{prefix}{origin-slug}/dir1/dir2/a{paramsmd5hash}.js";
-    // use slugify.ts
-    try {
-        new URL(url);
-    }
-    catch {
-        debugger;
-    }
-    const urlObj = new URL(url);
-    const origin = `${urlObj.protocol}//${urlObj.host}`;
-    const originSlug = slugifyFsUnique(origin);
-    const pathname = pathnameSearchToPahthname(urlObj.pathname, urlObj.search);
-    // // handle directory case
-    // if (pathname.endsWith('/')) {
-    //   pathname += '__index.json';
-    // }
-    return `./${prefix}${originSlug}${pathname}`;
-}

package/dist/esm/resolvers/_OLD_expoResolver.d.ts

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

package/dist/esm/resolvers/_OLD_expoResolver.js

@@ -1,49 +0,0 @@
-// import { parseRefValue } from '../resolve';
-// import { log } from '../logger';
-// import type { Resolver } from '../types';
-// import { httpResolver } from './httpResolver';
-export {};
-// // const SCHEMA = 'expo';
-// export const expoResolver: Resolver = {
-//   // canResolve(ref: string) {
-//   //   return canResolveRefSchema(ref, SCHEMA);
-//   // },
-//   schema: 'expo',
-//   async resolveRef(ref: string) {
-//     log('expoResolver resolveRef:', ref);
-//     // if (!this.canResolve(ref)) throw new Error(`Unexpected ref in httpResolver: ${ref}`);
-//     const expo = parseRefValue(ref);
-//     // try to resolve {$ref: `https://${expo}.expofp.com/manifest.json`}
-//     try {
-//       return await httpResolver.resolveRef(`https://${expo}.expofp.com/manifest.json`);
-//     } catch (error) {
-//       log(`Falling back to legacyDataUrlBase (no manifest for '${expo}')`);
-//     }
-//     // ET: fallback, remove in the future, when all expos support manifest.json
-//     // and throw instead
-//     const data = {
-//       expo,
-//       runtime: { $ref: `expo-runtime-get-branch:${expo}` },
-//       legacyData: { $ref: `legacy-data:https://${expo}.expofp.com/data/` },
-//     };
-//     return data;
-//   },
-//   // async *makeOfflineRef(ref: string) {
-//   //   log('expoRuntimeBranchResolver makeOfflineRef:', ref);
-//   //   if (!this.canResolve(ref)) throw new Error(`Unexpected ref: ${ref}`);
-//   //   const value = parseRefValue(ref);
-//   //   const refData = deepClone(await this.resolveRef(ref));
-//   //   const targetFilePath = makeUniqueJsonTargetPathFromString(value, SCHEMA_PREFIX_BASE);
-//   //   const data = yield* makeOfflineInternal(refData);
-//   //   yield { data: data, targetFilePath };
-//   //   return { $ref: targetFilePath, [STOP_RESOLVING]: true };
-//   // },
-//   // async *makeOfflineRef2(ref: string) {
-//   //   const refData = deepClone(await this.resolveRef(ref));
-//   //   const targetFilePath = makeUniqueJsonTargetPathFromString(ref);
-//   //   const data = yield* makeOfflineInternal(refData);
-//   //   yield { data, targetFilePath };
-//   //   return targetFilePath;
-//   // },
-//   offlineMethod: 'resolveRef',
-// };

package/dist/esm/resolvers/assetResolver.d.ts

@@ -1,6 +0,0 @@
-export declare function resolveAssetRefSync(ref: string): string;
-export declare const assetResolver: {
-    schema: string;
-    resolveRef: (ref: string) => Promise<string>;
-    offlineFunc: "localizeRef";
-};

package/dist/esm/resolvers/assetResolver.js

@@ -1,26 +0,0 @@
-import { parseRefValue } from '../resolve';
-import { log } from '../logger';
-export function resolveAssetRefSync(ref) {
-    log('assetResolver resolveRef:', ref);
-    // if (!assetResolver.canResolve(ref)) throw new Error(`Unexpected ref: ${ref}`);
-    return parseRefValue(ref);
-}
-export const assetResolver = {
-    schema: 'asset',
-    resolveRef: async (ref) => resolveAssetRefSync(ref),
-    offlineFunc: 'localizeRef',
-};
-// async *makeOfflineRef(ref: string) {
-//   log('assetResolver makeOfflineRef:', ref);
-//   if (!this.canResolve(ref)) throw new Error(`Unexpected ref: ${ref}`);
-//   const url = parseRefValue(ref);
-//   const targetFilePath = makeTargetPathFromUrl(url);
-//   yield { url, targetFilePath };
-//   return { $ref: `asset:${targetFilePath}`, [STOP_RESOLVING]: true };
-// },
-// async *makeOfflineRef2(ref: string) {
-//   const url = parseRefValue(ref);
-//   const targetFilePath = makeTargetPathFromUrl(url);
-//   yield { url, targetFilePath };
-//   return `asset:${targetFilePath}`;
-// },

package/dist/esm/resolvers/bundleAssetsResolver.d.ts

@@ -1,2 +0,0 @@
-import type { Resolver } from '../types';
-export declare const bundleAssetsResolver: Resolver;

package/dist/esm/resolvers/bundleAssetsResolver.js

@@ -1,20 +0,0 @@
-import { importJson } from '../importJson';
-import { parseRefValue } from '../resolve';
-import { returnCachedRef } from '../returnCachedRef';
-import { log } from '../logger';
-export const bundleAssetsResolver = {
-    schema: 'bundle-assets',
-    async resolveRef(ref, context) {
-        log('bundleAssetsResolver resolveRef:', ref);
-        const url = parseRefValue(ref);
-        return returnCachedRef(ref, context.refCache, async () => {
-            const files = await importJson(url, context);
-            const baseUrl = url.substring(0, url.lastIndexOf('/') + 1);
-            const assets = files.map((file) => ({
-                $ref: `asset+${baseUrl}${file}`,
-            }));
-            return assets;
-        });
-    },
-    offlineFunc: 'localizeRef',
-};

package/dist/esm/resolvers/cssTextAssetResolver.d.ts

@@ -1,8 +0,0 @@
-import debug from 'debug';
-export declare const log: debug.Debugger;
-export declare const SCHEMA = "css-text-asset";
-export declare const cssTextAssetResolver: {
-    schema: string;
-    resolveRef(ref: string): Promise<string>;
-    offlineFunc: (ref: string, _context: import("../resolve").ResolveContextInternal) => AsyncGenerator<import("../types").LocalFile, string, void>;
-};

package/dist/esm/resolvers/cssTextAssetResolver.js

@@ -1,15 +0,0 @@
-import debug from 'debug';
-import { parseRefValue } from '../resolve';
-export const log = debug('efp:loader:resolver:cssTextAsset');
-export const SCHEMA = 'css-text-asset';
-export const cssTextAssetResolver = {
-    schema: SCHEMA,
-    resolveRef(ref) {
-        log('cssTextAssetResolver resolveRef:', ref);
-        return Promise.resolve(parseRefValue(ref));
-    },
-    offlineFunc: async function* (ref, _context) {
-        const { offlineFunc } = await import('./cssTextAssetResolver.offlineFunc');
-        return yield* offlineFunc(ref, _context);
-    },
-};

package/dist/esm/resolvers/cssTextAssetResolver.offlineFunc.d.ts

@@ -1,2 +0,0 @@
-import { OfflineFunc } from '../types';
-export declare const offlineFunc: OfflineFunc;

package/dist/esm/resolvers/cssTextAssetResolver.offlineFunc.js

@@ -1,22 +0,0 @@
-import { makeTargetPathFromUrl } from '../offline/tools';
-import { parseRefValue } from '../resolve';
-import { log, SCHEMA } from './cssTextAssetResolver';
-export const offlineFunc = async function* (ref, _context) {
-    const originalCss = parseRefValue(ref);
-    const { urls, css } = extractCssUrls(originalCss, makeTargetPathFromUrl);
-    for (const { originalUrl, replacedUrl } of urls) {
-        yield { url: originalUrl, targetFilePath: replacedUrl };
-    }
-    return `${SCHEMA}:${css}`;
-};
-function extractCssUrls(css, replace) {
-    const urlRegex = /url\(\s*(['"]?)(.*?)\1\s*\)/g;
-    const urls = [];
-    const replacedCss = css.replace(urlRegex, (_match, quote, url) => {
-        const replacedUrl = replace(url);
-        urls.push({ originalUrl: url, replacedUrl });
-        log('Extracted and replaced URL in CSS:', url, '->', replacedUrl);
-        return `url(${quote}${replacedUrl}${quote})`;
-    });
-    return { urls, css: replacedCss };
-}

package/dist/esm/resolvers/expoRuntimeBranchResolver.d.ts

@@ -1,2 +0,0 @@
-import type { Resolver } from '../types';
-export declare const expoRuntimeBranchResolver: Resolver;

package/dist/esm/resolvers/expoRuntimeBranchResolver.js

@@ -1,20 +0,0 @@
-import { importJson } from '../importJson';
-import { parseRefValue } from '../resolve';
-import { returnCachedRef } from '../returnCachedRef';
-import { log } from '../logger';
-const BASE_URL = 'https://efp-runtime.expofp.com/';
-export const expoRuntimeBranchResolver = {
-    schema: 'expo-runtime-branch',
-    async resolveRef(ref, context) {
-        log('expoRuntimeBranchResolver resolveRef:', ref);
-        const branch = parseRefValue(ref);
-        const branchUrl = `${BASE_URL}branches/${branch}.json`;
-        return returnCachedRef(ref, context.refCache, async () => {
-            const { release } = await importJson(branchUrl, context);
-            return {
-                $ref: `expo-runtime+https://efp-runtime.expofp.com/releases/${release}/`,
-            };
-        });
-    },
-    offlineFunc: 'resolveRef',
-};

package/dist/esm/resolvers/expoRuntimeGetBranchResolver.d.ts

@@ -1,2 +0,0 @@
-import type { Resolver } from '../types';
-export declare const expoRuntimeGetBranchResolver: Resolver;

package/dist/esm/resolvers/expoRuntimeGetBranchResolver.js

@@ -1,14 +0,0 @@
-import { importJson } from '../importJson';
-import { parseRefValue } from '../resolve';
-import { log } from '../logger';
-// const SCHEMA = 'expo-runtime-get-branch';
-export const expoRuntimeGetBranchResolver = {
-    schema: 'expo-runtime-get-branch',
-    async resolveRef(ref, context) {
-        log('expoRuntimeGetBranchResolver resolveRef:', ref);
-        const expo = parseRefValue(ref);
-        const url = `https://${expo}.expofp.com/get-branch`;
-        return importJson(url, context);
-    },
-    offlineFunc: 'resolveRef',
-};

package/dist/esm/resolvers/expoRuntimeResolver.d.ts

@@ -1,2 +0,0 @@
-import type { Resolver } from '../types';
-export declare const expoRuntimeResolver: Resolver;

package/dist/esm/resolvers/expoRuntimeResolver.js

@@ -1,39 +0,0 @@
-import { log } from '../logger';
-import { parseRefValue } from '../resolve';
-import { deepFreeze } from '../shared';
-// const SCHEMA = 'expo-runtime';
-export const expoRuntimeResolver = {
-    schema: 'expo-runtime',
-    // canResolve(ref: string) {
-    //   return canResolveRefSchema(ref, SCHEMA);
-    // },
-    async resolveRef(ref) {
-        log('expoRuntimeResolver resolveRef:', ref);
-        // if (!this.canResolve(ref)) throw new Error(`Unexpected ref: ${ref}`);
-        const url = parseRefValue(ref);
-        const data = {
-            entry: { $ref: `asset+${url}expofp.js` },
-            assets: { $ref: `bundle-assets+${url}bundle.json` },
-        };
-        deepFreeze(data);
-        return data;
-    },
-    //   async *makeOfflineRef(ref: string) {
-    //     log('expoRuntimeResolver makeOfflineRef:', ref);
-    //     if (!this.canResolve(ref)) throw new Error(`Unexpected ref: ${ref}`);
-    //     const url = parseRefValue(ref);
-    //     const refData = deepClone(await this.resolveRef(ref));
-    //     const targetFilePath = makeUniqueJsonTargetPathFromString(url, SCHEMA_PREFIX_BASE);
-    //     const data = yield* makeOfflineInternal(refData);
-    //     yield { data: data, targetFilePath };
-    //     return { $ref: targetFilePath, [STOP_RESOLVING]: true };
-    //   },
-    //   async *makeOfflineRef2(ref: string) {
-    //     const refData = deepClone(await this.resolveRef(ref));
-    //     const targetFilePath = makeUniqueJsonTargetPathFromString(ref);
-    //     const data = yield* makeOfflineInternal(refData);
-    //     yield { data, targetFilePath };
-    //     return targetFilePath;
-    //   },
-    offlineFunc: 'resolveRef',
-};

package/dist/esm/resolvers/httpResolver.d.ts

@@ -1,5 +0,0 @@
-export declare const httpResolver: {
-    canResolve(ref: string): boolean;
-    resolveRef(ref: string, context: import("../resolve").ResolveContextInternal): Promise<any>;
-    offlineFunc: "resolveRef";
-};

package/dist/esm/resolvers/httpResolver.js

@@ -1,14 +0,0 @@
-import { importJson } from '../importJson';
-import { log } from '../logger';
-export const httpResolver = {
-    canResolve(ref) {
-        return ref.startsWith('http://') || ref.startsWith('https://') || ref.startsWith('./');
-    },
-    resolveRef(ref, context) {
-        log('httpResolver resolveRef:', ref);
-        if (!this.canResolve(ref))
-            throw new Error(`Unexpected ref in httpResolver: ${ref}`);
-        return importJson(ref, context);
-    },
-    offlineFunc: 'resolveRef',
-};

package/dist/esm/resolvers/index.d.ts

@@ -1,2 +0,0 @@
-import type { Resolver } from '../types';
-export declare const resolvers: Resolver[];

package/dist/esm/resolvers/index.js

@@ -1,22 +0,0 @@
-import { assetResolver } from './assetResolver';
-import { bundleAssetsResolver } from './bundleAssetsResolver';
-import { cssTextAssetResolver } from './cssTextAssetResolver';
-import { expoRuntimeBranchResolver } from './expoRuntimeBranchResolver';
-import { expoRuntimeGetBranchResolver } from './expoRuntimeGetBranchResolver';
-import { expoRuntimeResolver } from './expoRuntimeResolver';
-import { httpResolver } from './httpResolver';
-import { legacyAssetUrlsResolver } from './legacyAssetUrlsResolver';
-import { legacyDataResolver } from './legacyDataResolver';
-import { legacyDataUrlBaseResolver } from './legacyDataUrlBaseResolver';
-export const resolvers = [
-    httpResolver,
-    bundleAssetsResolver,
-    assetResolver,
-    expoRuntimeResolver,
-    expoRuntimeBranchResolver,
-    expoRuntimeGetBranchResolver,
-    cssTextAssetResolver,
-    legacyDataResolver,
-    legacyAssetUrlsResolver,
-    legacyDataUrlBaseResolver,
-];

package/dist/esm/resolvers/legacyAssetUrlsResolver.d.ts

@@ -1,9 +0,0 @@
-import { type ResolveContextInternal } from '../resolve';
-/**
- * @deprecated Use legacyDataUrlBaseResolver instead
- */
-export declare const legacyAssetUrlsResolver: {
-    schema: string;
-    resolveRef(ref: string, context: ResolveContextInternal): Promise<any>;
-    offlineFunc: "resolveRef";
-};

package/dist/esm/resolvers/legacyAssetUrlsResolver.js

@@ -1,116 +0,0 @@
-import { loadAndWaitGlobal } from '../loadScript';
-import { parseRefValue } from '../resolve';
-import { returnCachedRef } from '../returnCachedRef';
-import { log } from '../logger';
-/**
- * @deprecated Use legacyDataUrlBaseResolver instead
- */
-export const legacyAssetUrlsResolver = {
-    schema: 'legacy-asset-urls',
-    resolveRef(ref, context) {
-        log('legacyAssetUrlsResolver resolveRef:', ref);
-        const signal = context.signal;
-        return returnCachedRef(ref, context.refCache, async () => {
-            const dataUrlBase = parseRefValue(ref);
-            // load version.js - it will contain "window.__fpDataVersion = "20251129003330106";"
-            const versionUrl = `${dataUrlBase}version.js`;
-            try {
-                await loadAndWaitGlobal(versionUrl, {
-                    globalVar: '__fpDataVersion',
-                    timeoutMs: 30_000,
-                    signal,
-                });
-                context.importCallback?.(versionUrl, 'script');
-            }
-            catch {
-                console.warn(`Could not load version.js at ${versionUrl}, proceeding without it`);
-            }
-            const version = globalThis.__fpDataVersion || (+new Date()).toString();
-            // const filesUrl = `${dataUrlBase}files.json?v=${version}`;
-            const dataUrl = `${dataUrlBase}data.js?v=${version}`;
-            // const filesPromise = importJson<string[]>(filesUrl, context).catch(() => {
-            //   console.warn(`Could not load files.json at ${filesUrl}, proceeding without it`);
-            //   return [];
-            // });
-            // data.js
-            const dataLoadPromise = loadAndWaitGlobal(dataUrl, {
-                globalVar: '__data',
-                signal,
-            });
-            context.importCallback?.(dataUrl, 'script');
-            // wf.data.js
-            const wfDataUrl = `${dataUrlBase}wf.data.js?v=${version}`;
-            const wfDataLoadPromise = loadAndWaitGlobal(wfDataUrl, {
-                globalVar: '__wfData',
-                signal,
-            })
-                .then(() => {
-                context.importCallback?.(wfDataUrl, 'script');
-            })
-                .catch(() => {
-                console.warn(`Could not load wf.data.js at ${wfDataUrl}, proceeding without it`);
-            });
-            // fp.svg.js
-            delete globalThis.__fpLayers;
-            const fpSvgUrl = `${dataUrlBase}fp.svg.js?v=${version}`;
-            const fpSvgLoadPromise = loadAndWaitGlobal(fpSvgUrl, {
-                globalVar: '__fp',
-                signal,
-            });
-            context.importCallback?.(fpSvgUrl, 'script');
-            await Promise.all([dataLoadPromise, wfDataLoadPromise, fpSvgLoadPromise]);
-            const __fpLayers = (globalThis.__fpLayers ?? []);
-            const fpLayerFiles = __fpLayers.map((x) => `fp.svg.${x.name}.js`);
-            for (const layerFile of fpLayerFiles) {
-                const layerUrl = `${dataUrlBase}${layerFile}?v=${version}`;
-                context.importCallback?.(layerUrl, 'script');
-            }
-            // const files = await filesPromise;...files,
-            const data = globalThis.__data || {};
-            const dataFiles = ['data.js', 'wf.data.js', 'fp.svg.js', ...fpLayerFiles];
-            const dataFilesAssets = dataFiles.reduce((map, file) => {
-                map[file] = { $ref: `asset+${dataUrlBase}${file}?v=${version}` };
-                return map;
-            }, {});
-            // return {};
-            return { ...dataFilesAssets, ...populateDataJsAssetsMap(dataUrlBase, data) };
-        });
-    },
-    offlineFunc: 'resolveRef',
-};
-function populateDataJsAssetsMap(dataUrlBase, data) {
-    const links = new Set();
-    function addLink(link) {
-        if (typeof link === 'string' && link.length > 0) {
-            // if (!link.startsWith('http://') && !link.startsWith('https://')) {
-            //   link = dataUrlBase + link;
-            // }
-            links.add(link);
-        }
-    }
-    addLink(data.logo);
-    data.exhibitors?.forEach((e) => {
-        addLink(e.logo);
-        // add same files but with __small and __tiny suffixes
-        if (e.logo) {
-            const dotIndex = e.logo.lastIndexOf('.');
-            if (dotIndex !== -1) {
-                const name = e.logo.substring(0, dotIndex);
-                const ext = e.logo.substring(dotIndex);
-                addLink(`${name}__small${ext}`);
-                addLink(`${name}__tiny${ext}`);
-            }
-        }
-        e.gallery?.forEach((img) => addLink(img));
-    });
-    data.events?.forEach((e) => {
-        addLink(e.logoFile);
-        e.speakers?.forEach((s) => {
-            addLink(s.photoFile);
-        });
-    });
-    return Array.from(links).reduce((map, link) => {
-        map[link] = { $ref: `asset+${dataUrlBase}${link}` };
-        return map;
-    }, {});
-}

package/dist/esm/resolvers/legacyDataResolver.d.ts

@@ -1,8 +0,0 @@
-/**
- * @deprecated Use legacyDataUrlBaseResolver instead
- */
-export declare const legacyDataResolver: {
-    schema: string;
-    resolveRef(ref: string, context: import("../resolve").ResolveContextInternal): Promise<any>;
-    offlineFunc: "resolveRef";
-};

package/dist/esm/resolvers/legacyDataResolver.js

@@ -1,20 +0,0 @@
-import { parseRefValue } from '../resolve';
-import { returnCachedRef } from '../returnCachedRef';
-import { log } from '../logger';
-/**
- * @deprecated Use legacyDataUrlBaseResolver instead
- */
-export const legacyDataResolver = {
-    schema: 'legacy-data',
-    resolveRef(ref, context) {
-        log('legacyDataResolver resolveRef:', ref);
-        return returnCachedRef(ref, context.refCache, async () => {
-            const dataUrlBase = parseRefValue(ref);
-            return {
-                _to_remove_for_offline_to_work_dataUrlBase: dataUrlBase,
-                legacyAssetUrls: { $ref: `legacy-asset-urls+${dataUrlBase}` },
-            };
-        });
-    },
-    offlineFunc: 'resolveRef',
-};

package/dist/esm/resolvers/legacyDataUrlBaseResolver.d.ts

@@ -1,8 +0,0 @@
-import debug from 'debug';
-export declare const log: debug.Debugger;
-export declare const SCHEMA = "legacy-data-url-base";
-export declare const legacyDataUrlBaseResolver: {
-    schema: string;
-    resolveRef(ref: string): Promise<string>;
-    offlineFunc: (ref: string, _context: import("../resolve").ResolveContextInternal) => AsyncGenerator<import("../types").LocalFile, string, void>;
-};

package/dist/esm/resolvers/legacyDataUrlBaseResolver.js

@@ -1,15 +0,0 @@
-import debug from 'debug';
-import { parseRefValue } from '../resolve';
-export const log = debug('efp:loader:resolver:legacyDataUrlBase');
-export const SCHEMA = 'legacy-data-url-base';
-export const legacyDataUrlBaseResolver = {
-    schema: SCHEMA,
-    resolveRef(ref) {
-        log('legacyDataResolver resolveRef:', ref);
-        return Promise.resolve(parseRefValue(ref));
-    },
-    offlineFunc: async function* (ref, _context) {
-        const { offlineFunc } = await import('./legacyDataUrlBaseResolver.offlineFunc');
-        return yield* offlineFunc(ref, _context);
-    },
-};

package/dist/esm/resolvers/legacyDataUrlBaseResolver.offlineFunc.d.ts

@@ -1,2 +0,0 @@
-import { OfflineFunc } from '../types';
-export declare const offlineFunc: OfflineFunc;