@expofp/loader 1.0.79 → 1.0.92

package/dist/esm/index.js

@@ -1,24 +1,45 @@
-import { log } from './logger';
-import { createFunction } from './shared';
-const info = globalThis.__efpLoaderBuildInfo;
-if (info) {
-    log('Initialized', { version: info[0], builtAt: info[1] });
+import debug from 'debug';
+import { importHttpRuntime } from './importHttpRuntime';
+import { resolve } from './resolve';
+const log = debug('efp:loader');
+if (typeof __efpLoaderBuildInfo !== 'undefined') {
+    log('Initialized', { version: __efpLoaderBuildInfo[0], builtAt: __efpLoaderBuildInfo[1] });
 }
 else {
     log('Initialized');
 }
-export const mount = createFunction('mount');
-export const load = createFunction('load');
-export const initialize = createFunction('initialize');
-// extra
-// export const createFloorPlan = createFunction('createFloorPlan');
-// export const rewriteManifestToLocalFiles = createFunction('rewriteManifestToLocalFiles');
-export async function callFunction_Experimental(name, manifest, ...args) {
-    const fn = createFunction(name);
-    return await fn(manifest, ...args);
+export async function loadApi(manifest, options) {
+    log('Loading manifest:', manifest);
+    if (typeof manifest === 'string') {
+        manifest = { $ref: manifest };
+    }
+    manifest = await resolve(manifest, { fetchCallback: options?.fetchCallback });
+    const runtime = await resolve(manifest.runtime, {
+        fetchCallback: options?.fetchCallback,
+    });
+    log('Resolved runtime URL:', runtime);
+    if (typeof runtime !== 'string') {
+        throw new Error('Resolved runtime is not a string ');
+    }
+    const api = await importHttpRuntime(runtime);
+    api.meta = { runtime };
+    return api; //{ ...api, runtime } as LoaderApi;
 }
-export { mutateManifest } from './mutateManifest';
-export { downloadOfflineZip, makeOfflineBundle, saveOfflineZip, makeOffline } from './offline';
-export { resolve } from './resolve';
-// preloadJson('https://efp-runtime.expofp.com/branches/main.json');
-// preconnectUrl('https://efp-runtime.expofp.com/');
+// allow calling api functions directly from here
+const api = new Proxy({}, {
+    get: (_, prop) => {
+        return async (...args) => {
+            const manifest = args[0];
+            const runtimeApi = await loadApi(manifest);
+            const fn = runtimeApi[prop];
+            if (typeof fn !== 'function') {
+                throw new Error(`API has no function named '${prop}'`);
+            }
+            return fn.apply(runtimeApi, args);
+        };
+    },
+});
+export async function load(manifest, ...args) {
+    return api.load(manifest, ...args);
+}
+export default api;

package/dist/esm/resolve.d.ts

@@ -1,45 +1,11 @@
-import type { Resolver } from './types';
-export interface ResolveContextInternal {
-    forceFetch: boolean;
-    refCache: Map<string, Promise<any>>;
-    /**
-     * Callback invoked when a URL is fetched or imported.
-     */
-    importCallback?: (url: string, type: 'json' | 'script') => void;
-    signal: AbortSignal | null;
-    preResolvedRefs?: Map<string, any>;
-}
-interface ResolveOptionsNotMutate extends Partial<ResolveContextInternal> {
-    mutate?: false;
+export type ResolveOptions = {
+    maxHops?: number;
     signal?: AbortSignal;
-}
-interface ResolveOptionMutate extends Omit<ResolveOptionsNotMutate, 'mutate'> {
-    /**
-     * Mutate original object during resolution.
-     */
-    mutate: true;
-}
-export type ResolveOptions = ResolveOptionsNotMutate | ResolveOptionMutate;
-/**
- * Resolves a value from an object using a JSON Pointer RFC 6901.
- *
- * @param object - The object to resolve the value from
- * @param jsonPointer - A JSON Pointer string that must start with '/'
- * @param options - Optional context for resolution, including cache and fetch callback
- * @returns A promise that resolves to the value at the specified JSON Pointer path
- * @throws {Error} If the JSON Pointer is not valid or if a $ref cannot be resolved
- *
- * @example
- * ```typescript
- * const obj = { foo: { bar: 'baz' } };
- * const result = await resolve(obj, '/foo/bar');
- * // result === 'baz'
- * ```
- */
-export declare function resolve(object: any, jsonPointer: string, options: ResolveOptionMutate): Promise<void>;
-export declare function resolve<T = any>(object: any, jsonPointer: string, options?: ResolveOptionsNotMutate): Promise<T>;
-export declare function resolverResolve(resolver: Resolver, ref: string, context: ResolveContextInternal): Promise<any>;
-export declare function canResolve(resolver: Resolver, ref: string): boolean;
-export declare function canResolveRefSchema(ref: string, prefixBase: string): boolean;
-export declare function parseRefValue(ref: string): string;
-export {};
+    onHop?: (info: {
+        hop: number;
+        ref: string;
+        via: 'import' | 'fetch';
+    }) => void;
+    fetchCallback?: (ref: string) => void;
+};
+export declare function resolve<T>(input: unknown, options?: ResolveOptions): Promise<T>;

package/dist/esm/resolve.js

@@ -1,304 +1,100 @@
-import { log } from './logger';
-import { resolvers } from './resolvers';
-import { createMergedObjectWithOverridenNonRefProps, deepFreeze, replaceObjectFields, } from './shared';
-const globalRefCache = new Map();
-export async function resolve(object, jsonPointer, options) {
-    log('Resolving:', jsonPointer, 'of', object, options);
-    // if (typeof window !== 'undefined') {
-    //   (window as any)['__lastResolveObject'] = object;
-    // }
-    const resolveContext = {
-        importCallback: options?.importCallback,
-        refCache: options?.refCache || globalRefCache,
-        forceFetch: !!options?.forceFetch,
-        signal: options?.signal || null,
-        preResolvedRefs: options?.preResolvedRefs,
-    };
-    if (typeof jsonPointer !== 'string') {
-        throw new Error(`Invalid JSON Pointer (not a string): ${jsonPointer}`);
-    }
-    if (!jsonPointer.startsWith('/')) {
-        throw new Error(`Invalid JSON Pointer: ${jsonPointer}`);
-    }
-    if (jsonPointer.length > 1 && jsonPointer.endsWith('/')) {
-        throw new Error(`Invalid JSON Pointer: ${jsonPointer}`);
-    }
-    // if (jsonPointer === '/') {
-    //   const result = await resolveObject(object, resolveContext);
-    //   if (options?.mutate) {
-    //     replaceObjectFields(object, result);
-    //   }
-    //   return result;
-    // }
-    let parts;
-    if (jsonPointer === '/') {
-        parts = [];
-    }
-    else {
-        parts = jsonPointer.substring(1).split('/');
-    }
-    if (parts.some((part) => part.length === 0))
-        throw new Error(`Invalid JSON Pointer (empty part): ${jsonPointer}`);
-    if (options?.mutate) {
-        // prepend parts with 'root'
-        parts.unshift('root');
-        const target = { root: object };
-        await resovlePartsRecursiveMutate(target, parts, 0, resolveContext);
-        replaceObjectFields(object, target.root);
-    }
-    else {
-        return await resovlePartsRecursive(object, parts, 0, resolveContext);
-    }
-    // prepend parts with 'root'
-    // parts.unshift('root');
-    // // if (parts.some((part) => part.length === 0))
-    // //   throw new Error(`Invalid JSON Pointer (empty part): ${jsonPointer}`);
-    // const target = { root: object };
-    // const value = await resovlePartsRecursiveMutate(
-    //   target,
-    //   // 'root',
-    //   parts,
-    //   0,
-    //   resolveContext
-    // );
-    // if (options?.mutate) {
-    //   replaceObjectFields(object, target.root);
-    // }
-    // log(`Resolved ${jsonPointer}:`, value);
-    // return value;
-}
-// TODO: use library for JSON Pointer resolution
-async function resovlePartsRecursiveMutate(node, 
-// key: string,
-parts, partsIndex, context) {
-    const key = parts[partsIndex];
-    // console.warn('in', key);
-    await resolveObjectMutate(node, key, context);
-    if (partsIndex == parts.length - 1)
-        return;
-    if (node[key] === null || typeof node[key] !== 'object') {
-        // console.error('Cannot resolve path, encountered non-object:', node, key);
-        throw new Error(`Cannot resolve path, encountered non-object at part '${parts.slice(1).join('/')}', index ${partsIndex - 1}'`);
-    }
-    return await resovlePartsRecursiveMutate(node[key], parts, partsIndex + 1, context);
-}
-async function resolveObjectMutate(node, key, context) {
-    log('resolveObjectMutate:', node, key);
-    let obj = node[key];
-    const result = await resolveObject(obj, context);
-    if (result !== undefined)
-        node[key] = result;
-}
-// TODO: use library for JSON Pointer resolution
-async function resovlePartsRecursive(object, parts, index, context) {
-    // should return undefined if last part not found
-    // if not last part found - throw error
-    // do not resolve object if its children are not needed (needed part exist as key)
-    if (index === parts.length) {
-        // console.warn('Resolving last part:', object);
-        return await resolveObject(object, context);
-    }
-    if (object === null || typeof object !== 'object') {
-        throw new Error(`Cannot resolve path, encountered non-object at part '${parts.join('/')}', index ${index}'`);
-    }
-    const part = parts[index];
-    let child = object[part];
-    if (child === undefined) {
-        // console.warn('Resolving, part not found during resolve:', part, object);
-        const resolvedObject = await resolveObject(object, context);
-        child = resolvedObject[part];
-    }
-    return await resovlePartsRecursive(child, parts, index + 1, context);
-}
-async function resolveObject(object, context) {
-    log('resolveObject:', object);
-    let obj = object;
-    do {
-        if (typeof obj !== 'object' || obj === null || !('$ref' in obj)) {
-            return obj;
-        }
-        const resolversToUse = resolvers.filter((r) => canResolve(r, obj.$ref));
-        if (resolversToUse.length === 0) {
-            if (obj.$ref) {
-                throw new Error(`No resolver found for ref: ${obj.$ref}`);
+// resolveHttpRefToString.ts
+// Follows $ref chains until finding a value without $ref.
+//
+// Rules:
+// - If value is an object with {$ref: string} -> follow it (fetch if http/https URL)
+// - Otherwise -> return the value as-is
+//
+// Browser: tries `import(url, { with: { type: 'json' } })` first, falls back to fetch.
+// Node: uses fetch (Node 18+ has global fetch).
+import debug from 'debug';
+import { fetch } from './fetch';
+const log = debug('efp:loader:resolve');
+export async function resolve(input, options = {}) {
+    const maxHops = options.maxHops ?? 32;
+    const seen = new Set();
+    let cur = input;
+    for (let hop = 0; hop < maxHops; hop++) {
+        // If it's an object with $ref, follow it
+        if (cur && typeof cur === 'object' && '$ref' in cur) {
+            const obj = cur;
+            const ref = obj.$ref;
+            if (typeof ref !== 'string') {
+                throw new Error(`$ref must be a string, got: ${typeof ref}`);
             }
-            deepFreeze(obj);
-            return obj;
-        }
-        if (resolversToUse.length > 1) {
-            throw new Error(`Multiple resolvers can resolve ref: ${obj.$ref}`);
+            // If it's an http/https URL, fetch it
+            if (isHttpUrl(ref)) {
+                if (seen.has(ref)) {
+                    throw new Error(`Circular $ref detected at: ${ref}`);
+                }
+                seen.add(ref);
+                log('Loading JSON ref:', ref);
+                options.fetchCallback?.(ref);
+                const json = await loadJson(ref, options.signal);
+                options.onHop?.({ hop, ref, via: json.__via });
+                cur = json.value;
+                continue;
+            }
+            // Non-http $ref (e.g., relative, custom schema) - return the object as-is
+            // (caller is responsible for handling these)
+            return cur;
         }
-        const data = await resolverResolve(resolversToUse[0], obj.$ref, context);
-        obj = createMergedObjectWithOverridenNonRefProps(data, obj);
-    } while (true);
-}
-export async function resolverResolve(resolver, ref, context) {
-    if (!canResolve(resolver, ref)) {
-        throw new Error(`Unexpected ref: ${ref}`);
+        // No $ref found - return current value
+        return cur;
     }
-    return resolver.resolveRef(ref, context);
+    throw new Error(`Too many ref hops (>${maxHops}). Possible loop or unexpectedly deep chain.`);
 }
-export function canResolve(resolver, ref) {
-    if (resolver.canResolve) {
-        return resolver.canResolve(ref);
-    }
-    if (resolver.schema) {
-        return canResolveRefSchema(ref, resolver.schema);
-    }
-    throw new Error('Resolver is missing canResolve method and schema property');
+function isHttpUrl(s) {
+    return s.startsWith('http://') || s.startsWith('https://');
 }
-export function canResolveRefSchema(ref, prefixBase) {
-    const prefixes = [`${prefixBase}+`, `${prefixBase}:`];
-    for (const prefix of prefixes) {
-        if (ref.startsWith(prefix)) {
-            return true;
-        }
+async function loadJson(url, signal) {
+    // Try import() JSON first (browser-friendly; depends on runtime/bundler support + CORS)
+    const imported = await tryImportJson(url);
+    if (imported.ok)
+        return { value: imported.value, __via: 'import' };
+    // Fallback to fetch
+    const res = await fetch(url, {
+        method: 'GET',
+        signal,
+        headers: {
+            // Helps some CDNs/content negotiation setups
+            Accept: 'application/json, text/plain;q=0.9, */*;q=0.1',
+        },
+    });
+    if (!res.ok) {
+        throw new Error(`Failed to fetch JSON ref: ${url} (${res.status} ${res.statusText})`);
+    }
+    // Prefer JSON; if server mislabels, fallback to text->JSON parse.
+    const ct = res.headers.get('content-type') || '';
+    if (ct.includes('application/json') || ct.includes('+json')) {
+        return { value: await res.json(), __via: 'fetch' };
+    }
+    const text = await res.text();
+    try {
+        return { value: JSON.parse(text), __via: 'fetch' };
+    }
+    catch {
+        // If the endpoint literally returns a plain string (not JSON), accept it.
+        return { value: text, __via: 'fetch' };
     }
-    return false;
 }
-export function parseRefValue(ref) {
-    // look for anything before ":" or before +https:// or before +http://
-    // https://www -> https://www
-    // so some+base+https://www -> https://www
-    // base+https://www -> https://www
-    // base:abc -> abc
-    // "some-base" can contain only non-:
-    if (ref.startsWith('http://') || ref.startsWith('https://')) {
-        return ref;
-    }
-    // if it is something+http:// or something+https://
-    const plusHttpIndex = ref.indexOf('+http://');
-    const plusHttpsIndex = ref.indexOf('+https://');
-    if (plusHttpIndex !== -1) {
-        return ref.substring(plusHttpIndex + 1);
-    }
-    if (plusHttpsIndex !== -1) {
-        return ref.substring(plusHttpsIndex + 1);
-    }
-    // if it is something:abc
-    const colonIndex = ref.indexOf(':');
-    if (colonIndex !== -1) {
-        return ref.substring(colonIndex + 1);
+async function tryImportJson(url) {
+    // `with: { type: 'json' }` is the modern import assertion form.
+    // Some environments still only accept `assert: { type: 'json' }`.
+    try {
+        ////   @ts-expect-error - TS lib definitions differ across versions
+        const mod = await import(/* @vite-ignore */ url, { with: { type: 'json' } });
+        log('Imported JSON via import():', url);
+        return { ok: true, value: mod?.default ?? mod };
+    }
+    catch (e1) {
+        try {
+            ////   @ts-expect-error - fallback for older assertion syntax
+            const mod = await import(/* @vite-ignore */ url, { assert: { type: 'json' } });
+            return { ok: true, value: mod?.default ?? mod };
+        }
+        catch (e2) {
+            return { ok: false, error: e2 ?? e1 };
+        }
     }
-    throw new Error(`Error getting URL from: ${ref}, no valid prefix found`);
-}
-// export function parseRefValue(ref: string): string {
-//   // look for anything before ":" or before +https:// or before +http://
-//   // https://www -> https://www
-//   // so some+base+https://www -> https://www
-//   // base+https://www -> https://www
-//   // base:abc -> abc
-//   // "some-base" can contain only non-:
-//   if (ref.startsWith('http://') || ref.startsWith('https://')) {
-//     return ref;
-//   }
-//   // if it is something+http:// or something+https://
-//   const plusHttpIndex = ref.indexOf('+http://');
-//   const plusHttpsIndex = ref.indexOf('+https://');
-//   if (plusHttpIndex !== -1) {
-//     return ref.substring(plusHttpIndex + 1);
-//   }
-//   if (plusHttpsIndex !== -1) {
-//     return ref.substring(plusHttpsIndex + 1);
-//   }
-//   // if it is something:abc
-//   const colonIndex = ref.indexOf(':');
-//   if (colonIndex !== -1) {
-//     return ref.substring(colonIndex + 1);
-//   }
-//   throw new Error(`Error getting URL from: ${ref}, no valid prefix found`);
-//   // const prefixBase = ref.split('+')[0].split(':')[0];
-//   // if (!prefixBase) {
-//   //   throw new Error(`Invalid ref, missing prefix: ${ref}`);
-//   // }
-//   // return ref.substring(prefixBase.length + 1);
-//   // const prefixes = [`${prefixBase}+`, `${prefixBase}:`];
-//   // for (const prefix of prefixes) {
-//   //   if (ref.startsWith(prefix)) {
-//   //     const url = ref.substring(prefix.length);
-//   //     if (!url) {
-//   //       throw new Error(`Invalid ref, missing URL after prefix "${prefix}": ${ref}`);
-//   //     }
-//   //     return url;
-//   //   }
-//   // }
-//   // throw new Error(
-//   //   `Error getting URL from: ${ref}, none of the prefixes matched: ${prefixes.join(', ')}`
-//   // );
-// }
-// export function parseRefValue(ref: string, prefixBase: string): string {
-//   const prefixes = [`${prefixBase}+`, `${prefixBase}:`];
-//   for (const prefix of prefixes) {
-//     if (ref.startsWith(prefix)) {
-//       const url = ref.substring(prefix.length);
-//       if (!url) {
-//         throw new Error(`Invalid ref, missing URL after prefix "${prefix}": ${ref}`);
-//       }
-//       return url;
-//     }
-//   }
-//   throw new Error(
-//     `Error getting URL from: ${ref}, none of the prefixes matched: ${prefixes.join(', ')}`
-//   );
-// }
-// const importJsonNative = new Function('url', 'return import(url, { with: { type: "json" } });') as (
-//   url: string
-// ) => Promise<any>;
-if (typeof window !== 'undefined') {
-    window['__debugResolve'] = async function debugResolve(object, jsonPointer, options) {
-        return await resolve(object, jsonPointer, options);
-    };
-    // (window as any)['__dd'] = async function dd() {
-    //   const url = 'https://demo.expofp.com/manifest.json';
-    //   // const imp = import;
-    //   const zz = (await importJsonNative(url)).default;
-    //   console.warn('debugResolve demo manifest:', zz);
-    //   //   let object: any;
-    //   //   let ref: string;
-    //   //   let resolveContext: ResolveOptions | undefined;
-    //   //   if (typeof objectOrRef === 'string') {
-    //   //     object = (window as any)['__lastResolveObject'];
-    //   //     ref = objectOrRef;
-    //   //     resolveContext = refOrContext;
-    //   //   } else {
-    //   //     object = objectOrRef;
-    //   //     ref = refOrContext;
-    //   //     resolveContext = context;
-    //   //   }
-    //   //   return await resolve(object, ref, resolveContext);
-    // };
 }
-// if (index === parts.length - 1) {
-//   return await resolveObject(object, context);
-// }
-// if (object === null || typeof object !== 'object') {
-//   throw new Error(
-//     `Cannot resolve path, encountered non-object at part '${parts.join('/')}', index ${index}'`
-//   );
-// }
-// if (!(parts[0] in object)) {
-//   return undefined;
-// }
-// let partIndex = 0;
-// let currentObject = await resolveObject(object, context);
-// while (partIndex < parts.length) {
-//   const part = parts[partIndex];
-//   if (typeof currentObject !== 'object' || currentObject === null) {
-//     throw new Error(
-//       `Cannot resolve path, encountered non-object at part '${parts.join(
-//         '/'
-//       )}, index ${partIndex}'`
-//     );
-//   }
-//   // console.info(
-//   //   'resolvePath currentObject:',
-//   //   part,
-//   //   JSON.stringify(currentObject, null, 2),
-//   //   currentObject[part]
-//   // );
-//   // debugger;
-//   const child = currentObject[part];
-//   currentObject = await resolveObject(child, context);
-//   partIndex++;
-// }
-// return currentObject;

package/dist/esm/types.d.ts

@@ -1,26 +1,11 @@
-import type { ResolveContextInternal } from './resolve';
-export interface Resolver {
-    schema?: string;
-    canResolve?(ref: string): boolean;
-    resolveRef(ref: string, context: ResolveContextInternal): Promise<any>;
-    offlineFunc: 'localizeRef' | 'resolveRef' | OfflineFunc;
-}
-export interface LocalFetchFile {
-    url: string;
-    targetFilePath: string;
-}
-export interface LocalTextFile {
-    text: string;
-    targetFilePath: string;
-}
-export interface LocalJsonFile {
-    data: unknown;
-    targetFilePath: string;
-}
-export type ManifestData = any;
-export type LocalFile = LocalFetchFile | LocalJsonFile | LocalTextFile;
-export interface MakeOfflineResult {
-    manifest: any;
-    files: AsyncGenerator<LocalFile, ManifestData, void>;
-}
-export type OfflineFunc = (ref: string, context: ResolveContextInternal) => AsyncGenerator<LocalFile, string, void>;
+export type Ref = {
+    $ref: string;
+};
+export type Runtime = string;
+export type Manifest = {
+    runtime: Runtime | Ref | string;
+};
+export type LoaderFn = (manifest: Manifest | Ref | string, ...args: unknown[]) => Promise<unknown>;
+export type LoaderApi = {
+    [key: string]: LoaderFn | undefined;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expofp/loader",
-  "version": "1.0.79",
+  "version": "1.0.92",
   "description": "ExpoFP JavaScript loader library",
   "license": "MIT",
   "homepage": "https://expofp.com",
@@ -28,12 +28,14 @@
     "clean": "rm -rf dist",
     "build": "pnpm clean && tsc && vite build",
     "preview": "vite preview",
+    "test": "DEBUG=efp:* tsx watch ./scripts/test.ts",
     "css": "tsx watch ./scripts/css.ts",
     "offline:build": "tsx ./scripts/buildOffline.ts",
     "offline:serve": "http-server ./tmp/offline",
     "prepare": "husky"
   },
   "dependencies": {
+    "@apidevtools/json-schema-ref-parser": "^15.1.3",
     "debug": "^4.4.3",
     "fetch-retry": "^6.0.0",
     "jszip": "^3.10.1"

package/dist/bundle/cssTextAssetResolver.offlineFunc-CWvHnYni.js

@@ -1,19 +0,0 @@
-import { a as i } from "./tools-D0u8lBvQ.js";
-import { p, S as u, l as f } from "./bundle.js";
-const U = async function* (e, c) {
-  const t = p(e), { urls: r, css: a } = g(t, i);
-  for (const { originalUrl: o, replacedUrl: s } of r)
-    yield { url: o, targetFilePath: s };
-  return `${u}:${a}`;
-};
-function g(e, c) {
-  const t = /url\(\s*(['"]?)(.*?)\1\s*\)/g, r = [], a = e.replace(t, (o, s, l) => {
-    const n = c(l);
-    return r.push({ originalUrl: l, replacedUrl: n }), f("Extracted and replaced URL in CSS:", l, "->", n), `url(${s}${n}${s})`;
-  });
-  return { urls: r, css: a };
-}
-export {
-  U as offlineFunc
-};
-//# sourceMappingURL=cssTextAssetResolver.offlineFunc-CWvHnYni.js.map

package/dist/bundle/cssTextAssetResolver.offlineFunc-CWvHnYni.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"cssTextAssetResolver.offlineFunc-CWvHnYni.js","sources":["../../src/resolvers/cssTextAssetResolver.offlineFunc.ts"],"sourcesContent":["import { makeTargetPathFromUrl } from '../offline/tools';\nimport { parseRefValue } from '../resolve';\nimport { OfflineFunc } from '../types';\nimport { log, SCHEMA } from './cssTextAssetResolver';\n\nexport const offlineFunc: OfflineFunc = async function* (ref: string, _context: any) {\n  const originalCss = parseRefValue(ref);\n  const { urls, css } = extractCssUrls(originalCss, makeTargetPathFromUrl);\n\n  for (const { originalUrl, replacedUrl } of urls) {\n    yield { url: originalUrl, targetFilePath: replacedUrl };\n  }\n\n  return `${SCHEMA}:${css}`;\n};\n\ninterface UrlReplacement {\n  originalUrl: string;\n  replacedUrl: string;\n}\n\nfunction extractCssUrls(\n  css: string,\n  replace: (url: string) => string\n): { urls: UrlReplacement[]; css: string } {\n  const urlRegex = /url\\(\\s*(['\"]?)(.*?)\\1\\s*\\)/g;\n  const urls: UrlReplacement[] = [];\n\n  const replacedCss = css.replace(urlRegex, (_match, quote, url) => {\n    const replacedUrl = replace(url);\n    urls.push({ originalUrl: url, replacedUrl });\n    log('Extracted and replaced URL in CSS:', url, '->', replacedUrl);\n    return `url(${quote}${replacedUrl}${quote})`;\n  });\n\n  return { urls, css: replacedCss };\n}\n"],"names":["offlineFunc","ref","_context","originalCss","parseRefValue","urls","css","extractCssUrls","makeTargetPathFromUrl","originalUrl","replacedUrl","SCHEMA","replace","urlRegex","replacedCss","_match","quote","url","log"],"mappings":";;AAKO,MAAMA,IAA2B,iBAAiBC,GAAaC,GAAe;AACnF,QAAMC,IAAcC,EAAcH,CAAG,GAC/B,EAAE,MAAAI,GAAM,KAAAC,EAAA,IAAQC,EAAeJ,GAAaK,CAAqB;AAEvE,aAAW,EAAE,aAAAC,GAAa,aAAAC,EAAA,KAAiBL;AACzC,UAAM,EAAE,KAAKI,GAAa,gBAAgBC,EAAA;AAG5C,SAAO,GAAGC,CAAM,IAAIL,CAAG;AACzB;AAOA,SAASC,EACPD,GACAM,GACyC;AACzC,QAAMC,IAAW,gCACXR,IAAyB,CAAA,GAEzBS,IAAcR,EAAI,QAAQO,GAAU,CAACE,GAAQC,GAAOC,MAAQ;AAChE,UAAMP,IAAcE,EAAQK,CAAG;AAC/B,WAAAZ,EAAK,KAAK,EAAE,aAAaY,GAAK,aAAAP,GAAa,GAC3CQ,EAAI,sCAAsCD,GAAK,MAAMP,CAAW,GACzD,OAAOM,CAAK,GAAGN,CAAW,GAAGM,CAAK;AAAA,EAC3C,CAAC;AAED,SAAO,EAAE,MAAAX,GAAM,KAAKS,EAAA;AACtB;"}