solve-engine 1.0.0-beta.0 → 1.0.0-beta.2

package/dist/pipeline-DPUQt7yL.d.cts

@@ -0,0 +1,285 @@
+import { M as MatrixData, R as RangeData, S as SymbolicNode } from './Value-KtAQNHur.cjs';
+
+/** Base event, all events include a timestamp relative to pipeline start */
+interface BaseEvent {
+    readonly type: string;
+    readonly elapsedNs: number;
+    readonly expression: string;
+}
+/** Emitted after each token is produced by the lexer */
+interface TokenEmittedEvent extends BaseEvent {
+    readonly type: "token_emitted";
+    readonly token: {
+        readonly type: string;
+        readonly value: string;
+        readonly offset: number;
+        readonly line: number;
+        readonly col: number;
+    };
+}
+/** Emitted when the parser resolves a parselet for a token */
+interface ParseletMatchedEvent extends BaseEvent {
+    readonly type: "parselet_matched";
+    readonly tokenType: string;
+    readonly tokenValue: string;
+    readonly parseletCategory: string;
+    readonly parseletType: string;
+    readonly isPrefix: boolean;
+    readonly bindingPower?: number;
+    readonly tokenOffset: number;
+}
+/** Emitted after bytecode is built */
+interface BytecodeBuiltEvent extends BaseEvent {
+    readonly type: "bytecode_built";
+    readonly opcodesLength: number;
+    readonly numbersLength: number;
+    readonly stringsLength: number;
+    readonly isCached: boolean;
+}
+/** Emitted after each VM opcode execution (only when vmTrace is enabled) */
+interface VmStepEvent extends BaseEvent {
+    readonly type: "vm_step";
+    readonly opcode: number;
+    readonly opcodeName: string;
+    readonly ip: number;
+    readonly stackDepth: number;
+    readonly instructionNumber: number;
+    readonly stack: ReadonlyArray<{
+        readonly type: number;
+        readonly value: number | bigint | string | boolean | MatrixData | RangeData | SymbolicNode;
+        readonly unit?: string;
+    }>;
+}
+/** Emitted when the VM halts with a result */
+interface VmHaltEvent extends BaseEvent {
+    readonly type: "vm_halt";
+    readonly result?: {
+        readonly type: number;
+        readonly value: number | bigint | string | boolean | MatrixData | RangeData | SymbolicNode;
+        readonly unit?: string;
+    };
+}
+/** Emitted on cache hit */
+interface CacheHitEvent extends BaseEvent {
+    readonly type: "cache_hit";
+    readonly cache: "bytecode" | "line";
+    readonly key: string;
+}
+/** Emitted on cache miss */
+interface CacheMissEvent extends BaseEvent {
+    readonly type: "cache_miss";
+    readonly cache: "bytecode" | "line";
+    readonly key: string;
+}
+/** Emitted when a pipeline evaluation begins */
+interface PipelineStartEvent extends BaseEvent {
+    readonly type: "pipeline_start";
+    readonly inputType: string;
+}
+/** Emitted when a pipeline evaluation completes */
+interface PipelineEndEvent extends BaseEvent {
+    readonly type: "pipeline_end";
+    readonly success: boolean;
+    readonly error?: string;
+    readonly totalTokens: number;
+    readonly totalOpcodes: number;
+}
+/** Emitted when the normalizer begins its pass */
+interface NormalizerStartEvent extends BaseEvent {
+    readonly type: "normalizer_start";
+    readonly inputTokenCount: number;
+}
+/** Emitted when the normalizer fuses tokens */
+interface TokenFusedEvent extends BaseEvent {
+    readonly type: "token_fused";
+    readonly ruleName: string;
+    readonly sourceTokenCount: number;
+    readonly fusedTokenType: string;
+    readonly fusedTokenValue: string;
+}
+/** Emitted when the normalizer completes its pass */
+interface NormalizerEndEvent extends BaseEvent {
+    readonly type: "normalizer_end";
+    readonly outputTokenCount: number;
+    readonly fusionsCount: number;
+}
+/** Union of all event types */
+type DiagnosticEvent = TokenEmittedEvent | NormalizerStartEvent | TokenFusedEvent | NormalizerEndEvent | ParseletMatchedEvent | BytecodeBuiltEvent | VmStepEvent | VmHaltEvent | CacheHitEvent | CacheMissEvent | PipelineStartEvent | PipelineEndEvent;
+/** Categorized parselet info */
+interface CategorizedParselet {
+    readonly tokenType: string;
+    readonly tokenValue: string;
+    readonly parseletCategory: string;
+    readonly parseletType: string;
+    readonly isPrefix: boolean;
+    readonly bindingPower?: number;
+    readonly tokenOffset: number;
+}
+/** Structured diagnostic report */
+interface DiagnosticReport {
+    readonly events: readonly DiagnosticEvent[];
+    readonly parselets: readonly CategorizedParselet[];
+    readonly summary: {
+        readonly totalTokens: number;
+        readonly totalParselets: number;
+        readonly totalOpcodes: number;
+        readonly cacheHit: boolean;
+        readonly elapsedNs: number;
+        readonly parseCategories: ReadonlyMap<string, number>;
+    };
+    readonly metadata: {
+        readonly expression: string;
+        readonly inputType: string;
+        readonly timestamp: number;
+        readonly vmTraceEnabled: boolean;
+    };
+    /** Serialize to a JSON-safe plain object */
+    toJSON(): DiagnosticReportJSON;
+}
+/** JSON-serializable representation of a DiagnosticReport */
+interface DiagnosticReportJSON {
+    readonly events: readonly DiagnosticEvent[];
+    readonly parselets: readonly CategorizedParselet[];
+    readonly summary: {
+        readonly totalTokens: number;
+        readonly totalParselets: number;
+        readonly totalOpcodes: number;
+        readonly cacheHit: boolean;
+        readonly elapsedNs: number;
+        readonly parseCategories: Record<string, number>;
+    };
+    readonly metadata: {
+        readonly expression: string;
+        readonly inputType: string;
+        readonly timestamp: number;
+        readonly vmTraceEnabled: boolean;
+    };
+}
+/** JSON-serializable representation of a DiagnosticReport */
+interface DiagnosticReportJSON {
+    readonly events: readonly DiagnosticEvent[];
+    readonly parselets: readonly CategorizedParselet[];
+    readonly summary: {
+        readonly totalTokens: number;
+        readonly totalParselets: number;
+        readonly totalOpcodes: number;
+        readonly cacheHit: boolean;
+        readonly elapsedNs: number;
+        readonly parseCategories: Record<string, number>;
+    };
+    readonly metadata: {
+        readonly expression: string;
+        readonly inputType: string;
+        readonly timestamp: number;
+        readonly vmTraceEnabled: boolean;
+    };
+}
+
+/**
+ * Interface for collecting diagnostic data during pipeline execution.
+ *
+ * All methods are implemented as concrete no-ops so subclasses only
+ * need to override the ones they care about. This avoids optional
+ * method issues with TypeScript's strict mode.
+ *
+ * The parameters are named `_event` because these base implementations
+ * deliberately ignore them. Overrides are free to name theirs `event` and use
+ * it; TypeScript does not match parameter names when checking overrides.
+ */
+declare abstract class DiagnosticCollector {
+    onPipelineStart(_event: DiagnosticEvent & {
+        type: "pipeline_start";
+    }): void;
+    onTokenEmitted(_event: DiagnosticEvent & {
+        type: "token_emitted";
+    }): void;
+    onNormalizerStart(_event: DiagnosticEvent & {
+        type: "normalizer_start";
+    }): void;
+    onTokenFused(_event: DiagnosticEvent & {
+        type: "token_fused";
+    }): void;
+    onNormalizerEnd(_event: DiagnosticEvent & {
+        type: "normalizer_end";
+    }): void;
+    onParseletMatched(_event: DiagnosticEvent & {
+        type: "parselet_matched";
+    }): void;
+    onBytecodeBuilt(_event: DiagnosticEvent & {
+        type: "bytecode_built";
+    }): void;
+    onVmStep(_event: DiagnosticEvent & {
+        type: "vm_step";
+    }): void;
+    onVmHalt(_event: DiagnosticEvent & {
+        type: "vm_halt";
+    }): void;
+    onCacheHit(_event: DiagnosticEvent & {
+        type: "cache_hit";
+    }): void;
+    onCacheMiss(_event: DiagnosticEvent & {
+        type: "cache_miss";
+    }): void;
+    onPipelineEnd(_event: DiagnosticEvent & {
+        type: "pipeline_end";
+    }): void;
+    abstract getReport(): DiagnosticReport | undefined;
+    abstract reset(): void;
+}
+
+/**
+ * Dispatches diagnostic events to all registered collectors.
+ *
+ * Performance guarantee: when no collectors are registered (production mode),
+ * every dispatch method is a branch on `this.collectors.length === 0` which
+ * modern JS engines will predict and eliminate. The overhead is a single
+ * comparison per call, effectively zero.
+ */
+declare class DiagnosticPipeline {
+    private collectors;
+    register(collector: DiagnosticCollector): void;
+    unregister(collector: DiagnosticCollector): void;
+    clear(): void;
+    get hasCollectors(): boolean;
+    get collectorCount(): number;
+    firePipelineStart(event: DiagnosticEvent & {
+        type: "pipeline_start";
+    }): void;
+    fireTokenEmitted(event: DiagnosticEvent & {
+        type: "token_emitted";
+    }): void;
+    fireNormalizerStart(event: DiagnosticEvent & {
+        type: "normalizer_start";
+    }): void;
+    fireTokenFused(event: DiagnosticEvent & {
+        type: "token_fused";
+    }): void;
+    fireNormalizerEnd(event: DiagnosticEvent & {
+        type: "normalizer_end";
+    }): void;
+    fireParseletMatched(event: DiagnosticEvent & {
+        type: "parselet_matched";
+    }): void;
+    fireBytecodeBuilt(event: DiagnosticEvent & {
+        type: "bytecode_built";
+    }): void;
+    fireVmStep(event: DiagnosticEvent & {
+        type: "vm_step";
+    }): void;
+    fireVmHalt(event: DiagnosticEvent & {
+        type: "vm_halt";
+    }): void;
+    fireCacheHit(event: DiagnosticEvent & {
+        type: "cache_hit";
+    }): void;
+    fireCacheMiss(event: DiagnosticEvent & {
+        type: "cache_miss";
+    }): void;
+    firePipelineEnd(event: DiagnosticEvent & {
+        type: "pipeline_end";
+    }): void;
+    collectReports(): DiagnosticReport[];
+    reset(): void;
+}
+
+export { DiagnosticPipeline as D, type DiagnosticReportJSON as a };

