@univerjs-pro/engine-formula 1.0.0-alpha.6 → 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

@@ -0,0 +1,103 @@
+import type { IRange } from '@univerjs/core';
+/** 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.
+ * Always use the stable Unit ID; never infer it from `formulaQualifier`.
+ */
+export interface IFormulaReferenceUnit {
+    /**
+     * Display name written into the formula qualifier. Supply the name only, without
+     * surrounding brackets or quotes; the builder applies formula escaping.
+     */
+    formulaQualifier: 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 one formula reference fragment.
+ *
+ * `hostUnitId === unit.unitId` produces Host-local syntax. Different IDs produce
+ * cross-Unit syntax using `unit.formulaQualifier`.
+ */
+export interface IBuildFormulaReferenceOptions {
+    /** Stable ID of the Unit that will own the formula. */
+    hostUnitId: string;
+    /** Stable identity and public qualifier of the referenced Sheet or Base Unit. */
+    unit: IFormulaReferenceUnit;
+    /** Sheet range or structured-table column to serialize. */
+    target: FormulaReferenceTarget;
+}
+/**
+ * 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(_0x37526e,_0x49949e){var _0x2cd36c=_0x42ba,_0x1c230c=_0x37526e();while(!![]){try{var _0x24ce21=-parseInt(_0x2cd36c(0x1bd))/0x1*(-parseInt(_0x2cd36c(0x1c5))/0x2)+parseInt(_0x2cd36c(0x1c1))/0x3+parseInt(_0x2cd36c(0x1c3))/0x4+-parseInt(_0x2cd36c(0x1bb))/0x5*(-parseInt(_0x2cd36c(0x1bc))/0x6)+parseInt(_0x2cd36c(0x1c7))/0x7*(-parseInt(_0x2cd36c(0x1c0))/0x8)+-parseInt(_0x2cd36c(0x1be))/0x9+-parseInt(_0x2cd36c(0x1cb))/0xa;if(_0x24ce21===_0x49949e)break;else _0x1c230c['push'](_0x1c230c['shift']());}catch(_0x5b2744){_0x1c230c['push'](_0x1c230c['shift']());}}}(_0x4657,0x4efb1),function(_0x5c7c5a,_0x1ee934){var _0x404a07=_0x42ba;typeof exports==_0x404a07(0x1ca)&&typeof module<'u'?_0x1ee934(exports,require('@univerjs/engine-formula/facade')):typeof define==_0x404a07(0x1c8)&&define['amd']?define([_0x404a07(0x1c6),'@univerjs/engine-formula/facade'],_0x1ee934):(_0x5c7c5a=typeof globalThis<'u'?globalThis:_0x5c7c5a||self,_0x1ee934(_0x5c7c5a[_0x404a07(0x1ba)]={},_0x5c7c5a[_0x404a07(0x1c9)]));}(this,function(_0x11117c,_0x2e21ce){var _0x4c0648=_0x42ba;Object[_0x4c0648(0x1c2)](_0x11117c,Symbol[_0x4c0648(0x1c4)],{'value':_0x4c0648(0x1cc)}),Object[_0x4c0648(0x1c2)](_0x11117c,_0x4c0648(0x1bf),{'enumerable':!0x0,'get':function(){return _0x2e21ce['FFormula'];}});}));function _0x42ba(_0x39debb,_0xd21eb7){_0x39debb=_0x39debb-0x1ba;var _0x465746=_0x4657();var _0x42ba67=_0x465746[_0x39debb];return _0x42ba67;}function _0x4657(){var _0x2a835c=['exports','1309oCXuon','function','UniverEngineFormulaFacade','object','1628010wNLTqH','Module','UniverProEngineFormulaFacade','5NUPmRo','1922466eUfmQa','546727YmQiTG','2904156KGbaZG','FFormula','18344otEyRq','37998yfomXo','defineProperty','1431908CPVKPs','toStringTag','2eTRUyW'];_0x4657=function(){return _0x2a835c;};return _0x4657();}
+(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();}