@remix-run/assets 0.0.0 → 0.1.0

package/dist/lib/scripts/compiler.js

@@ -0,0 +1,435 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { IfNoneMatch } from '@remix-run/headers';
+import { createAssetServerCompilationError } from "../compilation-error.js";
+import { createFileMatcher } from "../file-matcher.js";
+import { formatFingerprintedPathname, getFingerprintRequestCacheControl, parseFingerprintSuffix, } from "../fingerprint.js";
+import { emitResolvedModule } from "./emit.js";
+import { normalizeFilePath, resolveFilePath } from "../paths.js";
+import { resolveModule, resolverExtensionAlias, resolverExtensions, supportedScriptExtensions, } from "./resolve.js";
+import { createModuleStore } from "./store.js";
+import { createTsconfigTransformOptionsResolver, transformModule } from "./transform.js";
+import { ResolverFactory } from 'oxc-resolver';
+const supportedScriptExtensionSet = new Set(supportedScriptExtensions);
+const preloadConcurrency = Math.max(1, Math.min(8, os.availableParallelism() - 1));
+export function createModuleCompiler(options) {
+    let resolvedOptions = {
+        ...options,
+        externalSet: new Set(options.external),
+        watchIgnoreMatchers: (options.watchIgnore ?? []).map((pattern) => createFileMatcher(pattern, options.rootDir)),
+    };
+    let store = createModuleStore({
+        onWatchDirectoriesChange: options.onWatchDirectoriesChange,
+    });
+    let tsconfigTransformOptionsResolver = createTsconfigTransformOptionsResolver();
+    let resolverFactory = new ResolverFactory({
+        aliasFields: [['browser']],
+        conditionNames: ['browser', 'import', 'module', 'default'],
+        extensionAlias: resolverExtensionAlias,
+        extensions: resolverExtensions,
+        mainFields: ['browser', 'module', 'main'],
+        tsconfig: 'auto',
+    });
+    let resolveInFlightByCacheKey = new Map();
+    let emitInFlightByCacheKey = new Map();
+    let transformArgs = {
+        buildId: resolvedOptions.buildId ?? null,
+        define: resolvedOptions.define ?? null,
+        externalSet: resolvedOptions.externalSet,
+        isWatchIgnored,
+        minify: resolvedOptions.minify,
+        resolveActualPath,
+        routes: resolvedOptions.routes,
+        sourceMapSourcePaths: resolvedOptions.sourceMapSourcePaths,
+        sourceMaps: resolvedOptions.sourceMaps ?? null,
+        target: resolvedOptions.target ?? null,
+        tsconfigTransformOptionsResolver,
+    };
+    let resolveArgs = {
+        isAllowed: resolvedOptions.isAllowed,
+        isWatchIgnored,
+        resolveModulePath,
+        resolverFactory,
+        routes: resolvedOptions.routes,
+    };
+    return {
+        async getModule(filePath, getOptions) {
+            let resolvedModule = resolveServedModuleOrThrow(resolveInputFilePath(filePath));
+            let record = store.get(resolvedModule.identityPath);
+            let notModified = getNotModifiedModule(record, getOptions);
+            if (notModified)
+                return notModified;
+            let emitted = await getOrCreateEmittedModule(record);
+            return {
+                type: 'module',
+                module: toModuleCompileResult(emitted),
+            };
+        },
+        async getPreloadUrls(filePath) {
+            let resolvedEntries = [];
+            let seen = new Set();
+            for (let resolvedModule of (Array.isArray(filePath) ? filePath : [filePath]).map((nextPath) => resolveServedModuleOrThrow(resolveInputFilePath(nextPath)))) {
+                if (seen.has(resolvedModule.identityPath))
+                    continue;
+                seen.add(resolvedModule.identityPath);
+                resolvedEntries.push(resolvedModule.identityPath);
+            }
+            let visited = new Set(resolvedEntries);
+            let queue = [...resolvedEntries];
+            let urls = [];
+            while (queue.length > 0) {
+                let frontier = queue;
+                queue = [];
+                let resolvedModules = await getOrCreateResolvedModules(frontier.map((identityPath) => store.get(identityPath)));
+                for (let resolvedModule of resolvedModules) {
+                    urls.push(getServedUrlForResolvedModule(resolvedModule));
+                    for (let dep of resolvedModule.deps) {
+                        if (visited.has(dep))
+                            continue;
+                        visited.add(dep);
+                        queue.push(dep);
+                    }
+                }
+            }
+            return urls;
+        },
+        async getHref(filePath) {
+            let resolvedModule = resolveServedModuleOrThrow(resolveInputFilePath(filePath));
+            return getServedUrl(resolvedModule.identityPath);
+        },
+        async handleFileEvent(filePath, event) {
+            let normalizedFilePath = normalizeFilePath(filePath);
+            if (isWatchIgnored(normalizedFilePath))
+                return;
+            if (shouldClearResolverCacheForFileEvent(normalizedFilePath, event)) {
+                resolverFactory.clearCache();
+            }
+            if (isTsconfigPath(normalizedFilePath)) {
+                tsconfigTransformOptionsResolver.clear();
+                store.invalidateAll();
+                return;
+            }
+            if (isPackageJsonPath(normalizedFilePath)) {
+                store.invalidateAll();
+                return;
+            }
+            store.invalidateForFileEvent(normalizedFilePath, event);
+        },
+        parseRequestPathname(pathname) {
+            let parsedPathname = parseServedPathname(pathname);
+            let filePath = resolvedOptions.routes.resolveUrlPathname(parsedPathname.stablePathname);
+            if (!filePath)
+                return null;
+            if (resolvedOptions.fingerprintModules && parsedPathname.requestedFingerprint === null)
+                return null;
+            return {
+                cacheControl: getFingerprintRequestCacheControl(parsedPathname.requestedFingerprint),
+                filePath,
+                isSourceMapRequest: parsedPathname.isSourceMapRequest,
+                requestedFingerprint: parsedPathname.requestedFingerprint,
+            };
+        },
+    };
+    function resolveInputFilePath(filePath) {
+        if (filePath.startsWith('file://')) {
+            return normalizeFilePath(fileURLToPath(new URL(filePath)));
+        }
+        if (filePath.includes('://')) {
+            throw new TypeError(`Expected a file path or file:// URL, received "${filePath}"`);
+        }
+        return resolveFilePath(resolvedOptions.rootDir, filePath);
+    }
+    function resolveServedModuleOrThrow(absolutePath) {
+        let resolvedModule = resolveModulePath(absolutePath);
+        if (!resolvedModule) {
+            throw createAssetServerCompilationError(`Module not found: ${absolutePath}`, {
+                code: 'MODULE_NOT_FOUND',
+            });
+        }
+        if (!resolvedOptions.isAllowed(resolvedModule.identityPath)) {
+            throw createAssetServerCompilationError(`Module is not allowed: ${resolvedModule.identityPath}`, {
+                code: 'MODULE_NOT_ALLOWED',
+            });
+        }
+        return resolvedModule;
+    }
+    function getNotModifiedModule(record, options) {
+        let current = getNotModifiedResult(record.emitted, options);
+        if (current)
+            return current;
+        if (!record.staleEmittedSnapshot || !isModuleSnapshotFresh(record.staleEmittedSnapshot)) {
+            return null;
+        }
+        return getNotModifiedResult(record.staleEmitted, options);
+    }
+    async function getOrCreateResolvedModules(records) {
+        return mapWithConcurrency(records, preloadConcurrency, (record) => getOrCreateResolvedModule(record));
+    }
+    async function getOrCreateResolvedModule(record) {
+        if (record.resolved)
+            return record.resolved;
+        let cacheKey = getRecordCacheKey(record);
+        let existing = resolveInFlightByCacheKey.get(cacheKey);
+        if (existing)
+            return existing;
+        let promise = (async () => {
+            let startedVersion = record.invalidationVersion;
+            let transformedModule = await getOrCreateTransformedModule(record);
+            if (resolvedOptions.watchMode &&
+                transformedModule.unresolvedImports.some((unresolved) => isBareImportSpecifier(unresolved.specifier))) {
+                resolverFactory.clearCache();
+            }
+            let resolveModuleResult = await resolveModule(record, transformedModule, resolveArgs);
+            if (!resolveModuleResult.ok) {
+                if (isFresh(record, startedVersion)) {
+                    store.setResolveFailure(record.identityPath, resolveModuleResult.tracking);
+                }
+                throw resolveModuleResult.error;
+            }
+            if (isFresh(record, startedVersion)) {
+                store.setResolved(record.identityPath, resolveModuleResult.value);
+            }
+            return resolveModuleResult.value;
+        })();
+        resolveInFlightByCacheKey.set(cacheKey, promise);
+        try {
+            return await promise;
+        }
+        finally {
+            if (resolveInFlightByCacheKey.get(cacheKey) === promise) {
+                resolveInFlightByCacheKey.delete(cacheKey);
+            }
+        }
+    }
+    async function getOrCreateTransformedModule(record) {
+        if (record.transformed)
+            return record.transformed;
+        let startedVersion = record.invalidationVersion;
+        let transformModuleResult = await transformModule(record, transformArgs);
+        if (!transformModuleResult.ok) {
+            if (isFresh(record, startedVersion)) {
+                store.setTransformFailure(record.identityPath, {
+                    trackedFiles: transformModuleResult.trackedFiles,
+                });
+            }
+            throw transformModuleResult.error;
+        }
+        if (isFresh(record, startedVersion)) {
+            store.setTransformed(record.identityPath, transformModuleResult.value);
+        }
+        return transformModuleResult.value;
+    }
+    async function getOrCreateEmittedModule(record) {
+        if (record.emitted)
+            return record.emitted;
+        let cacheKey = getRecordCacheKey(record);
+        let existing = emitInFlightByCacheKey.get(cacheKey);
+        if (existing)
+            return existing;
+        let promise = (async () => {
+            let startedVersion = record.invalidationVersion;
+            let resolvedModule = await getOrCreateResolvedModule(record);
+            let emitResolvedModuleResult = await emitResolvedModule(resolvedModule, {
+                getServedUrl,
+                sourceMaps: resolvedOptions.sourceMaps,
+            });
+            if (!emitResolvedModuleResult.ok) {
+                throw emitResolvedModuleResult.error;
+            }
+            if (isFresh(record, startedVersion)) {
+                store.setEmitted(record.identityPath, emitResolvedModuleResult.value, createModuleSnapshot(resolvedModule.trackedFiles));
+            }
+            return emitResolvedModuleResult.value;
+        })();
+        emitInFlightByCacheKey.set(cacheKey, promise);
+        try {
+            return await promise;
+        }
+        finally {
+            if (emitInFlightByCacheKey.get(cacheKey) === promise) {
+                emitInFlightByCacheKey.delete(cacheKey);
+            }
+        }
+    }
+    async function getServedUrl(identityPath) {
+        return getServedUrlForResolvedModule(await getOrCreateResolvedModule(store.get(identityPath)));
+    }
+    function getServedUrlForResolvedModule(resolvedModule) {
+        return formatFingerprintedPathname(resolvedModule.stableUrlPathname, resolvedOptions.fingerprintModules ? resolvedModule.fingerprint : null);
+    }
+    function isWatchIgnored(filePath) {
+        return resolvedOptions.watchIgnoreMatchers.some((matcher) => matcher(filePath));
+    }
+}
+function getRecordCacheKey(record) {
+    return `${record.identityPath}\0${record.invalidationVersion}`;
+}
+function isFresh(record, version) {
+    return record.invalidationVersion === version;
+}
+function getNotModifiedResult(emittedModule, options) {
+    if (!emittedModule || options.ifNoneMatch === null)
+        return null;
+    if (options.requestedFingerprint !== null &&
+        emittedModule.fingerprint !== options.requestedFingerprint) {
+        return null;
+    }
+    let asset = getEmittedAssetForRequest(emittedModule, options.isSourceMapRequest);
+    if (!asset)
+        return null;
+    if (!IfNoneMatch.from(options.ifNoneMatch).matches(asset.etag))
+        return null;
+    return { type: 'not-modified', etag: asset.etag };
+}
+function getEmittedAssetForRequest(emittedModule, isSourceMapRequest) {
+    return isSourceMapRequest ? emittedModule.sourceMap : emittedModule.code;
+}
+function createModuleSnapshot(filePaths) {
+    let snapshot = new Map();
+    for (let filePath of filePaths) {
+        let fileSnapshot = getFileSnapshot(filePath);
+        if (!fileSnapshot)
+            return null;
+        snapshot.set(filePath, fileSnapshot);
+    }
+    return snapshot;
+}
+function isModuleSnapshotFresh(snapshot) {
+    for (let [filePath, previous] of snapshot) {
+        let current = getFileSnapshot(filePath);
+        if (!current)
+            return false;
+        if (current.mtimeNs !== previous.mtimeNs || current.size !== previous.size)
+            return false;
+    }
+    return true;
+}
+function getFileSnapshot(filePath) {
+    try {
+        let stats = fs.statSync(filePath, { bigint: true });
+        if (!stats.isFile())
+            return null;
+        return {
+            mtimeNs: stats.mtimeNs,
+            size: stats.size,
+        };
+    }
+    catch (error) {
+        if (isNoEntityError(error))
+            return null;
+        throw error;
+    }
+}
+function parseServedPathname(pathname) {
+    let isSourceMapRequest = pathname.endsWith('.map');
+    let pathWithoutMap = isSourceMapRequest ? pathname.slice(0, -4) : pathname;
+    let fingerprint = parseFingerprintSuffix(pathWithoutMap);
+    return {
+        isSourceMapRequest,
+        requestedFingerprint: fingerprint.requestedFingerprint,
+        stablePathname: fingerprint.pathname,
+    };
+}
+async function mapWithConcurrency(items, concurrency, mapper) {
+    if (items.length === 0)
+        return [];
+    let results = new Array(items.length);
+    let nextIndex = 0;
+    async function worker() {
+        while (nextIndex < items.length) {
+            let index = nextIndex++;
+            results[index] = await mapper(items[index], index);
+        }
+    }
+    await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, () => worker()));
+    return results;
+}
+function toModuleCompileResult(emittedModule) {
+    return {
+        code: emittedModule.code,
+        fingerprint: emittedModule.fingerprint,
+        sourceMap: emittedModule.sourceMap,
+    };
+}
+function isPackageJsonPath(filePath) {
+    return filePath.endsWith('/package.json');
+}
+function isTsconfigPath(filePath) {
+    return /\/tsconfig(?:\..+)?\.json$/.test(filePath);
+}
+function shouldClearResolverCacheForFileEvent(filePath, event) {
+    return event !== 'change' || isPackageJsonPath(filePath) || isTsconfigPath(filePath);
+}
+function resolveModulePath(absolutePath) {
+    let resolvedPath;
+    try {
+        resolvedPath = normalizeFilePath(fs.realpathSync(normalizeFilePath(absolutePath)));
+    }
+    catch (error) {
+        if (isNoEntityError(error))
+            return null;
+        throw error;
+    }
+    if (!supportedScriptExtensionSet.has(path.extname(resolvedPath).toLowerCase())) {
+        return null;
+    }
+    return {
+        identityPath: resolvedPath,
+        resolvedPath,
+    };
+}
+function resolveActualPath(identityPath) {
+    try {
+        return normalizeFilePath(fs.realpathSync(identityPath));
+    }
+    catch (error) {
+        if (isNoEntityError(error))
+            return null;
+        throw error;
+    }
+}
+function isBareImportSpecifier(specifier) {
+    return (!specifier.startsWith('./') &&
+        !specifier.startsWith('../') &&
+        !specifier.startsWith('/') &&
+        !specifier.startsWith('file:') &&
+        !specifier.startsWith('data:') &&
+        !specifier.startsWith('http://') &&
+        !specifier.startsWith('https://'));
+}
+function isNoEntityError(error) {
+    return (error instanceof Error &&
+        'code' in error &&
+        (error.code === 'ENOENT' ||
+            error.code === 'ENOTDIR'));
+}
+export function createResponseForModule(result, options) {
+    let body;
+    let etag;
+    let contentType;
+    if (options.isSourceMapRequest) {
+        if (!result.sourceMap) {
+            return new Response('Not found', { status: 404 });
+        }
+        body = options.method === 'HEAD' ? null : result.sourceMap.content;
+        etag = result.sourceMap.etag;
+        contentType = 'application/json; charset=utf-8';
+    }
+    else {
+        body = options.method === 'HEAD' ? null : result.code.content;
+        etag = result.code.etag;
+        contentType = 'application/javascript; charset=utf-8';
+    }
+    if (IfNoneMatch.from(options.ifNoneMatch).matches(etag)) {
+        return new Response(null, { status: 304, headers: { ETag: etag } });
+    }
+    return new Response(body, {
+        headers: {
+            'Cache-Control': options.cacheControl,
+            'Content-Type': contentType,
+            ETag: etag,
+        },
+    });
+}

