@univerjs-pro/engine-formula 1.0.0-alpha.3 → 1.0.0-alpha.4

package/lib/types/controllers/external-reference-data-providers.controller.d.ts

@@ -0,0 +1,6 @@
+import { Disposable } from '@univerjs/core';
+import { ExternalCacheReferenceDataProvider } from '../services/external-cache-reference-data.provider';
+import { IFormulaReferenceDataProviderRegistry } from '../services/formula-reference-data.service';
+export declare class ExternalReferenceDataProvidersController extends Disposable {
+    constructor(registry: IFormulaReferenceDataProviderRegistry, cacheProvider: ExternalCacheReferenceDataProvider);
+}

package/lib/types/controllers/external-reference-rename.controller.d.ts

@@ -0,0 +1,9 @@
+import { Disposable, IUniverInstanceService } from '@univerjs/core';
+import { ExternalReferenceOverlayModel } from '../models/external-reference-overlay.model';
+import { ExternalReferenceModel } from '../models/external-reference.model';
+export declare class ExternalReferenceRenameController extends Disposable {
+    private readonly _univerInstanceService;
+    private readonly _names;
+    constructor(_univerInstanceService: IUniverInstanceService, externalReferenceModel: ExternalReferenceModel, externalReferenceOverlayModel: ExternalReferenceOverlayModel);
+    private _watch;
+}

package/lib/types/controllers/external-reference-resource.controller.d.ts

@@ -0,0 +1,6 @@
+import { Disposable, IResourceManagerService } from '@univerjs/core';
+import { ExternalReferenceOverlayModel } from '../models/external-reference-overlay.model';
+import { ExternalReferenceModel } from '../models/external-reference.model';
+export declare class ExternalReferenceResourceController extends Disposable {
+    constructor(resourceManagerService: IResourceManagerService, externalReferenceModel: ExternalReferenceModel, externalReferenceOverlayModel: ExternalReferenceOverlayModel);
+}

package/lib/types/controllers/formula-reference-data-rpc.controller.d.ts

@@ -0,0 +1,7 @@
+import { Disposable } from '@univerjs/core';
+import { IRPCChannelService } from '@univerjs/rpc';
+import { IFormulaReferenceDataService } from '../services/formula-reference-data.service';
+export declare const FORMULA_REFERENCE_DATA_RPC_CHANNEL = "univer-pro.formula.reference-data";
+export declare class FormulaReferenceDataRpcController extends Disposable {
+    constructor(rpcChannelService: IRPCChannelService, referenceDataService: IFormulaReferenceDataService);
+}

package/lib/types/index.d.ts

@@ -1,6 +1,23 @@
+export { ExternalReferenceDataProvidersController } from './controllers/external-reference-data-providers.controller';
+export { ExternalReferenceRenameController } from './controllers/external-reference-rename.controller';
+export { ExternalReferenceResourceController } from './controllers/external-reference-resource.controller';
+export { FORMULA_REFERENCE_DATA_RPC_CHANNEL, FormulaReferenceDataRpcController } from './controllers/formula-reference-data-rpc.controller';
+export { ExternalReferenceOverlayModel } from './models/external-reference-overlay.model';
+export type { IExternalOverlayCellState } from './models/external-reference-overlay.model';
+export { createEmptyExternalReferenceResource, createExternalSyntheticUnitId, EXTERNAL_REFERENCE_SCHEMA_VERSION, ExternalReferenceModel, SHEET_EXTERNAL_DATA_PLUGIN, } from './models/external-reference.model';
+export type { ExternalReferenceBindingResult, IExternalReferenceCachedCell, IExternalReferenceCachedSheet, IExternalReferenceCoverage, IExternalReferenceLink, IExternalReferenceResource, IExternalReferenceTable, IExternalReferenceTableColumn, } from './models/external-reference.model';
 export { UniverProFormulaEnginePlugin } from './plugin';
