@univerjs-pro/engine-formula 1.0.0-alpha.7 → 1.0.0-alpha.8

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

@@ -0,0 +1,61 @@
+import type { FormulaUnitType } from '@univerjs/engine-formula';
+import { Disposable } from '@univerjs/core';
+/**
+ * Snapshot resource key shared by Sheet, Document, Slide, Board, and Base Hosts.
+ * The resource stores identity mappings only; it never stores Source formula data.
+ */
+export declare const UNIVER_EXTERNAL_REFERENCE_PLUGIN = "UNIVER_EXTERNAL_REFERENCE_PLUGIN";
+export declare const HOST_EXTERNAL_REFERENCE_SCHEMA_VERSION: 1;
+/** One Host-owned mapping from a public formula qualifier to a stable Source Unit. */
+export interface IHostExternalReference {
+    /** Source name used in formula text, without brackets or quotes. */
+    qualifier: string;
+    /** Stable Source Unit ID used for external data reads. */
+    sourceUnitId: string;
+    /** Sheet or Base Source type. */
+    sourceUnitType: FormulaUnitType;
+}
+/**
+ * Value persisted under {@link UNIVER_EXTERNAL_REFERENCE_PLUGIN}.
+ *
+ * `references` is keyed by an opaque Host-local reference ID. Callers should use
+ * Facade/command APIs for runtime writes instead of constructing those IDs.
+ */
+export interface IHostExternalReferenceResource {
+    schemaVersion: typeof HOST_EXTERNAL_REFERENCE_SCHEMA_VERSION;
+    references: Record<string, IHostExternalReference>;
+}
+export type HostExternalReferenceBindingResult = {
+    status: 'resolved';
+    referenceId: string;
+    reference: IHostExternalReference;
+} | {
+    status: 'missing' | 'ambiguous';
+};
+export type HostExternalReferenceLoadError = 'invalid-resource' | 'unsupported-version';
+export declare function createEmptyHostExternalReferenceResource(): IHostExternalReferenceResource;
+export declare function isReservedExternalReferenceQualifier(qualifier: string): boolean;
+export declare function normalizeHostExternalReferenceQualifier(qualifier: string): string;
+export declare function isHostExternalReference(value: unknown): value is IHostExternalReference;
+export declare class HostExternalReferenceModel extends Disposable {
+    private readonly _resources;
+    private readonly _rawResources;
+    private readonly _loadErrors;
+    private readonly _revisions;
+    load(hostUnitId: string, value: unknown): boolean;
+    set(hostUnitId: string, resource: IHostExternalReferenceResource): boolean;
+    serialize(hostUnitId: string): unknown;
+    get(hostUnitId: string): IHostExternalReferenceResource | undefined;
+    getAll(): Record<string, IHostExternalReferenceResource>;
+    getLoadError(hostUnitId: string): HostExternalReferenceLoadError | undefined;
+    /**
+     * Runtime revision used by derived Formula cache compare-and-set mutations.
+     * It is intentionally not serialized into the Host resource.
+     */
+    getRevision(hostUnitId: string): number;
+    resolveBinding(hostUnitId: string, qualifier: string): HostExternalReferenceBindingResult;
+    remove(hostUnitId: string): void;
+    dispose(): void;
+    private _preserveInvalid;
+    private _bumpRevision;
+}

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

@@ -1,17 +1,13 @@
 import type { IFormulaDatasetConfig } from '@univerjs/engine-formula';
-import type { CalcNodeIndex, DynamicResolver, ICalculationOrderResult } from '../engine/dependency-engine/types';
+import type { CalcNodeIndex, ICalculationOrderResult, IDynamicResolver } from '../engine/dependency-engine/types';
 import type { IFormulaCalculationTree } from '../engine/formula-dependency';
 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';