package/dist/lib/scripts/emit.d.ts

@@ -0,0 +1,25 @@
+import type { ResolvedModule } from './resolve.ts';
+import type { AssetServerCompilationError } from '../compilation-error.ts';
+export type EmittedAsset = {
+    content: string;
+    etag: string;
+};
+export type EmittedModule = {
+    code: EmittedAsset;
+    fingerprint: string | null;
+    importUrls: string[];
+    sourceMap: EmittedAsset | null;
+};
+type EmitResult = {
+    ok: true;
+    value: EmittedModule;
+} | {
+    ok: false;
+    error: AssetServerCompilationError;
+};
+export declare function emitResolvedModule(resolvedModule: ResolvedModule, options: {
+    getServedUrl(identityPath: string): Promise<string>;
+    sourceMaps?: 'external' | 'inline';
+}): Promise<EmitResult>;
+export {};
+//# sourceMappingURL=emit.d.ts.map

package/dist/lib/scripts/emit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit.d.ts","sourceRoot":"","sources":["../../../src/lib/scripts/emit.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAElD,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAA;AAE1E,MAAM,MAAM,YAAY,GAAG;IACzB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,YAAY,CAAA;IAClB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB,SAAS,EAAE,YAAY,GAAG,IAAI,CAAA;CAC/B,CAAA;AAED,KAAK,UAAU,GACX;IACE,EAAE,EAAE,IAAI,CAAA;IACR,KAAK,EAAE,aAAa,CAAA;CACrB,GACD;IACE,EAAE,EAAE,KAAK,CAAA;IACT,KAAK,EAAE,2BAA2B,CAAA;CACnC,CAAA;AAEL,wBAAsB,kBAAkB,CACtC,cAAc,EAAE,cAAc,EAC9B,OAAO,EAAE;IACP,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IACnD,UAAU,CAAC,EAAE,UAAU,GAAG,QAAQ,CAAA;CACnC,GACA,OAAO,CAAC,UAAU,CAAC,CAkCrB"}