-export { RemoveSuperTableMutation, SetFormulaCalculationResultMutation, SetFormulaCalculationStartMutation, SetSuperTableMutation, } from '@univerjs/engine-formula';
+export { ExternalCacheReferenceDataProvider } from './services/external-cache-reference-data.provider';
+export { ExternalReferencePrefetchPlanner } from './services/external-reference-prefetch-planner';
+export { ExternalReferencePrefetchService } from './services/external-reference-prefetch.service';
+export type { IExternalReferencePrefetchLimits, IExternalReferencePrefetchResult, } from './services/external-reference-prefetch.service';
+export { ExternalFormulaUnitReferenceResolver } from './services/external-unit-reference-resolver.service';
+export { createUnavailableReferenceDataResponse, FormulaReferenceDataProviderRegistry, IFormulaReferenceDataProviderRegistry, IFormulaReferenceDataService, } from './services/formula-reference-data.service';
+export type { FormulaReferenceDataFreshness, FormulaReferenceDataSource, IFormulaReferenceDataCell, IFormulaReferenceDataProvider, IFormulaReferenceDataRangeRequest, IFormulaReferenceDataRequest, IFormulaReferenceDataResponse, IFormulaReferenceDataSheet, } from './services/formula-reference-data.service';
+export { MainFormulaReferenceDataService } from './services/main-formula-reference-data.service';
+export { RemoveSuperTableMutation, SetFormulaCalculationResultMutation, SetFormulaCalculationStartMutation, SetSuperTableMutation, SetTriggerFormulaCalculationStartMutation, } from '@univerjs/engine-formula';
 export type { ISetFormulaCalculationResultMutation, ISetFormulaCalculationStartMutation, ISuperTable, } from '@univerjs/engine-formula';
 export { SetFormulaDataMutation } from '@univerjs/engine-formula';
+export { refactorFormulaUnitQualifier } from '@univerjs/engine-formula';
 export type { IUniverEngineFormulaConfig } from '@univerjs/engine-formula';
 export { FormulaCalculationTriggerService, FormulaDataModel, IActiveDirtyManagerService, ISuperTableService, } from '@univerjs/engine-formula';

package/lib/types/models/external-reference-overlay.model.d.ts

@@ -0,0 +1,41 @@
+import type { IRange, IUnitRange } from '@univerjs/core';
+import type { IFormulaDatasetConfig } from '@univerjs/engine-formula';
+import type { IFormulaReferenceDataRequest, IFormulaReferenceDataResponse } from '../services/formula-reference-data.service';
+import { Disposable } from '@univerjs/core';
+import { ISuperTableService } from '@univerjs/engine-formula';
+import { ExternalReferenceModel } from './external-reference.model';
+export interface IExternalOverlayCellState {
+    covered: boolean;
+    value: unknown;
+}
+export declare class ExternalReferenceOverlayModel extends Disposable {
+    private readonly _externalReferenceModel;
+    private readonly _superTableService;
+    private readonly _units;
+    private readonly _pendingDirtyRanges;
+    constructor(_externalReferenceModel: ExternalReferenceModel, _superTableService: ISuperTableService);
+    apply(request: IFormulaReferenceDataRequest, response: IFormulaReferenceDataResponse): Array<{
+        sheetId: string;
+        range: IRange;
+    }>;
+    materialize(config: IFormulaDatasetConfig): void;
+    getCellState(unitId: string, sheetId: string, row: number, column: number): IExternalOverlayCellState;
+    isRangeCovered(unitId: string, sheetNameOrId: string | undefined, range: IRange): boolean;
+    enforceLimits(maxCells: number, maxBytes: number): number;
+    invalidateHost(hostUnitId: string): IUnitRange[];
+    invalidateSyntheticUnit(unitId: string): IUnitRange[];
+    invalidateSourceRange(targetUnitIdOrName: string, sheetNameOrId: string, range: IRange): IUnitRange[];
+    invalidateSourceMetadata(targetUnitIdOrName: string): IUnitRange[];
+    drainDirtyRanges(): IUnitRange[];
+    getUnitCount(): number;
+    dispose(): void;
+    private _unitRanges;
+    private _queueDirty;
+    private _mergeSheet;
+    private _oldestCoverage;
+    private _coveredCellCount;
+    private _estimatedBytes;
+    private _writeCoverageMisses;
+    private _createUnavailableSheets;
+    private _registerTables;
+}

package/lib/types/models/external-reference.model.d.ts