package/dist/resolvers.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+var chunkX6K3HUOY_cjs = require('./chunk-X6K3HUOY.cjs');
+require('./chunk-B7LXJ6LC.cjs');
+
+
+
+Object.defineProperty(exports, "ResolverRegistry", {
+  enumerable: true,
+  get: function () { return chunkX6K3HUOY_cjs.ResolverRegistry; }
+});
+//# sourceMappingURL=resolvers.cjs.map
+//# sourceMappingURL=resolvers.cjs.map

package/dist/resolvers.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"resolvers.cjs"}

package/dist/resolvers.d.cts

@@ -0,0 +1,111 @@
+import { QueryClient } from '@tanstack/query-core';
+import { T as Token } from './Token-0jpvUdPY.cjs';
+import { a as BytecodeProgram } from './BytecodeBuilder-3egMyuDi.cjs';
+import { V as Value } from './Value-KtAQNHur.cjs';
+
+/**
+ * Result from a resolver's preflight() check.
+ * Returned when async data is needed, the orchestrator uses this
+ * to subscribe to the resolver and return a Pending value immediately.
+ */
+interface AsyncCheckResult {
+    /** Unique cache key for deduplication (e.g., "{packageId}:rates:USD:GBP") */
+    queryKey: string;
+    /** Promise that resolves to the final Value */
+    resolver: Promise<Value>;
+    /** Package owning this resolver */
+    packageId: string;
+    /** AbortSignal for stale-data prevention */
+    signal: AbortSignal;
+    /** Optional metadata for diagnostics */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Interface for async resolvers registered by packages/plugins.
+ *
+ * Each resolver handles a domain of async data (currency rates,
+ * weather, stock prices, etc.). The preflight() method is called
+ * BEFORE VM execution to check if all data is cached. If not,
+ * it returns an AsyncCheckResult and the engine skips the VM,
+ * returning a Pending value instead.
+ */
+interface IAsyncResolver {
+    /** Unique namespace for cache key scoping (e.g., "currency", "weather") */
+    readonly namespace: string;
+    /**
+     * Pre-flight check: called BEFORE VM execution.
+     *
+     * Returns null if all data for this expression is cached and ready.
+     * Returns an AsyncCheckResult if async work is needed.
+     *
+     * This method is synchronous, it only checks caches, never fetches.
+     * If data is missing, it creates a Promise and returns immediately.
+     *
+     * @param tokens - The lexed tokens for the expression
+     * @param bytecode - The compiled bytecode program
+     * @param pluginId - The plugin ID (for cache key scoping)
+     * @param signal - AbortSignal for the current evaluation
+     */
+    preflight?(tokens: Token[], bytecode: BytecodeProgram, packageId: string, signal: AbortSignal, queryClient: QueryClient): AsyncCheckResult | null;
+    /**
+     * Called when the resolver's namespace is being unregistered.
+     * Clean up any in-flight promises, clear caches, unsubscribe.
+     */
+    destroy(): void;
+}
+/**
+ * Registry of async resolvers, keyed by namespace.
+ *
+ * Plugins/packages register resolvers alongside their parselets
+ * and opcode handlers. The engine calls preflightAll() before
+ * VM execution to short-circuit async expressions.
+ *
+ * Lifecycle:
+ * - register(), when a package is loaded
+ * - unregister(), when a package is unloaded (clears cache entries)
+ * - clear(), on document switch (clears all resolvers)
+ */
+declare class ResolverRegistry {
+    private resolvers;
+    /**
+     * Register an async resolver.
+     *
+     * Each resolver must have a unique `namespace`. If a resolver with the
+     * same namespace is already registered, the old one is destroyed and
+     * replaced (with a console warning). Packages that need multiple async
+     * operations should use `asyncResolvers: [...]` with distinct namespaces
+     * (e.g., `"weather:current"`, `"weather:forecast"`).
+     */
+    register(resolver: IAsyncResolver): void;
+    /**
+     * Unregister a resolver by namespace.
+     * Calls destroy() and clears all cache entries with that namespace prefix.
+     */
+    unregister(namespace: string, queryClient?: QueryClient): void;
+    /**
+     * Run all registered resolvers' preflight checks against compiled bytecode.
+     *
+     * Returns the first AsyncCheckResult found, or null if all data is ready.
+     * Short-circuits on first pending, subsequent pending ops will be
+     * discovered on re-evaluation when the first resolves.
+     */
+    preflightAll(tokens: Token[], bytecode: BytecodeProgram, packageId: string, signal: AbortSignal, queryClient: QueryClient): AsyncCheckResult | null;
+    /**
+     * Get a resolver by namespace.
+     * Returns undefined if no resolver is registered for that namespace.
+     */
+    get(namespace: string): IAsyncResolver | undefined;
+    /** Number of registered resolvers. */
+    get size(): number;
+    /**
+     * Check if a resolver is registered for the given namespace.
+     */
+    has(namespace: string): boolean;
+    /**
+     * Clear all resolvers (document switch, engine reset).
+     * Calls destroy() on each resolver and clears the map.
+     */
+    clear(): void;
+}
+
+export { type AsyncCheckResult, type IAsyncResolver, ResolverRegistry };

package/dist/resolvers.d.ts

@@ -0,0 +1,111 @@
+import { QueryClient } from '@tanstack/query-core';
+import { T as Token } from './Token-0jpvUdPY.js';
+import { a as BytecodeProgram } from './BytecodeBuilder-3egMyuDi.js';
+import { V as Value } from './Value-KtAQNHur.js';
+
+/**
+ * Result from a resolver's preflight() check.
+ * Returned when async data is needed, the orchestrator uses this
+ * to subscribe to the resolver and return a Pending value immediately.
+ */
+interface AsyncCheckResult {
+    /** Unique cache key for deduplication (e.g., "{packageId}:rates:USD:GBP") */
+    queryKey: string;
+    /** Promise that resolves to the final Value */
+    resolver: Promise<Value>;
+    /** Package owning this resolver */
+    packageId: string;
+    /** AbortSignal for stale-data prevention */
+    signal: AbortSignal;
+    /** Optional metadata for diagnostics */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Interface for async resolvers registered by packages/plugins.
+ *
+ * Each resolver handles a domain of async data (currency rates,
+ * weather, stock prices, etc.). The preflight() method is called
+ * BEFORE VM execution to check if all data is cached. If not,
+ * it returns an AsyncCheckResult and the engine skips the VM,
+ * returning a Pending value instead.
+ */
+interface IAsyncResolver {
+    /** Unique namespace for cache key scoping (e.g., "currency", "weather") */
+    readonly namespace: string;
+    /**
+     * Pre-flight check: called BEFORE VM execution.
+     *
+     * Returns null if all data for this expression is cached and ready.
+     * Returns an AsyncCheckResult if async work is needed.
+     *
+     * This method is synchronous, it only checks caches, never fetches.
+     * If data is missing, it creates a Promise and returns immediately.
+     *
+     * @param tokens - The lexed tokens for the expression
+     * @param bytecode - The compiled bytecode program
+     * @param pluginId - The plugin ID (for cache key scoping)
+     * @param signal - AbortSignal for the current evaluation
+     */
+    preflight?(tokens: Token[], bytecode: BytecodeProgram, packageId: string, signal: AbortSignal, queryClient: QueryClient): AsyncCheckResult | null;
+    /**
+     * Called when the resolver's namespace is being unregistered.
+     * Clean up any in-flight promises, clear caches, unsubscribe.
+     */
+    destroy(): void;
+}
+/**
+ * Registry of async resolvers, keyed by namespace.
+ *
+ * Plugins/packages register resolvers alongside their parselets
+ * and opcode handlers. The engine calls preflightAll() before
+ * VM execution to short-circuit async expressions.
+ *
+ * Lifecycle:
+ * - register(), when a package is loaded
+ * - unregister(), when a package is unloaded (clears cache entries)
+ * - clear(), on document switch (clears all resolvers)
+ */
+declare class ResolverRegistry {
+    private resolvers;
+    /**
+     * Register an async resolver.
+     *
+     * Each resolver must have a unique `namespace`. If a resolver with the
+     * same namespace is already registered, the old one is destroyed and
+     * replaced (with a console warning). Packages that need multiple async
+     * operations should use `asyncResolvers: [...]` with distinct namespaces
+     * (e.g., `"weather:current"`, `"weather:forecast"`).
+     */
+    register(resolver: IAsyncResolver): void;
+    /**
+     * Unregister a resolver by namespace.
+     * Calls destroy() and clears all cache entries with that namespace prefix.
+     */
+    unregister(namespace: string, queryClient?: QueryClient): void;
+    /**
+     * Run all registered resolvers' preflight checks against compiled bytecode.
+     *
+     * Returns the first AsyncCheckResult found, or null if all data is ready.
+     * Short-circuits on first pending, subsequent pending ops will be
+     * discovered on re-evaluation when the first resolves.
+     */
+    preflightAll(tokens: Token[], bytecode: BytecodeProgram, packageId: string, signal: AbortSignal, queryClient: QueryClient): AsyncCheckResult | null;
+    /**
+     * Get a resolver by namespace.
+     * Returns undefined if no resolver is registered for that namespace.
+     */
+    get(namespace: string): IAsyncResolver | undefined;
+    /** Number of registered resolvers. */
+    get size(): number;
+    /**
+     * Check if a resolver is registered for the given namespace.
+     */
+    has(namespace: string): boolean;
+    /**
+     * Clear all resolvers (document switch, engine reset).
+     * Calls destroy() on each resolver and clears the map.
+     */
+    clear(): void;
+}
+
+export { type AsyncCheckResult, type IAsyncResolver, ResolverRegistry };

package/dist/resolvers.js

@@ -0,0 +1,4 @@
+export { ResolverRegistry } from './chunk-3VGDNEE3.js';
+import './chunk-YLJ4XMA6.js';
+//# sourceMappingURL=resolvers.js.map
+//# sourceMappingURL=resolvers.js.map

package/dist/resolvers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"resolvers.js"}

package/dist/services.cjs

@@ -0,0 +1,21 @@
+'use strict';
+
+var chunkZ2XP767T_cjs = require('./chunk-Z2XP767T.cjs');
+require('./chunk-B7LXJ6LC.cjs');
+
+
+
+Object.defineProperty(exports, "createQueryClient", {
+  enumerable: true,
+  get: function () { return chunkZ2XP767T_cjs.createQueryClient; }
+});
+Object.defineProperty(exports, "getActiveQueryClient", {
+  enumerable: true,
+  get: function () { return chunkZ2XP767T_cjs.getActiveQueryClient; }
+});
+Object.defineProperty(exports, "setActiveQueryClient", {
+  enumerable: true,
+  get: function () { return chunkZ2XP767T_cjs.setActiveQueryClient; }
+});
+//# sourceMappingURL=services.cjs.map
+//# sourceMappingURL=services.cjs.map

package/dist/services.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"services.cjs"}