+import { AstTreeBuilder, CalculateFormulaService, IFormulaCurrentConfigService, IFormulaDependencyGenerator, IFormulaExternalReferenceDataLoader, IFormulaRuntimeService, Interpreter, Lexer } from '@univerjs/engine-formula';
 export declare class CalculateFormulaProService extends CalculateFormulaService {
-    private readonly _externalPrefetchPlanner;
-    private readonly _externalPrefetchService;
+    private readonly _externalReferenceDataLoader;
     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);
+    private _runtimeExternalDataLoaded;
+    constructor(configService: IConfigService, lexer: Lexer, currentConfigService: IFormulaCurrentConfigService, runtimeService: IFormulaRuntimeService, formulaDependencyGenerator: IFormulaDependencyGenerator, interpreter: Interpreter, astTreeBuilder: AstTreeBuilder, _externalReferenceDataLoader: IFormulaExternalReferenceDataLoader);
     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>;
@@ -21,15 +17,13 @@ export declare class CalculateFormulaProService extends CalculateFormulaService
     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;
     protected _getCalculationPlanTreeCount(calculationOrderResult: Pick<ICalculationOrderResult, 'calculationForest'>, dependencyTree: Map<CalcNodeIndex, IFormulaCalculationTree>, cycleReferenceCount: number): number;
-    protected _getDynamicResolver(): DynamicResolver | undefined;
+    protected _getDynamicResolver(): IDynamicResolver | undefined;
     private _refreshDynamicDepsAfterCalculate;
-    private _collectAddressFunctionRuntimeRanges;
-    private _collectAddressFunctionRuntimeRangesInternal;
+    private _collectAddressFunctionRuntimeReferences;
+    private _collectAddressFunctionRuntimeReferencesInternal;
     private _getRangeSignature;
     private _waitForExecutionSlot;
     private _calculateDependencyTree;
-    private _prefetchDynamicExternalReferences;
-    private _collectAddressFunctionRuntimeReferences;
     private _setFunctionRefInfoForTree;
     private _formulaReferencesTreeCell;
     private _isReferenceMetadataFunctionArgument;

package/lib/types/services/dependency-manager.service.d.ts

@@ -1,6 +1,6 @@
 import type { IUnitRange } from '@univerjs/core';
 import type { FormulaDependencyTree, IDirtyUnitFeatureMap, IDirtyUnitOtherFormulaMap, IDirtyUnitSheetNameMap, IFormulaDependencyTree } from '@univerjs/engine-formula';
