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

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 _0x5cfd(_0x23136e,_0x3f2b7b){_0x23136e=_0x23136e-0xcc;var _0x204414=_0x2044();var _0x5cfdd5=_0x204414[_0x23136e];return _0x5cfdd5;}(function(_0x3d5ae3,_0x55bc9a){var _0x4e50f5=_0x5cfd,_0x5007f4=_0x3d5ae3();while(!![]){try{var _0x281e01=-parseInt(_0x4e50f5(0xe0))/0x1+-parseInt(_0x4e50f5(0xe6))/0x2*(parseInt(_0x4e50f5(0xed))/0x3)+parseInt(_0x4e50f5(0xf2))/0x4+parseInt(_0x4e50f5(0xcd))/0x5*(parseInt(_0x4e50f5(0xf1))/0x6)+parseInt(_0x4e50f5(0xf0))/0x7*(parseInt(_0x4e50f5(0xce))/0x8)+-parseInt(_0x4e50f5(0xeb))/0x9*(-parseInt(_0x4e50f5(0xea))/0xa)+-parseInt(_0x4e50f5(0xe3))/0xb*(parseInt(_0x4e50f5(0xe9))/0xc);if(_0x281e01===_0x55bc9a)break;else _0x5007f4['push'](_0x5007f4['shift']());}catch(_0x5050ed){_0x5007f4['push'](_0x5007f4['shift']());}}}(_0x2044,0x5bf8f),function(_0x1a1265,_0x10d836){var _0x4922b6=_0x5cfd;typeof exports==_0x4922b6(0xdd)&&typeof module<'u'?_0x10d836(exports,require('@univerjs/engine-formula/facade'),require('@univerjs-pro/engine-formula'),require('@univerjs/core/facade'),require('@univerjs/core')):typeof define==_0x4922b6(0xd0)&&define['amd']?define(['exports','@univerjs/engine-formula/facade',_0x4922b6(0xe5),_0x4922b6(0xd6),_0x4922b6(0xcf)],_0x10d836):(_0x1a1265=typeof globalThis<'u'?globalThis:_0x1a1265||self,_0x10d836(_0x1a1265['UniverProEngineFormulaFacade']={},_0x1a1265[_0x4922b6(0xec)],_0x1a1265[_0x4922b6(0xe8)],_0x1a1265[_0x4922b6(0xd4)],_0x1a1265['UniverCore']));}(this,function(_0x40a39f,_0x20e34e,_0x49107c,_0x3f2721,_0x271284){var _0x26977a=_0x5cfd;Object['defineProperty'](_0x40a39f,Symbol[_0x26977a(0xe1)],{'value':_0x26977a(0xee)});var _0x1719df=class extends _0x3f2721[_0x26977a(0xd7)]{get[_0x26977a(0xd8)](){var _0x8b34a5=_0x26977a;return _0x49107c[_0x8b34a5(0xd8)];}};_0x3f2721[_0x26977a(0xd7)]['extend'](_0x1719df);var _0x2593e2=class extends _0x20e34e['FFormula']{[_0x26977a(0xe2)](_0xfa7e1f){var _0x4d0a5f=_0x26977a;let {hostUnitId:_0x1ebc26,unit:_0x2a112c,target:_0x1d49ab}=_0xfa7e1f;if(!_0x1ebc26||!_0x2a112c[_0x4d0a5f(0xd3)])throw Error('Formula\x20reference\x20authoring\x20requires\x20stable\x20Host\x20and\x20Source\x20Unit\x20IDs.');if(_0x2a112c[_0x4d0a5f(0xd3)]!==_0x1ebc26&&!this[_0x4d0a5f(0xd2)][_0x4d0a5f(0xcc)](_0x49107c[_0x4d0a5f(0xe7)]['id'],{'unitId':_0x1ebc26,'qualifier':_0x2a112c['formulaQualifier'],'sourceUnitId':_0x2a112c['unitId'],'sourceUnitType':_0x1d49ab[_0x4d0a5f(0xd5)]===_0x49107c[_0x4d0a5f(0xd8)][_0x4d0a5f(0xd9)]?_0x271284[_0x4d0a5f(0xde)]['UNIVER_SHEET']:_0x271284[_0x4d0a5f(0xde)][_0x4d0a5f(0xdb)]}))throw Error(_0x4d0a5f(0xf3)+_0x2a112c[_0x4d0a5f(0xda)]+'\x22.');return(0x0,_0x49107c[_0x4d0a5f(0xdf)])(_0xfa7e1f);}[_0x26977a(0xef)](_0x41dfaf){var _0x4fe984=_0x26977a;return this['_commandService'][_0x4fe984(0xcc)](_0x49107c[_0x4fe984(0xe7)]['id'],_0x41dfaf);}[_0x26977a(0xdc)](_0x3289a0){var _0x344138=_0x26977a;return this[_0x344138(0xd2)]['syncExecuteCommand'](_0x49107c['RemoveHostExternalReferenceCommand']['id'],_0x3289a0);}};_0x20e34e[_0x26977a(0xd1)][_0x26977a(0xe4)](_0x2593e2),Object['defineProperty'](_0x40a39f,_0x26977a(0xd1),{'enumerable':!0x0,'get':function(){var _0x3d1613=_0x26977a;return _0x20e34e[_0x3d1613(0xd1)];}});}));function _0x2044(){var _0x2951dd=['UniverProEngineFormula','12NPdTdS','10smwPUx','5659767szCLpS','UniverEngineFormulaFacade','75RsGoRs','Module','upsertExternalReference','182pBCUlf','6DYcHef','2623476FhduDx','Failed\x20to\x20bind\x20external\x20formula\x20reference\x20\x22','syncExecuteCommand','921355dUnFms','3288iDDLhr','@univerjs/core','function','FFormula','_commandService','unitId','UniverCoreFacade','kind','@univerjs/core/facade','FEnum','FormulaReferenceType','SHEET_RANGE','formulaQualifier','UNIVER_BASE','removeExternalReference','object','UniverInstanceType','buildFormulaReference','83482BvTBSC','toStringTag','buildReference','7753493KaFOdL','extend','@univerjs-pro/engine-formula','25170djuKEw','UpsertHostExternalReferenceCommand'];_0x2044=function(){return _0x2951dd;};return _0x2044();}