package/dist/services.d.cts

@@ -0,0 +1,30 @@
+import { QueryClient } from '@tanstack/query-core';
+
+/**
+ * QueryClient factory for the solve-js engine.
+ *
+ * Creates a TanStack Query QueryClient with sensible defaults for
+ * stale-while-revalidate, garbage collection, and retry behavior.
+ * The QueryClient is injected into resolvers via the engine, so
+ * no global singleton is needed.
+ *
+ * Removed in this refactor:
+ * - DataQueryWorker (worker thread), doesn't solve anything in Obsidian's single-threaded env
+ * - localCache (raw Map), replaced by TanStack Query's built-in cache
+ * - pendingQueries (manual promise plumbing), TanStack Query handles dedup
+ * - DataSourceHandle, registerDataSource, unregisterDataSource, no longer needed
+ * - cleanupCache timer, TanStack Query's gc does this automatically
+ * - cacheUpdateListeners / errorListeners, TanStack Query has its own observer API
+ */
+
+/** Publish the QueryClient for the execution about to run. Set by the engine. */
+declare function setActiveQueryClient(qc: QueryClient | null): void;
+/** Read the QueryClient of the currently executing engine, if any. */
+declare function getActiveQueryClient(): QueryClient | null;
+/**
+ * Create a new TanStack Query QueryClient with project defaults.
+ * Each engine instance gets its own client for isolation.
+ */
+declare function createQueryClient(): QueryClient;
+
+export { createQueryClient, getActiveQueryClient, setActiveQueryClient };