-import type { DynamicResolver, ICalcNodeRef, ICompressedSharedFormulaGroup } from '../engine/dependency-engine/types';
+import type { ICalcNodeRef, ICompressedSharedFormulaGroup, IDynamicResolver } from '../engine/dependency-engine/types';
 import { DependencyManagerBaseService } from '@univerjs/engine-formula';
 export declare class DependencyManagerProService extends DependencyManagerBaseService {
     private _dependencyEngineCache;
@@ -42,12 +42,12 @@ export declare class DependencyManagerProService extends DependencyManagerBaseSe
     clearCalculatedDirty(indices: number[]): void;
     hasDynamicDeps(node: ICalcNodeRef): boolean;
     hasDynamicDepsByIndex(nodeIndex: number): boolean;
-    refreshDynamicDeps(node: ICalcNodeRef, resolver: DynamicResolver): boolean;
-    refreshDynamicDepsByIndex(nodeIndex: number, resolver: DynamicResolver): boolean;
+    refreshDynamicDeps(node: ICalcNodeRef, resolver: IDynamicResolver): boolean;
+    refreshDynamicDepsByIndex(nodeIndex: number, resolver: IDynamicResolver): boolean;
     hasUncalculatedDirtyPrecedentByIndex(nodeIndex: number, calculatedNodeIndices: ReadonlySet<number>): boolean;
     forEachPrecedentNodeByIndex(nodeIndex: number, cb: (precedentNodeIndex: number) => void): void;
     forEachDependentNodeByIndex(nodeIndex: number, cb: (dependentNodeIndex: number) => void): void;
-    prepareDynamicDependencies(resolver: DynamicResolver): boolean;
+    prepareDynamicDependencies(resolver: IDynamicResolver): boolean;
     getCalculationOrder(options?: {
         detectCycles?: boolean;
     }): import("../engine/dependency-engine/types").ICalculationOrderResult;

package/lib/types/services/formula-cache-eligibility.service.d.ts

@@ -0,0 +1,18 @@
+import type { IOtherFormulaResult } from '@univerjs/engine-formula';
+import { LexerTreeBuilder } from '@univerjs/engine-formula';
+export type FormulaCacheIneligibleReason = 'not-successful' | 'volatile';
+export interface IFormulaCacheEligibility {
+    eligible: boolean;
+    reason?: FormulaCacheIneligibleReason;
+}
+/**
+ * Central Formula-engine authority for last-value cache eligibility.
+ *
+ * Volatility is derived from parsed Formula nodes, never function-name substrings
+ * or rendered error text. Availability is represented by the structured result status.
+ */
+export declare class FormulaCacheEligibilityService {
+    private readonly _lexerTreeBuilder;
+    constructor(_lexerTreeBuilder: LexerTreeBuilder);
+    assess(formula: string, result: IOtherFormulaResult | undefined): IFormulaCacheEligibility;
+}

package/lib/types/services/formula-last-value-persistence.service.d.ts

@@ -0,0 +1,18 @@
+import type { IDisposable, IMutationInfo } from '@univerjs/core';
+import { Disposable } from '@univerjs/core';
+/**
+ * A Formula host contributes compare-and-set mutations for successful scalar results.
+ *
+ * Providers omit unavailable, failed, non-scalar, and volatile results. Every returned
+ * mutation revalidates its captured Formula source before writing, so a late result cannot
+ * overwrite a newer edit.
+ */
+export interface IFormulaLastValuePersistenceProvider {
+    collectMutations(sessionId: number): readonly IMutationInfo[];
+}
+export declare class FormulaLastValuePersistenceService extends Disposable {
+    private readonly _providers;
+    registerProvider(provider: IFormulaLastValuePersistenceProvider): IDisposable;
+    collectMutations(sessionId: number): IMutationInfo[];
+    dispose(): void;
+}

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

@@ -13,11 +13,13 @@ export interface IFormulaReferenceDataRequest {
     requestId: string;
     calculationId: string;
     hostUnitId: string;
-    bindingSlot: number;
+    bindingSlot?: number;
+    referenceId?: string;
     syntheticUnitId: string;
     target: {
         name: string;
         unitType: FormulaUnitType;
+        sourceUnitId?: string;
         uri?: string;
         liveUnitId?: string;
     };
@@ -38,6 +40,13 @@ export interface IFormulaReferenceDataSheet {
     coverage: IRange[];
     cells: IFormulaReferenceDataCell[];
 }
+export interface IFormulaReferenceDataTable {
+    name: string;
+    sheetId: string;
+    range: IRange;
+    columns: string[];
+    showHeader?: boolean;
+}
 export interface IFormulaReferenceDataResponse {
     requestId: string;
     calculationId: string;
@@ -45,6 +54,7 @@ export interface IFormulaReferenceDataResponse {
     freshness: FormulaReferenceDataFreshness;
     revision?: string;
     sheets: IFormulaReferenceDataSheet[];
+    tables?: IFormulaReferenceDataTable[];
     error?: '#N/A' | '#REF!' | '#CYCLE!';
 }
 export interface IFormulaReferenceDataService {

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

@@ -1,43 +1,103 @@
 import type { IRange } from '@univerjs/core';
-/** The kind of reference text produced by {@link buildFormulaReference}. */
+/** Reference syntax produced by {@link buildFormulaReference} and `FFormula.buildReference()`. */
 export declare enum FormulaReferenceType {
+    /** A worksheet A1 range such as `Sheet1!A1:B10` or `'[Sales]Data'!A1:B10`. */
     SHEET_RANGE = "sheet-range",
+    /** A Base structured reference such as `Orders[Amount]` or `[Sales]!Orders[Amount]`. */
     TABLE_COLUMN = "table-column"
 }
-/** Explicit Unit identity supplied by the caller when serializing a formula reference. */
+/**
+ * Explicit Unit identity supplied by the caller when serializing a formula reference.
+ * Always use the stable Unit ID; never infer it from `formulaQualifier`.
+ */
 export interface IFormulaReferenceUnit {
-    /** Name written into a formula unit qualifier. */
+    /**
+     * Display name written into the formula qualifier. Supply the name only, without
+     * surrounding brackets or quotes; the builder applies formula escaping.
+     */
     formulaQualifier: string;
-    /** Stable Unit identifier used to detect a current-Unit reference. */
-    unitId?: string;
+    /**
+     * Stable Sheet or Base Unit ID. When it equals `hostUnitId`, the builder emits
+     * a Host-local reference; otherwise it emits a cross-Unit qualifier.
+     */
+    unitId: string;
 }
 /** Sheet-range reference target accepted by {@link buildFormulaReference}. */
 export interface IFormulaSheetRangeReferenceTarget {
     kind: FormulaReferenceType.SHEET_RANGE;
+    /** Source worksheet name, without formula quotes. */
     sheetName: string;
+    /** Zero-based inclusive source range. */
     range: IRange;
 }
 /** Base/structured-table reference target accepted by {@link buildFormulaReference}. */
 export interface IFormulaTableColumnReferenceTarget {
     kind: FormulaReferenceType.TABLE_COLUMN;
+    /** Source Base table name, without formula quotes. */
     tableName: string;
+    /** First source field name. */
     columnName: string;
     /** Optional final column for a contiguous structured-reference range. */
     endColumnName?: string;
 }
 /** A Sheet range or Base structured-reference target serialized by {@link buildFormulaReference}. */
 export type FormulaReferenceTarget = IFormulaSheetRangeReferenceTarget | IFormulaTableColumnReferenceTarget;
-/** Input used to serialize a formula reference fragment. */
+/**
+ * Input used to serialize one formula reference fragment.
+ *
+ * `hostUnitId === unit.unitId` produces Host-local syntax. Different IDs produce
+ * cross-Unit syntax using `unit.formulaQualifier`.
+ */
 export interface IBuildFormulaReferenceOptions {
-    /** Unit that owns the formula. */
+    /** Stable ID of the Unit that will own the formula. */
     hostUnitId: string;
-    /** Unit identity supplied explicitly by the caller. */
+    /** Stable identity and public qualifier of the referenced Sheet or Base Unit. */
     unit: IFormulaReferenceUnit;
     /** Sheet range or structured-table column to serialize. */
     target: FormulaReferenceTarget;
 }
 /**
- * Serializes a formula reference fragment without discovering, mutating, or loading a Unit.
- * The returned text does not include a leading `=` or a wrapping function.
+ * Purely serializes a Sheet-range or Base-table reference fragment.
+ *
+ * This low-level helper never persists a Host External Reference, loads a Unit, or
+ * starts calculation. Use `univerAPI.getFormula().buildReference()` for normal
+ * Facade authoring because that method also synchronizes cross-Unit bindings.
+ * The returned fragment has no leading `=` and is intended to be embedded in a
+ * complete formula.
+ *
+ * @example Serialize a Host-local Sheet range
+ * ```ts
+ * const reference = buildFormulaReference({
+ *     hostUnitId: 'host-workbook',
+ *     unit: {
+ *         unitId: 'host-workbook',
+ *         formulaQualifier: 'Host Workbook',
+ *     },
+ *     target: {
+ *         kind: FormulaReferenceType.SHEET_RANGE,
+ *         sheetName: 'Data',
+ *         range: { startRow: 0, endRow: 9, startColumn: 1, endColumn: 1 },
+ *     },
+ * });
+ * // reference === 'Data!B1:B10'
+ * ```
+ *
+ * @example Serialize a cross-Unit Base column
+ * ```ts
+ * const reference = buildFormulaReference({
+ *     hostUnitId: 'host-document',
+ *     unit: {
+ *         unitId: 'sales-base',
+ *         formulaQualifier: 'Sales Base',
+ *     },
+ *     target: {
+ *         kind: FormulaReferenceType.TABLE_COLUMN,
+ *         tableName: 'Orders',
+ *         columnName: 'Amount',
+ *     },
+ * });
+ * // reference === '[Sales Base]!Orders[Amount]'
+ * // The caller must persist the Host External Reference separately.
+ * ```
  */
 export declare function buildFormulaReference(options: IBuildFormulaReferenceOptions): string;

package/lib/types/services/formula-result-presentation.d.ts

@@ -0,0 +1,22 @@
+import type { ICellData } from '@univerjs/core';
+import type { IOtherFormulaResult } from '@univerjs/engine-formula';
+import type { IFormulaLastValue } from '../models/formula-last-value';
+export interface IFormulaResultPresentation {
+    text: string;
+    color?: string;
+    pattern: string;
+    cell?: ICellData;
+    source: 'persisted' | 'calculated';
+    stale: boolean;
+}
+export interface IResolveFormulaResultPresentationOptions {
+    numberFormat?: {
+        pattern: string;
+    };
+    lastValue?: IFormulaLastValue;
+    result?: IOtherFormulaResult;
+}
+export declare function resolveFormulaResultPresentation(options: IResolveFormulaResultPresentationOptions): IFormulaResultPresentation;
+export declare function getFormulaResultCell(result: IOtherFormulaResult | undefined): ICellData | undefined;
+export declare function getScalarFormulaResultCell(result: IOtherFormulaResult | undefined): ICellData | undefined;
+export declare function toFormulaLastValue(cell: ICellData): IFormulaLastValue | null;

package/lib/types/services/host-external-reference-data-loader.service.d.ts

@@ -0,0 +1,31 @@
+import type { IRange } from '@univerjs/core';
+import type { IFormulaExternalReferenceDataLoader, IFormulaExternalReferenceLoadInput } from '@univerjs/engine-formula';
+import { ErrorType, IFormulaCurrentConfigService, ISuperTableService } from '@univerjs/engine-formula';
+import { ExternalReferenceModel } from '../models/external-reference.model';
+import { IFormulaReferenceDataService } from './formula-reference-data.service';
+export declare class HostExternalReferenceDataLoader implements IFormulaExternalReferenceDataLoader {
+    private readonly _currentConfigService;
+    private readonly _referenceDataService;
+    private readonly _excelExternalReferenceModel;
+    private readonly _superTableService;
+    private _requestCounter;
+    private _generation;
+    private readonly _inflight;
+    private readonly _completed;
+    constructor(_currentConfigService: IFormulaCurrentConfigService, _referenceDataService: IFormulaReferenceDataService, _excelExternalReferenceModel: ExternalReferenceModel, _superTableService: ISuperTableService);
+    load(input: IFormulaExternalReferenceLoadInput): Promise<ErrorType | void>;
+    loadRuntimeRange(input: {
+        hostUnitId: string;
+        unitId: string;
+        sheetId: string;
+        sheetName?: string;
+        range: IRange;
+    }): Promise<ErrorType | boolean | void>;
+    private _resolveRuntimeRange;
+    private _runtimeRangeSheetName;
+    private _createRequest;
+    private _createA1RangeRequest;
+    private _loadRequest;
+    private _materialize;
+    private _materializeSheet;
+}

package/lib/types/services/host-formula-binding.service.d.ts

@@ -0,0 +1,15 @@
+import type { FormulaSequenceNode } from '@univerjs/engine-formula';
+import type { HostExternalReferenceBindingResult, IHostExternalReference } from '../models/host-external-reference.model';
+export type HostFormulaExternalReferenceResolution = {
+    status: 'resolved';
+    references: readonly IHostExternalReference[];
+} | {
+    status: 'missing' | 'ambiguous';
+    qualifier: string;
+};
+export declare function collectFormulaExternalReferenceQualifiers(sequenceNodes: FormulaSequenceNode[]): string[];
+export declare function resolveHostFormulaExternalReferences(options: {
+    qualifiers: readonly string[];
+    explicitReferences: readonly IHostExternalReference[];
+    resolveBinding: (qualifier: string) => HostExternalReferenceBindingResult;
+}): HostFormulaExternalReferenceResolution;

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

@@ -7,6 +7,7 @@ export declare class MainFormulaReferenceDataService implements IFormulaReferenc
     private readonly _providerRegistry;
     constructor(_formulaDataModel: FormulaDataModel, _superTableService: ISuperTableService, _providerRegistry: IFormulaReferenceDataProviderRegistry);
     readData(request: IFormulaReferenceDataRequest): Promise<IFormulaReferenceDataResponse>;
+    private _readLiveTables;
     private _readLiveSheets;
     private _resolveLiveRange;
 }

package/lib/umd/facade.js

@@ -1 +1 @@
-function _0x360e(_0x234ce7,_0x2ae612){_0x234ce7=_0x234ce7-0x174;var _0x59feb1=_0x59fe();var _0x360e2b=_0x59feb1[_0x234ce7];return _0x360e2b;}(function(_0x5c6164,_0x40bb74){var _0x5122ab=_0x360e,_0x1e6079=_0x5c6164();while(!![]){try{var _0x289760=parseInt(_0x5122ab(0x17a))/0x1*(parseInt(_0x5122ab(0x179))/0x2)+-parseInt(_0x5122ab(0x18c))/0x3*(-parseInt(_0x5122ab(0x183))/0x4)+-parseInt(_0x5122ab(0x182))/0x5*(-parseInt(_0x5122ab(0x187))/0x6)+parseInt(_0x5122ab(0x18a))/0x7+parseInt(_0x5122ab(0x176))/0x8+parseInt(_0x5122ab(0x175))/0x9*(-parseInt(_0x5122ab(0x17c))/0xa)+-parseInt(_0x5122ab(0x180))/0xb;if(_0x289760===_0x40bb74)break;else _0x1e6079['push'](_0x1e6079['shift']());}catch(_0xc3f200){_0x1e6079['push'](_0x1e6079['shift']());}}}(_0x59fe,0x985e0),function(_0x557913,_0x16f5d3){var _0x26273d=_0x360e;typeof exports==_0x26273d(0x18f)&&typeof module<'u'?_0x16f5d3(exports,require('@univerjs/engine-formula/facade'),require('@univerjs-pro/engine-formula'),require('@univerjs/core/facade')):typeof define==_0x26273d(0x186)&&define[_0x26273d(0x174)]?define([_0x26273d(0x188),'@univerjs/engine-formula/facade',_0x26273d(0x17f),_0x26273d(0x178)],_0x16f5d3):(_0x557913=typeof globalThis<'u'?globalThis:_0x557913||self,_0x16f5d3(_0x557913[_0x26273d(0x185)]={},_0x557913[_0x26273d(0x18d)],_0x557913[_0x26273d(0x177)],_0x557913[_0x26273d(0x18e)]));}(this,function(_0x40992c,_0x5d11bb,_0x370b12,_0x17a016){var _0x3ff4da=_0x360e;Object[_0x3ff4da(0x17e)](_0x40992c,Symbol[_0x3ff4da(0x17b)],{'value':_0x3ff4da(0x189)});var _0x5235e5=class extends _0x17a016[_0x3ff4da(0x181)]{get[_0x3ff4da(0x184)](){return _0x370b12['FormulaReferenceType'];}};_0x17a016[_0x3ff4da(0x181)]['extend'](_0x5235e5);var _0x2cebcb=class extends _0x5d11bb['FFormula']{[_0x3ff4da(0x17d)](_0x533eb6){return(0x0,_0x370b12['buildFormulaReference'])(_0x533eb6);}};_0x5d11bb['FFormula']['extend'](_0x2cebcb),Object[_0x3ff4da(0x17e)](_0x40992c,_0x3ff4da(0x18b),{'enumerable':!0x0,'get':function(){var _0x22a97e=_0x3ff4da;return _0x5d11bb[_0x22a97e(0x18b)];}});}));function _0x59fe(){var _0x887e35=['Module','6458144QOocmH','FFormula','51KyLhxT','UniverEngineFormulaFacade','UniverCoreFacade','object','amd','3576411jnpOKF','9319768vIRcNv','UniverProEngineFormula','@univerjs/core/facade','1439978XYSlxI','1ZXtbNY','toStringTag','30RmRCok','buildReference','defineProperty','@univerjs-pro/engine-formula','27556463jBYGdI','FEnum','1534325HxfwuH','283988NkoEyw','FormulaReferenceType','UniverProEngineFormulaFacade','function','6ekqkjF','exports'];_0x59fe=function(){return _0x887e35;};return _0x59fe();}
+(function(_0x2b4e62,_0x504782){var _0xff5d77=_0x579a,_0x237ec5=_0x2b4e62();while(!![]){try{var _0x389e22=-parseInt(_0xff5d77(0x1c9))/0x1+parseInt(_0xff5d77(0x1e0))/0x2*(parseInt(_0xff5d77(0x1ec))/0x3)+-parseInt(_0xff5d77(0x1dd))/0x4*(parseInt(_0xff5d77(0x1de))/0x5)+-parseInt(_0xff5d77(0x1e5))/0x6+parseInt(_0xff5d77(0x1cd))/0x7*(-parseInt(_0xff5d77(0x1cc))/0x8)+-parseInt(_0xff5d77(0x1ca))/0x9*(-parseInt(_0xff5d77(0x1ea))/0xa)+parseInt(_0xff5d77(0x1e3))/0xb;if(_0x389e22===_0x504782)break;else _0x237ec5['push'](_0x237ec5['shift']());}catch(_0x8448f6){_0x237ec5['push'](_0x237ec5['shift']());}}}(_0x148c,0x44240),function(_0x331042,_0x3f4d11){var _0x157715=_0x579a;typeof exports==_0x157715(0x1c6)&&typeof module<'u'?_0x3f4d11(exports,require('@univerjs/engine-formula/facade'),require('@univerjs-pro/engine-formula'),require('@univerjs/core/facade'),require('@univerjs/core')):typeof define==_0x157715(0x1dc)&&define['amd']?define([_0x157715(0x1e1),_0x157715(0x1e8),_0x157715(0x1c7),_0x157715(0x1d2),_0x157715(0x1db)],_0x3f4d11):(_0x331042=typeof globalThis<'u'?globalThis:_0x331042||self,_0x3f4d11(_0x331042['UniverProEngineFormulaFacade']={},_0x331042[_0x157715(0x1ce)],_0x331042[_0x157715(0x1df)],_0x331042[_0x157715(0x1cb)],_0x331042[_0x157715(0x1e4)]));}(this,function(_0xc7e3ad,_0x19e3dc,_0x1921b7,_0x3fab13,_0x5de9cf){var _0x59805f=_0x579a;Object[_0x59805f(0x1e6)](_0xc7e3ad,Symbol[_0x59805f(0x1e2)],{'value':'Module'});var _0x1f4e43=class extends _0x3fab13[_0x59805f(0x1eb)]{get['FormulaReferenceType'](){var _0x48c21d=_0x59805f;return _0x1921b7[_0x48c21d(0x1d4)];}};_0x3fab13[_0x59805f(0x1eb)]['extend'](_0x1f4e43);var _0x2b013c=class extends _0x19e3dc[_0x59805f(0x1e9)]{[_0x59805f(0x1d1)](_0x2e9086){var _0x337139=_0x59805f;let {hostUnitId:_0x2d1634,unit:_0x40ff1a,target:_0x445c3b}=_0x2e9086;if(!_0x2d1634||!_0x40ff1a[_0x337139(0x1c4)])throw Error('Formula\x20reference\x20authoring\x20requires\x20stable\x20Host\x20and\x20Source\x20Unit\x20IDs.');if(_0x40ff1a[_0x337139(0x1c4)]!==_0x2d1634&&!this[_0x337139(0x1c8)][_0x337139(0x1cf)](_0x1921b7[_0x337139(0x1d5)]['id'],{'unitId':_0x2d1634,'qualifier':_0x40ff1a[_0x337139(0x1d6)],'sourceUnitId':_0x40ff1a[_0x337139(0x1c4)],'sourceUnitType':_0x445c3b[_0x337139(0x1d8)]===_0x1921b7[_0x337139(0x1d4)][_0x337139(0x1d9)]?_0x5de9cf[_0x337139(0x1d0)][_0x337139(0x1d3)]:_0x5de9cf[_0x337139(0x1d0)]['UNIVER_BASE']}))throw Error('Failed\x20to\x20bind\x20external\x20formula\x20reference\x20\x22'+_0x40ff1a['formulaQualifier']+'\x22.');return(0x0,_0x1921b7[_0x337139(0x1da)])(_0x2e9086);}[_0x59805f(0x1c5)](_0x181d84){var _0x4dbf2d=_0x59805f;return this[_0x4dbf2d(0x1c8)]['syncExecuteCommand'](_0x1921b7[_0x4dbf2d(0x1d5)]['id'],_0x181d84);}[_0x59805f(0x1e7)](_0x3a6141){var _0x5b5391=_0x59805f;return this['_commandService'][_0x5b5391(0x1cf)](_0x1921b7[_0x5b5391(0x1d7)]['id'],_0x3a6141);}};_0x19e3dc[_0x59805f(0x1e9)]['extend'](_0x2b013c),Object[_0x59805f(0x1e6)](_0xc7e3ad,_0x59805f(0x1e9),{'enumerable':!0x0,'get':function(){var _0x175dc2=_0x59805f;return _0x19e3dc[_0x175dc2(0x1e9)];}});}));function _0x579a(_0x23a05e,_0xcbfb5a){_0x23a05e=_0x23a05e-0x1c4;var _0x148c22=_0x148c();var _0x579ab4=_0x148c22[_0x23a05e];return _0x579ab4;}function _0x148c(){var _0x37e7de=['479284usfwZn','27DqdcsX','UniverCoreFacade','1250168bmOOtL','21fXkheW','UniverEngineFormulaFacade','syncExecuteCommand','UniverInstanceType','buildReference','@univerjs/core/facade','UNIVER_SHEET','FormulaReferenceType','UpsertHostExternalReferenceCommand','formulaQualifier','RemoveHostExternalReferenceCommand','kind','SHEET_RANGE','buildFormulaReference','@univerjs/core','function','8848iadoWV','5cbLPem','UniverProEngineFormula','6OFIBgd','exports','toStringTag','13672516ctQIqF','UniverCore','2619510Tnfqic','defineProperty','removeExternalReference','@univerjs/engine-formula/facade','FFormula','670nzNHqU','FEnum','422841lvOpAc','unitId','upsertExternalReference','object','@univerjs-pro/engine-formula','_commandService'];_0x148c=function(){return _0x37e7de;};return _0x148c();}