package/dist/lib/scripts/emit.js

@@ -0,0 +1,63 @@
+import MagicString from 'magic-string';
+import { createAssetServerCompilationError, isAssetServerCompilationError, } from "../compilation-error.js";
+import { hashContent } from "../fingerprint.js";
+import { composeSourceMaps } from "../source-maps.js";
+export async function emitResolvedModule(resolvedModule, options) {
+    try {
+        let importUrls = await Promise.all(resolvedModule.deps.map((depPath) => options.getServedUrl(depPath)));
+        let rewriteResult = await rewriteImports(resolvedModule, options);
+        let finalCode = rewriteResult.code;
+        if (rewriteResult.sourceMap) {
+            if (options.sourceMaps === 'inline') {
+                let encoded = Buffer.from(rewriteResult.sourceMap).toString('base64');
+                finalCode += `\n//# sourceMappingURL=data:application/json;base64,${encoded}`;
+            }
+            else if (options.sourceMaps === 'external') {
+                finalCode += `\n//# sourceMappingURL=${await options.getServedUrl(resolvedModule.identityPath)}.map`;
+            }
+        }
+        return {
+            ok: true,
+            value: {
+                code: await createEmittedAsset(finalCode),
+                fingerprint: resolvedModule.fingerprint,
+                importUrls,
+                sourceMap: rewriteResult.sourceMap
+                    ? await createEmittedAsset(rewriteResult.sourceMap)
+                    : null,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: toEmitError(error, resolvedModule.identityPath),
+        };
+    }
+}
+async function rewriteImports(resolvedModule, options) {
+    let rewrittenSource = new MagicString(resolvedModule.rawCode);
+    for (let imported of resolvedModule.imports) {
+        let url = await options.getServedUrl(imported.depPath);
+        rewrittenSource.overwrite(imported.start, imported.end, imported.quote ? `${imported.quote}${url}${imported.quote}` : url);
+    }
+    let code = rewrittenSource.toString();
+    let sourceMap = resolvedModule.sourceMap && resolvedModule.imports.length > 0
+        ? composeSourceMaps(rewrittenSource.generateMap({ hires: true }).toString(), resolvedModule.sourceMap)
+        : resolvedModule.sourceMap;
+    return { code, sourceMap };
+}
+async function createEmittedAsset(content) {
+    return {
+        content,
+        etag: `W/"${await hashContent(content)}"`,
+    };
+}
+function toEmitError(error, identityPath) {
+    if (isAssetServerCompilationError(error))
+        return error;
+    return createAssetServerCompilationError(`Failed to emit module ${identityPath}. ${error instanceof Error ? error.message : String(error)}`, {
+        cause: error,
+        code: 'MODULE_EMIT_FAILED',
+    });
+}

package/dist/lib/scripts/resolve.d.ts

@@ -0,0 +1,60 @@
+import type { ResolverFactory } from 'oxc-resolver';
+import type { AssetServerCompilationError } from '../compilation-error.ts';
+import type { CompiledRoutes } from '../routes.ts';
+import type { ModuleRecord } from './store.ts';
+import type { ResolveModuleResult, TransformedModule } from './transform.ts';
+export declare const resolverExtensionAlias: {
+    '.js': string[];
+    '.jsx': string[];
+    '.mjs': string[];
+};
+export declare const resolverExtensions: string[];
+export declare const supportedScriptExtensions: string[];
+type ResolvedImport = {
+    depPath: string;
+    end: number;
+    quote?: '"' | "'" | '`';
+    start: number;
+};
+type RelativeImportResolution = {
+    candidatePaths: readonly string[];
+    candidatePrefixes: readonly string[];
+    specifier: string;
+};
+export type TrackedResolution = RelativeImportResolution & {
+    resolvedIdentityPath: string | null;
+};
+export type ResolvedModule = {
+    deps: string[];
+    fingerprint: string | null;
+    identityPath: string;
+    imports: ResolvedImport[];
+    trackedFiles: string[];
+    trackedResolutions: TrackedResolution[];
+    rawCode: string;
+    resolvedPath: string;
+    sourceMap: string | null;
+    stableUrlPathname: string;
+};
+export type ResolutionFailureState = {
+    trackedFiles: readonly string[];
+    trackedResolutions: readonly TrackedResolution[];
+};
+type ResolveResult = {
+    ok: true;
+    value: ResolvedModule;
+} | {
+    ok: false;
+    error: AssetServerCompilationError;
+    tracking: ResolutionFailureState;
+};
+export type ResolveArgs = {
+    isAllowed(absolutePath: string): boolean;
+    isWatchIgnored(filePath: string): boolean;
+    resolveModulePath(absolutePath: string): ResolveModuleResult | null;
+    resolverFactory: ResolverFactory;
+    routes: CompiledRoutes;
+};
+export declare function resolveModule(record: ModuleRecord, transformed: TransformedModule, args: ResolveArgs): Promise<ResolveResult>;
+export {};
+//# sourceMappingURL=resolve.d.ts.map

package/dist/lib/scripts/resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../../src/lib/scripts/resolve.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAMnD,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAA;AAE1E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAC9C,OAAO,KAAK,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAA;AAE5E,eAAO,MAAM,sBAAsB;;;;CAIC,CAAA;AAEpC,eAAO,MAAM,kBAAkB,UAAiD,CAAA;AAChF,eAAO,MAAM,yBAAyB,UAAiD,CAAA;AAGvF,KAAK,cAAc,GAAG;IACpB,OAAO,EAAE,MAAM,CAAA;IACf,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,CAAC,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,CAAA;IACvB,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,KAAK,wBAAwB,GAAG;IAC9B,cAAc,EAAE,SAAS,MAAM,EAAE,CAAA;IACjC,iBAAiB,EAAE,SAAS,MAAM,EAAE,CAAA;IACpC,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG,wBAAwB,GAAG;IACzD,oBAAoB,EAAE,MAAM,GAAG,IAAI,CAAA;CACpC,CAAA;AAED,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,YAAY,EAAE,MAAM,CAAA;IACpB,OAAO,EAAE,cAAc,EAAE,CAAA;IACzB,YAAY,EAAE,MAAM,EAAE,CAAA;IACtB,kBAAkB,EAAE,iBAAiB,EAAE,CAAA;IACvC,OAAO,EAAE,MAAM,CAAA;IACf,YAAY,EAAE,MAAM,CAAA;IACpB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,iBAAiB,EAAE,MAAM,CAAA;CAC1B,CAAA;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAA;IAC/B,kBAAkB,EAAE,SAAS,iBAAiB,EAAE,CAAA;CACjD,CAAA;AAED,KAAK,aAAa,GACd;IACE,EAAE,EAAE,IAAI,CAAA;IACR,KAAK,EAAE,cAAc,CAAA;CACtB,GACD;IACE,EAAE,EAAE,KAAK,CAAA;IACT,KAAK,EAAE,2BAA2B,CAAA;IAClC,QAAQ,EAAE,sBAAsB,CAAA;CACjC,CAAA;AAEL,MAAM,MAAM,WAAW,GAAG;IACxB,SAAS,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAA;IACxC,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAA;IACzC,iBAAiB,CAAC,YAAY,EAAE,MAAM,GAAG,mBAAmB,GAAG,IAAI,CAAA;IACnE,eAAe,EAAE,eAAe,CAAA;IAChC,MAAM,EAAE,cAAc,CAAA;CACvB,CAAA;AAQD,wBAAsB,aAAa,CACjC,MAAM,EAAE,YAAY,EACpB,WAAW,EAAE,iBAAiB,EAC9B,IAAI,EAAE,WAAW,GAChB,OAAO,CAAC,aAAa,CAAC,CAyIxB"}