package/dist/services.d.ts

@@ -0,0 +1,30 @@
+import { QueryClient } from '@tanstack/query-core';
+
+/**
+ * QueryClient factory for the solve-js engine.
+ *
+ * Creates a TanStack Query QueryClient with sensible defaults for
+ * stale-while-revalidate, garbage collection, and retry behavior.
+ * The QueryClient is injected into resolvers via the engine, so
+ * no global singleton is needed.
+ *
+ * Removed in this refactor:
+ * - DataQueryWorker (worker thread), doesn't solve anything in Obsidian's single-threaded env
+ * - localCache (raw Map), replaced by TanStack Query's built-in cache
+ * - pendingQueries (manual promise plumbing), TanStack Query handles dedup
+ * - DataSourceHandle, registerDataSource, unregisterDataSource, no longer needed
+ * - cleanupCache timer, TanStack Query's gc does this automatically
+ * - cacheUpdateListeners / errorListeners, TanStack Query has its own observer API
+ */
+
+/** Publish the QueryClient for the execution about to run. Set by the engine. */
+declare function setActiveQueryClient(qc: QueryClient | null): void;
+/** Read the QueryClient of the currently executing engine, if any. */
+declare function getActiveQueryClient(): QueryClient | null;
+/**
+ * Create a new TanStack Query QueryClient with project defaults.
+ * Each engine instance gets its own client for isolation.
+ */
+declare function createQueryClient(): QueryClient;
+
+export { createQueryClient, getActiveQueryClient, setActiveQueryClient };