@@ -0,0 +1,91 @@
+import type { FormulaUnitType } from '@univerjs/engine-formula';
+import { Disposable } from '@univerjs/core';
+export declare const SHEET_EXTERNAL_DATA_PLUGIN = "SHEET_EXTERNAL_DATA_PLUGIN";
+export declare const EXTERNAL_REFERENCE_SCHEMA_VERSION: 1;
+export interface IExternalReferenceCoverage {
+    startRow: number;
+    endRow: number;
+    startColumn: number;
+    endColumn: number;
+}
+export interface IExternalReferenceCachedCell {
+    row: number;
+    column: number;
+    value: unknown;
+    valueType?: number;
+}
+export interface IExternalReferenceCachedSheet {
+    name: string;
+    sheetId?: string;
+    rowCount?: number;
+    columnCount?: number;
+    coverage: IExternalReferenceCoverage[];
+    cells: IExternalReferenceCachedCell[];
+}
+export interface IExternalReferenceTableColumn {
+    id?: string;
+    name: string;
+}
+export interface IExternalReferenceTable {
+    id?: string;
+    name: string;
+    sheetName?: string;
+    columns: IExternalReferenceTableColumn[];
+    range?: IExternalReferenceCoverage;
+    /** Base virtual tables start with records at row 0; Sheet tables default to a physical header. */
+    showHeader?: boolean;
+}
+export interface IExternalReferenceLink {
+    /** Host-local OOXML slot. Slots are one-based and order is preserved. */
+    slot: number;
+    name: string;
+    target: {
+        name: string;
+        unitType: FormulaUnitType;
+        uri?: string;
+        liveUnitId?: string;
+    };
+    sheetNames: Array<{
+        name: string;
+        sheetId?: string;
+    }>;
+    definedNames: Array<{
+        name: string;
+        formulaOrRefString: string;
+    }>;
+    tables: IExternalReferenceTable[];
+    cache?: {
+        revision?: string;
+        freshness: 'fresh' | 'stale';
+        complete: boolean;
+        sheets: IExternalReferenceCachedSheet[];
+    };
+}
+export interface IExternalReferenceResource {
+    schemaVersion: typeof EXTERNAL_REFERENCE_SCHEMA_VERSION;
+    links: IExternalReferenceLink[];
+}
+export type ExternalReferenceBindingResult = {
+    status: 'resolved';
+    link: IExternalReferenceLink;
+} | {
+    status: 'missing' | 'ambiguous';
+};
+export declare function createEmptyExternalReferenceResource(): IExternalReferenceResource;
+export declare function createExternalSyntheticUnitId(hostUnitId: string, slot: number): string;
+export declare class ExternalReferenceModel extends Disposable {
+    private readonly _resources;
+    private readonly _loadErrors;
+    load(hostUnitId: string, value: unknown): boolean;
+    set(hostUnitId: string, resource: IExternalReferenceResource): boolean;
+    serialize(hostUnitId: string): IExternalReferenceResource;
+    get(hostUnitId: string): IExternalReferenceResource | undefined;
+    getLoadError(hostUnitId: string): 'invalid-resource' | 'unsupported-version' | undefined;
+    resolveBinding(hostUnitId: string, qualifier: string): ExternalReferenceBindingResult;
+    renameLiveTarget(unitId: string, oldName: string, newName: string): Array<{
+        hostUnitId: string;
+        slot: number;
+    }>;
+    remove(hostUnitId: string): void;
+    dispose(): void;
+}

package/lib/types/plugin.d.ts

@@ -1,6 +1,14 @@
+import type { Dependency } from '@univerjs/core';
 import { UniverFormulaEnginePlugin } from '@univerjs/engine-formula';
 export declare class UniverProFormulaEnginePlugin extends UniverFormulaEnginePlugin {
     static packageName: string;
     static version: string;
+    /**
+     * Allows execution backends to replace individual formula services before
+     * they are registered. Keeping one registration pass avoids duplicate DI
+     * bindings when a backend only swaps the calculator.
+     */
+    protected _extendFormulaExecutionDependencies(_dependencies: Dependency[]): void;
     protected _initializeWithOverride(): void;
+    onReady(): void;
 }

package/lib/types/services/calculate-formula.service.d.ts

@@ -1,12 +1,22 @@
 import type { IFormulaDatasetConfig } from '@univerjs/engine-formula';
 import type { CalcNodeIndex, DynamicResolver, ICalculationOrderResult } from '../engine/dependency-engine/types';
 import type { IFormulaCalculationTree } from '../engine/formula-dependency';