package/dist/services.js

@@ -0,0 +1,4 @@
+export { createQueryClient, getActiveQueryClient, setActiveQueryClient } from './chunk-NLNDMWZC.js';
+import './chunk-YLJ4XMA6.js';
+//# sourceMappingURL=services.js.map
+//# sourceMappingURL=services.js.map

package/dist/services.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"services.js"}

package/dist/uom.cjs

@@ -0,0 +1,56 @@
+'use strict';
+
+var chunkWQTTOGXC_cjs = require('./chunk-WQTTOGXC.cjs');
+var chunkXJCMXB2E_cjs = require('./chunk-XJCMXB2E.cjs');
+require('./chunk-MZOVP3WI.cjs');
+require('./chunk-VEKIWQ3F.cjs');
+require('./chunk-OC6LTXYS.cjs');
+var chunkQNJ4ACRT_cjs = require('./chunk-QNJ4ACRT.cjs');
+require('./chunk-53B6KDDJ.cjs');
+require('./chunk-M4N5GA5Z.cjs');
+require('./chunk-B7LXJ6LC.cjs');
+
+
+
+Object.defineProperty(exports, "CurrencyAsyncResolver", {
+  enumerable: true,
+  get: function () { return chunkWQTTOGXC_cjs.CurrencyAsyncResolver; }
+});
+Object.defineProperty(exports, "CurrencyExchangeService", {
+  enumerable: true,
+  get: function () { return chunkXJCMXB2E_cjs.CurrencyExchangeService; }
+});
+Object.defineProperty(exports, "currencyExchangeService", {
+  enumerable: true,
+  get: function () { return chunkXJCMXB2E_cjs.currencyExchangeService; }
+});
+Object.defineProperty(exports, "sharedCurrencyExchange", {
+  enumerable: true,
+  get: function () { return chunkXJCMXB2E_cjs.sharedCurrencyExchange; }
+});
+Object.defineProperty(exports, "canConvert", {
+  enumerable: true,
+  get: function () { return chunkQNJ4ACRT_cjs.canConvert; }
+});
+Object.defineProperty(exports, "convertUnit", {
+  enumerable: true,
+  get: function () { return chunkQNJ4ACRT_cjs.convertUnit; }
+});
+Object.defineProperty(exports, "getBestUnit", {
+  enumerable: true,
+  get: function () { return chunkQNJ4ACRT_cjs.getBestUnit; }
+});
+Object.defineProperty(exports, "getMeasure", {
+  enumerable: true,
+  get: function () { return chunkQNJ4ACRT_cjs.getMeasure; }
+});
+Object.defineProperty(exports, "isConvertibleUnit", {
+  enumerable: true,
+  get: function () { return chunkQNJ4ACRT_cjs.isConvertibleUnit; }
+});
+Object.defineProperty(exports, "resolveUnit", {
+  enumerable: true,
+  get: function () { return chunkQNJ4ACRT_cjs.resolveUnit; }
+});
+//# sourceMappingURL=uom.cjs.map
+//# sourceMappingURL=uom.cjs.map