-import { CalculateFormulaService } from '@univerjs/engine-formula';
+import { IConfigService } from '@univerjs/core';
+import { AstTreeBuilder, CalculateFormulaService, IFormulaCurrentConfigService, IFormulaDependencyGenerator, IFormulaRuntimeService, Interpreter, Lexer } from '@univerjs/engine-formula';
+import { ExternalReferencePrefetchPlanner } from './external-reference-prefetch-planner';
+import { ExternalReferencePrefetchService } from './external-reference-prefetch.service';
 export declare class CalculateFormulaProService extends CalculateFormulaService {
+    private readonly _externalPrefetchPlanner;
+    private readonly _externalPrefetchService;
     private _dynamicRuntimeRanges;
+    private _externalFormulaDatasetConfig;
+    private _externalPrefetchedNodes;
+    constructor(configService: IConfigService, lexer: Lexer, currentConfigService: IFormulaCurrentConfigService, runtimeService: IFormulaRuntimeService, formulaDependencyGenerator: IFormulaDependencyGenerator, interpreter: Interpreter, astTreeBuilder: AstTreeBuilder, _externalPrefetchPlanner: ExternalReferencePrefetchPlanner, _externalPrefetchService: ExternalReferencePrefetchService);
     execute(formulaDatasetConfig: IFormulaDatasetConfig): Promise<void>;
     protected _executeStep(cycleReferenceCount?: number): Promise<true | undefined>;
     protected _apply(isArrayFormulaState?: boolean, cycleReferenceCount?: number): Promise<import("@univerjs/engine-formula").IAllRuntimeData | undefined>;
+    private _setFormulaExecuteStage;
+    private _setTotalFormulasToCalculate;
     private _shouldRescheduleAfterDynamicChange;
     protected _forEachCalculationPlanTree(calculationOrderResult: Pick<ICalculationOrderResult, 'calculationForest'>, dependencyTree: Map<CalcNodeIndex, IFormulaCalculationTree>, cycleReferenceCount: number, visitor: (tree: IFormulaCalculationTree, nodeIndex: CalcNodeIndex, cycleIndex?: number, shouldPreserveCycleTree?: boolean) => Promise<boolean | void>): Promise<void>;
     private _calculationPlanHasSelfReference;
@@ -18,6 +28,8 @@ export declare class CalculateFormulaProService extends CalculateFormulaService
     private _getRangeSignature;
     private _waitForExecutionSlot;
     private _calculateDependencyTree;
+    private _prefetchDynamicExternalReferences;
+    private _collectAddressFunctionRuntimeReferences;
     private _setFunctionRefInfoForTree;
     private _formulaReferencesTreeCell;
     private _isReferenceMetadataFunctionArgument;

package/lib/types/services/external-cache-reference-data.provider.d.ts

@@ -0,0 +1,10 @@
+import type { IFormulaReferenceDataProvider, IFormulaReferenceDataRequest, IFormulaReferenceDataResponse } from './formula-reference-data.service';
+import { ExternalReferenceModel } from '../models/external-reference.model';
+export declare class ExternalCacheReferenceDataProvider implements IFormulaReferenceDataProvider {
+    private readonly _externalReferenceModel;
+    readonly id = "ooxml-external-cache";
+    readonly priority = -100;
+    constructor(_externalReferenceModel: ExternalReferenceModel);
+    canRead(request: IFormulaReferenceDataRequest): boolean;
+    readData(request: IFormulaReferenceDataRequest): Promise<IFormulaReferenceDataResponse | undefined>;
+}

package/lib/types/services/external-reference-prefetch-planner.d.ts

@@ -0,0 +1,18 @@
+import type { IFormulaDatasetConfig } from '@univerjs/engine-formula';
+import type { IFormulaReferenceDataRangeRequest, IFormulaReferenceDataRequest } from './formula-reference-data.service';
+import { ExternalReferenceModel } from '../models/external-reference.model';
+export declare class ExternalReferencePrefetchPlanner {
+    private readonly _externalReferenceModel;
+    private _calculationCounter;
+    private _requestCounter;
+    constructor(_externalReferenceModel: ExternalReferenceModel);
+    plan(config: IFormulaDatasetConfig): IFormulaReferenceDataRequest[];
+    planDynamic(hostUnitId: string, references: Array<{
+        unitId: string;
+        sheetName: string;
+        range: IFormulaReferenceDataRangeRequest['range'];
+    }>): IFormulaReferenceDataRequest[];
+    private _collectA1;
+    private _collectTables;
+    private _addRange;
+}

package/lib/types/services/external-reference-prefetch.service.d.ts

@@ -0,0 +1,38 @@
+import type { IUnitRange } from '@univerjs/core';
+import type { IFormulaDatasetConfig } from '@univerjs/engine-formula';
+import type { IFormulaReferenceDataRequest, IFormulaReferenceDataResponse } from './formula-reference-data.service';
+import { Disposable } from '@univerjs/core';
+import { FormulaDataModel } from '@univerjs/engine-formula';
+import { ExternalReferenceOverlayModel } from '../models/external-reference-overlay.model';
+import { IFormulaReferenceDataService } from './formula-reference-data.service';
+export interface IExternalReferencePrefetchLimits {
+    maxCells: number;
+    maxBytes: number;
+    concurrency: number;
+    timeoutMs: number;
+}
+export interface IExternalReferencePrefetchResult {
+    responses: IFormulaReferenceDataResponse[];
+    dirtyRanges: Array<{
+        unitId: string;
+        sheetId: string;
+        range: NonNullable<IFormulaReferenceDataRequest['ranges'][number]['range']>;
+    }>;
+    discarded: number;
+}
+export declare class ExternalReferencePrefetchService extends Disposable {
+    private readonly _referenceDataService;
+    private readonly _overlayModel;
+    private readonly _formulaDataModel;
+    private readonly _inflight;
+    private readonly _latestCalculation;
+    constructor(_referenceDataService: IFormulaReferenceDataService, _overlayModel: ExternalReferenceOverlayModel, _formulaDataModel: FormulaDataModel);
+    prefetch(requests: IFormulaReferenceDataRequest[], config: IFormulaDatasetConfig, limits?: Partial<IExternalReferencePrefetchLimits>): Promise<IExternalReferencePrefetchResult>;
+    cancelHost(hostUnitId: string, nextCalculationId: string): void;
+    getInflightCount(): number;
+    drainDirtyRanges(): IUnitRange[];
+    dispose(): void;
+    private _hydrateLiveUnits;
+    private _hasWorkerLiveUnit;
+    private _readWithInflight;
+}

package/lib/types/services/external-unit-reference-resolver.service.d.ts

@@ -0,0 +1,8 @@
+import type { IFormulaUnitReferenceResolution, IFormulaUnitReferenceResolveInput } from '@univerjs/engine-formula';
+import { ErrorType, FormulaUnitReferenceResolver, IFormulaCurrentConfigService } from '@univerjs/engine-formula';
+import { ExternalReferenceModel } from '../models/external-reference.model';
+export declare class ExternalFormulaUnitReferenceResolver extends FormulaUnitReferenceResolver {
+    private readonly _externalReferenceModel;
+    constructor(currentConfigService: IFormulaCurrentConfigService, _externalReferenceModel: ExternalReferenceModel);
+    resolve(input: IFormulaUnitReferenceResolveInput): IFormulaUnitReferenceResolution | ErrorType;
+}

package/lib/types/services/formula-reference-data.service.d.ts

@@ -0,0 +1,71 @@
+import type { ICellData, IDisposable, IRange } from '@univerjs/core';
+import type { FormulaUnitType } from '@univerjs/engine-formula';
+import { Disposable } from '@univerjs/core';
+export type FormulaReferenceDataSource = 'worker-live' | 'main-live' | 'provider' | 'ooxml-cache' | 'unavailable';
+export type FormulaReferenceDataFreshness = 'fresh' | 'stale' | 'unavailable';
+export interface IFormulaReferenceDataRangeRequest {
+    sheetName?: string;
+    sheetId?: string;
+    tableName?: string;
+    range?: IRange;
+}
+export interface IFormulaReferenceDataRequest {
+    requestId: string;
+    calculationId: string;
+    hostUnitId: string;
+    bindingSlot: number;
+    syntheticUnitId: string;
+    target: {
+        name: string;
+        unitType: FormulaUnitType;
+        uri?: string;
+        liveUnitId?: string;
+    };
+    ranges: IFormulaReferenceDataRangeRequest[];
+    /** Defaults to true. Set false only when the caller explicitly accepts cached stale values. */
+    requireFresh?: boolean;
+}
+export interface IFormulaReferenceDataCell {
+    row: number;
+    column: number;
+    cell: ICellData;
+}
+export interface IFormulaReferenceDataSheet {
+    name: string;
+    sheetId: string;
+    rowCount: number;
+    columnCount: number;
+    coverage: IRange[];
+    cells: IFormulaReferenceDataCell[];
+}
+export interface IFormulaReferenceDataResponse {
+    requestId: string;
+    calculationId: string;
+    source: FormulaReferenceDataSource;
+    freshness: FormulaReferenceDataFreshness;
+    revision?: string;
+    sheets: IFormulaReferenceDataSheet[];
+    error?: '#N/A' | '#REF!' | '#CYCLE!';
+}
+export interface IFormulaReferenceDataService {
+    readData(request: IFormulaReferenceDataRequest): Promise<IFormulaReferenceDataResponse>;
+}
+export declare const IFormulaReferenceDataService: import("@wendellhu/redi").IdentifierDecorator<IFormulaReferenceDataService>;
+export interface IFormulaReferenceDataProvider {
+    readonly id: string;
+    readonly priority?: number;
+    canRead(request: IFormulaReferenceDataRequest): boolean;
+    readData(request: IFormulaReferenceDataRequest): Promise<IFormulaReferenceDataResponse | undefined>;
+}
+export interface IFormulaReferenceDataProviderRegistry {
+    register(provider: IFormulaReferenceDataProvider): IDisposable;
+    getProviders(request: IFormulaReferenceDataRequest): IFormulaReferenceDataProvider[];
+}
+export declare const IFormulaReferenceDataProviderRegistry: import("@wendellhu/redi").IdentifierDecorator<IFormulaReferenceDataProviderRegistry>;
+export declare class FormulaReferenceDataProviderRegistry extends Disposable implements IFormulaReferenceDataProviderRegistry {
+    private readonly _providers;
+    register(provider: IFormulaReferenceDataProvider): IDisposable;
+    getProviders(request: IFormulaReferenceDataRequest): IFormulaReferenceDataProvider[];
+    dispose(): void;
+}
+export declare function createUnavailableReferenceDataResponse(request: IFormulaReferenceDataRequest, error?: '#N/A' | '#REF!' | '#CYCLE!'): IFormulaReferenceDataResponse;

package/lib/types/services/main-formula-reference-data.service.d.ts

@@ -0,0 +1,12 @@
+import type { IFormulaReferenceDataRequest, IFormulaReferenceDataResponse, IFormulaReferenceDataService } from './formula-reference-data.service';
+import { FormulaDataModel, ISuperTableService } from '@univerjs/engine-formula';
+import { IFormulaReferenceDataProviderRegistry } from './formula-reference-data.service';
+export declare class MainFormulaReferenceDataService implements IFormulaReferenceDataService {
+    private readonly _formulaDataModel;
+    private readonly _superTableService;
+    private readonly _providerRegistry;
+    constructor(_formulaDataModel: FormulaDataModel, _superTableService: ISuperTableService, _providerRegistry: IFormulaReferenceDataProviderRegistry);
+    readData(request: IFormulaReferenceDataRequest): Promise<IFormulaReferenceDataResponse>;
+    private _readLiveSheets;
+    private _resolveLiveRange;
+}

package/lib/umd/facade.js

@@ -1 +1 @@
-function _0x4c13(_0x6ab70f,_0x6f80dd){_0x6ab70f=_0x6ab70f-0xcf;var _0x532531=_0x5325();var _0x4c139d=_0x532531[_0x6ab70f];return _0x4c139d;}function _0x5325(){var _0x4675ce=['14216CSIwBJ','exports','object','function','414Yknbbc','UniverEngineFormulaFacade','defineProperty','66VDWCuG','1555449nhuZhk','toStringTag','10077561ztnGVl','FFormula','314heBcbt','4742rHNCIC','31926984RKlZty','288235vKSKrh','90jIQwXP','@univerjs/engine-formula/facade','16vKwOTW','Module','1545247BHFhPa'];_0x5325=function(){return _0x4675ce;};return _0x5325();}(function(_0x325504,_0x3467cf){var _0x44b044=_0x4c13,_0x3e930b=_0x325504();while(!![]){try{var _0x74adb0=-parseInt(_0x44b044(0xe1))/0x1*(-parseInt(_0x44b044(0xe2))/0x2)+-parseInt(_0x44b044(0xd9))/0x3*(-parseInt(_0x44b044(0xd5))/0x4)+-parseInt(_0x44b044(0xcf))/0x5*(parseInt(_0x44b044(0xdc))/0x6)+parseInt(_0x44b044(0xdd))/0x7*(parseInt(_0x44b044(0xd2))/0x8)+parseInt(_0x44b044(0xdf))/0x9+-parseInt(_0x44b044(0xd0))/0xa*(-parseInt(_0x44b044(0xd4))/0xb)+-parseInt(_0x44b044(0xe3))/0xc;if(_0x74adb0===_0x3467cf)break;else _0x3e930b['push'](_0x3e930b['shift']());}catch(_0x201788){_0x3e930b['push'](_0x3e930b['shift']());}}}(_0x5325,0xbbaab),function(_0x2f19de,_0xfa9cd5){var _0x46c9a8=_0x4c13;typeof exports==_0x46c9a8(0xd7)&&typeof module<'u'?_0xfa9cd5(exports,require('@univerjs/engine-formula/facade')):typeof define==_0x46c9a8(0xd8)&&define['amd']?define([_0x46c9a8(0xd6),_0x46c9a8(0xd1)],_0xfa9cd5):(_0x2f19de=typeof globalThis<'u'?globalThis:_0x2f19de||self,_0xfa9cd5(_0x2f19de['UniverProEngineFormulaFacade']={},_0x2f19de[_0x46c9a8(0xda)]));}(this,function(_0x517bca,_0x379bfb){var _0x337f15=_0x4c13;Object[_0x337f15(0xdb)](_0x517bca,Symbol[_0x337f15(0xde)],{'value':_0x337f15(0xd3)}),Object[_0x337f15(0xdb)](_0x517bca,_0x337f15(0xe0),{'enumerable':!0x0,'get':function(){return _0x379bfb['FFormula'];}});}));
+(function(_0x30d002,_0x1c7b8b){var _0x4a4ad8=_0x6e44,_0x296f80=_0x30d002();while(!![]){try{var _0xf5e00e=-parseInt(_0x4a4ad8(0x1e3))/0x1*(parseInt(_0x4a4ad8(0x1e5))/0x2)+-parseInt(_0x4a4ad8(0x1ea))/0x3+-parseInt(_0x4a4ad8(0x1e6))/0x4+-parseInt(_0x4a4ad8(0x1e7))/0x5+parseInt(_0x4a4ad8(0x1e1))/0x6+-parseInt(_0x4a4ad8(0x1e2))/0x7+parseInt(_0x4a4ad8(0x1ec))/0x8;if(_0xf5e00e===_0x1c7b8b)break;else _0x296f80['push'](_0x296f80['shift']());}catch(_0x10d9ff){_0x296f80['push'](_0x296f80['shift']());}}}(_0xd1dd,0xa8f2d),function(_0x27da3d,_0x5d4420){var _0x5f4928=_0x6e44;typeof exports=='object'&&typeof module<'u'?_0x5d4420(exports,require('@univerjs/engine-formula/facade')):typeof define=='function'&&define['amd']?define(['exports','@univerjs/engine-formula/facade'],_0x5d4420):(_0x27da3d=typeof globalThis<'u'?globalThis:_0x27da3d||self,_0x5d4420(_0x27da3d['UniverProEngineFormulaFacade']={},_0x27da3d[_0x5f4928(0x1e4)]));}(this,function(_0x1f2103,_0xebe3c1){var _0x8b67fa=_0x6e44;Object[_0x8b67fa(0x1e8)](_0x1f2103,Symbol[_0x8b67fa(0x1e0)],{'value':_0x8b67fa(0x1eb)}),Object[_0x8b67fa(0x1e8)](_0x1f2103,_0x8b67fa(0x1e9),{'enumerable':!0x0,'get':function(){var _0x3e5faa=_0x8b67fa;return _0xebe3c1[_0x3e5faa(0x1e9)];}});}));function _0x6e44(_0x55216e,_0x33ca1b){_0x55216e=_0x55216e-0x1e0;var _0xd1dd60=_0xd1dd();var _0x6e444a=_0xd1dd60[_0x55216e];return _0x6e444a;}function _0xd1dd(){var _0x540c1c=['8381198wJUsGM','69583ywNHdH','UniverEngineFormulaFacade','32iTFTTc','4135028dTVsVo','6286820LzVkIY','defineProperty','FFormula','2264994mAcQEQ','Module','37601096teeTQJ','toStringTag','8091822krKGqk'];_0xd1dd=function(){return _0x540c1c;};return _0xd1dd();}