@flowgram-vue/variable-core 0.2.0

package/dist/index.cjs

@@ -0,0 +1,2630 @@
+'use strict';
+
+var inversify = require('inversify');
+var rxjs = require('rxjs');
+var utils = require('@flowgram-vue/utils');
+var lodashEs = require('lodash-es');
+var nanoid = require('nanoid');
+var fastEquals = require('fast-equals');
+var vue = require('vue');
+var core = require('@flowgram-vue/core');
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+function subsToDisposable(subscription) {
+  return utils.Disposable.create(() => subscription.unsubscribe());
+}
+
+// src/utils/memo.ts
+var createMemo = () => {
+  const _memoCache = /* @__PURE__ */ new Map();
+  const memo = (key, fn) => {
+    if (_memoCache.has(key)) {
+      return _memoCache.get(key);
+    }
+    const data = fn();
+    _memoCache.set(key, data);
+    return data;
+  };
+  const clear = (key) => {
+    if (key) {
+      _memoCache.delete(key);
+    } else {
+      _memoCache.clear();
+    }
+  };
+  memo.clear = clear;
+  return memo;
+};
+var VariableTable = class {
+  constructor(parentTable) {
+    this.parentTable = parentTable;
+    this.table = /* @__PURE__ */ new Map();
+    this.toDispose = new utils.DisposableCollection();
+    /**
+     * @deprecated
+     */
+    this.onDataChangeEmitter = new utils.Emitter();
+    this.variables$ = new rxjs.Subject();
+    /**
+     * An observable that listens for value changes on any variable within the table.
+     */
+    this.anyVariableChange$ = this.variables$.pipe(
+      rxjs.switchMap(
+        (_variables) => rxjs.merge(
+          ..._variables.map(
+            (_v) => _v.value$.pipe(
+              // Skip the initial value of the BehaviorSubject
+              rxjs.skip(1)
+            )
+          )
+        )
+      ),
+      rxjs.share()
+    );
+    /**
+     * @deprecated Use onListOrAnyVarChange instead.
+     */
+    this.onDataChange = this.onDataChangeEmitter.event;
+    this._version = 0;
+    this.toDispose.pushAll([
+      this.onDataChangeEmitter,
+      // Activate the share() operator
+      this.onAnyVariableChange(() => {
+        this.bumpVersion();
+      })
+    ]);
+  }
+  /**
+   * Subscribes to updates on any variable in the list.
+   * @param observer A function to be called when any variable's value changes.
+   * @returns A disposable object to unsubscribe from the updates.
+   */
+  onAnyVariableChange(observer) {
+    return subsToDisposable(this.anyVariableChange$.subscribe(observer));
+  }
+  /**
+   * Subscribes to changes in the variable list (additions or removals).
+   * @param observer A function to be called when the list of variables changes.
+   * @returns A disposable object to unsubscribe from the updates.
+   */
+  onVariableListChange(observer) {
+    return subsToDisposable(this.variables$.subscribe(observer));
+  }
+  /**
+   * Subscribes to both variable list changes and updates to any variable in the list.
+   * @param observer A function to be called when either the list or a variable in it changes.
+   * @returns A disposable collection to unsubscribe from both events.
+   */
+  onListOrAnyVarChange(observer) {
+    const disposables = new utils.DisposableCollection();
+    disposables.pushAll([this.onVariableListChange(observer), this.onAnyVariableChange(observer)]);
+    return disposables;
+  }
+  /**
+   * Fires change events to notify listeners that the data has been updated.
+   */
+  fireChange() {
+    this.bumpVersion();
+    this.onDataChangeEmitter.fire();
+    this.variables$.next(this.variables);
+    this.parentTable?.fireChange();
+  }
+  /**
+   * The current version of the variable table, incremented on each change.
+   */
+  get version() {
+    return this._version;
+  }
+  /**
+   * Increments the version number, resetting to 0 if it reaches MAX_SAFE_INTEGER.
+   */
+  bumpVersion() {
+    this._version = this._version + 1;
+    if (this._version === Number.MAX_SAFE_INTEGER) {
+      this._version = 0;
+    }
+  }
+  /**
+   * An array of all variables in the table.
+   */
+  get variables() {
+    return Array.from(this.table.values());
+  }
+  /**
+   * An array of all variable keys in the table.
+   */
+  get variableKeys() {
+    return Array.from(this.table.keys());
+  }
+  /**
+   * Retrieves a variable or a nested property field by its key path.
+   * @param keyPath An array of keys representing the path to the desired field.
+   * @returns The found variable or property field, or undefined if not found.
+   */
+  getByKeyPath(keyPath) {
+    const [variableKey, ...propertyKeys] = keyPath || [];
+    if (!variableKey) {
+      return;
+    }
+    const variable = this.getVariableByKey(variableKey);
+    return propertyKeys.length ? variable?.getByKeyPath(propertyKeys) : variable;
+  }
+  /**
+   * Retrieves a variable by its key.
+   * @param key The key of the variable to retrieve.
+   * @returns The variable declaration if found, otherwise undefined.
+   */
+  getVariableByKey(key) {
+    return this.table.get(key);
+  }
+  /**
+   * Adds a variable to the table.
+   * If a parent table exists, the variable is also added to the parent.
+   * @param variable The variable declaration to add.
+   */
+  addVariableToTable(variable) {
+    this.table.set(variable.key, variable);
+    if (this.parentTable) {
+      this.parentTable.addVariableToTable(variable);
+    }
+  }
+  /**
+   * Removes a variable from the table.
+   * If a parent table exists, the variable is also removed from the parent.
+   * @param key The key of the variable to remove.
+   */
+  removeVariableFromTable(key) {
+    this.table.delete(key);
+    if (this.parentTable) {
+      this.parentTable.removeVariableFromTable(key);
+    }
+  }
+  /**
+   * Disposes of all resources used by the variable table.
+   */
+  dispose() {
+    this.variableKeys.forEach(
+      (_key) => this.parentTable?.removeVariableFromTable(_key)
+    );
+    this.parentTable?.fireChange();
+    this.variables$.complete();
+    this.variables$.unsubscribe();
+    this.toDispose.dispose();
+  }
+};
+
+// src/providers.ts
+var VariableEngineProvider = /* @__PURE__ */ Symbol("DynamicVariableEngine");
+var ContainerProvider = /* @__PURE__ */ Symbol("ContainerProvider");
+
+// src/scope/scope-chain.ts
+exports.ScopeChain = class ScopeChain {
+  constructor() {
+    this.toDispose = new utils.DisposableCollection();
+  }
+  get variableEngine() {
+    return this.variableEngineProvider();
+  }
+  /**
+   * Refreshes the dependency and coverage relationships for all scopes.
+   */
+  refreshAllChange() {
+    this.variableEngine.getAllScopes().forEach((_scope) => {
+      _scope.refreshCovers();
+      _scope.refreshDeps();
+    });
+  }
+  dispose() {
+    this.toDispose.dispose();
+  }
+  get disposed() {
+    return this.toDispose.disposed;
+  }
+  get onDispose() {
+    return this.toDispose.onDispose;
+  }
+};
+__decorateClass([
+  inversify.inject(VariableEngineProvider)
+], exports.ScopeChain.prototype, "variableEngineProvider", 2);
+exports.ScopeChain = __decorateClass([
+  inversify.injectable()
+], exports.ScopeChain);
+
+// src/ast/types.ts
+var ASTKind = /* @__PURE__ */ ((ASTKind2) => {
+  ASTKind2["String"] = "String";
+  ASTKind2["Number"] = "Number";
+  ASTKind2["Integer"] = "Integer";
+  ASTKind2["Boolean"] = "Boolean";
+  ASTKind2["Object"] = "Object";
+  ASTKind2["Array"] = "Array";
+  ASTKind2["Map"] = "Map";
+  ASTKind2["Union"] = "Union";
+  ASTKind2["Any"] = "Any";
+  ASTKind2["CustomType"] = "CustomType";
+  ASTKind2["Property"] = "Property";
+  ASTKind2["VariableDeclaration"] = "VariableDeclaration";
+  ASTKind2["VariableDeclarationList"] = "VariableDeclarationList";
+  ASTKind2["KeyPathExpression"] = "KeyPathExpression";
+  ASTKind2["EnumerateExpression"] = "EnumerateExpression";
+  ASTKind2["WrapArrayExpression"] = "WrapArrayExpression";
+  ASTKind2["ListNode"] = "ListNode";
+  ASTKind2["DataNode"] = "DataNode";
+  ASTKind2["MapNode"] = "MapNode";
+  return ASTKind2;
+})(ASTKind || {});
+
+// src/ast/utils/inversify.ts
+var injectToAST = (serviceIdentifier) => function(target, propertyKey) {
+  if (!serviceIdentifier) {
+    throw new Error(
+      `ServiceIdentifier ${serviceIdentifier} in @lazyInject is Empty, it might be caused by file circular dependency, please check it.`
+    );
+  }
+  const descriptor = {
+    get() {
+      const container = this.scope.variableEngine.container;
+      return container.get(serviceIdentifier);
+    },
+    set() {
+    },
+    configurable: true,
+    enumerable: true
+  };
+  return descriptor;
+};
+var POST_CONSTRUCT_AST_SYMBOL = /* @__PURE__ */ Symbol("post_construct_ast");
+var postConstructAST = () => (target, propertyKey) => {
+  if (!Reflect.hasMetadata(POST_CONSTRUCT_AST_SYMBOL, target)) {
+    Reflect.defineMetadata(POST_CONSTRUCT_AST_SYMBOL, propertyKey, target);
+  } else {
+    throw Error("Duplication Post Construct AST");
+  }
+};
+
+// src/ast/flags.ts
+var ASTNodeFlags = /* @__PURE__ */ ((ASTNodeFlags2) => {
+  ASTNodeFlags2[ASTNodeFlags2["None"] = 0] = "None";
+  ASTNodeFlags2[ASTNodeFlags2["VariableField"] = 1] = "VariableField";
+  ASTNodeFlags2[ASTNodeFlags2["Expression"] = 4] = "Expression";
+  ASTNodeFlags2[ASTNodeFlags2["BasicType"] = 8] = "BasicType";
+  ASTNodeFlags2[ASTNodeFlags2["DrilldownType"] = 16] = "DrilldownType";
+  ASTNodeFlags2[ASTNodeFlags2["EnumerateType"] = 32] = "EnumerateType";
+  ASTNodeFlags2[ASTNodeFlags2["UnionType"] = 64] = "UnionType";
+  ASTNodeFlags2[ASTNodeFlags2["VariableType"] = 120] = "VariableType";
+  return ASTNodeFlags2;
+})(ASTNodeFlags || {});
+
+// src/ast/match.ts
+exports.ASTMatch = void 0;
+((ASTMatch2) => {
+  ASTMatch2.isString = (node) => node?.kind === "String" /* String */;
+  ASTMatch2.isNumber = (node) => node?.kind === "Number" /* Number */;
+  ASTMatch2.isBoolean = (node) => node?.kind === "Boolean" /* Boolean */;
+  ASTMatch2.isInteger = (node) => node?.kind === "Integer" /* Integer */;
+  ASTMatch2.isObject = (node) => node?.kind === "Object" /* Object */;
+  ASTMatch2.isArray = (node) => node?.kind === "Array" /* Array */;
+  ASTMatch2.isMap = (node) => node?.kind === "Map" /* Map */;
+  ASTMatch2.isCustomType = (node) => node?.kind === "CustomType" /* CustomType */;
+  ASTMatch2.isVariableDeclaration = (node) => node?.kind === "VariableDeclaration" /* VariableDeclaration */;
+  ASTMatch2.isProperty = (node) => node?.kind === "Property" /* Property */;
+  ASTMatch2.isBaseVariableField = (node) => !!(node?.flags || 0 & 1 /* VariableField */);
+  ASTMatch2.isVariableDeclarationList = (node) => node?.kind === "VariableDeclarationList" /* VariableDeclarationList */;
+  ASTMatch2.isEnumerateExpression = (node) => node?.kind === "EnumerateExpression" /* EnumerateExpression */;
+  ASTMatch2.isWrapArrayExpression = (node) => node?.kind === "WrapArrayExpression" /* WrapArrayExpression */;
+  ASTMatch2.isKeyPathExpression = (node) => node?.kind === "KeyPathExpression" /* KeyPathExpression */;
+  function is(node, targetType) {
+    return node?.kind === targetType?.kind;
+  }
+  ASTMatch2.is = is;
+})(exports.ASTMatch || (exports.ASTMatch = {}));
+
+// src/ast/utils/helpers.ts
+function updateChildNodeHelper({
+  getChildNode,
+  updateChildNode,
+  removeChildNode,
+  nextJSON
+}) {
+  const currNode = getChildNode();
+  const isNewKind = currNode?.kind !== nextJSON?.kind;
+  const isNewKey = nextJSON?.key && nextJSON?.key !== currNode?.key;
+  if (isNewKind || isNewKey) {
+    if (currNode) {
+      currNode.dispose();
+      removeChildNode();
+    }
+    if (nextJSON) {
+      const newNode = this.createChildNode(nextJSON);
+      updateChildNode(newNode);
+      this.fireChange();
+      return newNode;
+    } else {
+      this.fireChange();
+    }
+  } else if (nextJSON) {
+    currNode?.fromJSON(nextJSON);
+  }
+  return currNode;
+}
+function parseTypeJsonOrKind(typeJSONOrKind) {
+  return typeof typeJSONOrKind === "string" ? { kind: typeJSONOrKind } : typeJSONOrKind;
+}
+function getAllChildren(ast) {
+  return [...ast.children, ...ast.children.map((_child) => getAllChildren(_child)).flat()];
+}
+function isMatchAST(node, targetType) {
+  return exports.ASTMatch.is(node, targetType);
+}
+var ASTNode = class _ASTNode {
+  /**
+   * Constructor.
+   * @param createParams Necessary parameters for creating an ASTNode.
+   * @param injectOptions Dependency injection for various modules.
+   */
+  constructor({ key, parent, scope }, opts) {
+    /**
+     * Node flags, used to record some flag information.
+     */
+    this.flags = 0 /* None */;
+    /**
+     * The version number of the ASTNode, which increments by 1 each time `fireChange` is called.
+     */
+    this._version = 0;
+    /**
+     * Update lock.
+     * - When set to `true`, `fireChange` will not trigger any events.
+     * - This is useful when multiple updates are needed, and you want to avoid multiple triggers.
+     */
+    this.changeLocked = false;
+    /**
+     * Parameters related to batch updates.
+     */
+    this._batch = {
+      batching: false,
+      hasChangesInBatch: false
+    };
+    /**
+     * AST node change Observable events, implemented based on RxJS.
+     * - Emits the current ASTNode value upon subscription.
+     * - Emits a new value whenever `fireChange` is called.
+     */
+    this.value$ = new rxjs.BehaviorSubject(this);
+    /**
+     * Child ASTNodes.
+     */
+    this._children = /* @__PURE__ */ new Set();
+    /**
+     * List of disposal handlers for the ASTNode.
+     */
+    this.toDispose = new utils.DisposableCollection(
+      utils.Disposable.create(() => {
+        this.parent?.fireChange();
+        this.children.forEach((child) => child.dispose());
+      })
+    );
+    /**
+     * Callback triggered upon disposal.
+     */
+    this.onDispose = this.toDispose.onDispose;
+    this.scope = scope;
+    this.parent = parent;
+    this.opts = opts;
+    this.key = key || nanoid.nanoid();
+    this.fromJSON = this.withBatchUpdate(this.fromJSON.bind(this));
+    const rawToJSON = this.toJSON?.bind(this);
+    this.toJSON = () => lodashEs.omitBy(
+      {
+        // always include kind
+        kind: this.kind,
+        ...rawToJSON?.() || {}
+      },
+      // remove undefined fields
+      lodashEs.isNil
+    );
+  }
+  /**
+   * The type of the ASTNode.
+   */
+  get kind() {
+    if (!this.constructor.kind) {
+      throw new Error(`ASTNode Registry need a kind: ${this.constructor.name}`);
+    }
+    return this.constructor.kind;
+  }
+  /**
+   * Gets all child ASTNodes of the current ASTNode.
+   */
+  get children() {
+    return Array.from(this._children);
+  }
+  /**
+   * Creates a child ASTNode.
+   * @param json The AST JSON of the child ASTNode.
+   * @returns
+   */
+  createChildNode(json) {
+    const astRegisters = this.scope.variableEngine.astRegisters;
+    const child = astRegisters.createAST(json, {
+      parent: this,
+      scope: this.scope
+    });
+    this._children.add(child);
+    child.toDispose.push(
+      utils.Disposable.create(() => {
+        this._children.delete(child);
+      })
+    );
+    return child;
+  }
+  /**
+   * Updates a child ASTNode, quickly implementing the consumption logic for child ASTNode updates.
+   * @param keyInThis The specified key on the current object.
+   */
+  updateChildNodeByKey(keyInThis, nextJSON) {
+    this.withBatchUpdate(updateChildNodeHelper).call(this, {
+      getChildNode: () => this[keyInThis],
+      updateChildNode: (_node) => this[keyInThis] = _node,
+      removeChildNode: () => this[keyInThis] = void 0,
+      nextJSON
+    });
+  }
+  /**
+   * Batch updates the ASTNode, merging all `fireChange` calls within the batch function into one.
+   * @param updater The batch function.
+   * @returns
+   */
+  withBatchUpdate(updater) {
+    return (...args) => {
+      if (this._batch.batching) {
+        return updater.call(this, ...args);
+      }
+      this._batch.hasChangesInBatch = false;
+      this._batch.batching = true;
+      const res = updater.call(this, ...args);
+      this._batch.batching = false;
+      if (this._batch.hasChangesInBatch) {
+        this.fireChange();
+      }
+      this._batch.hasChangesInBatch = false;
+      return res;
+    };
+  }
+  /**
+   * Triggers an update for the current node.
+   */
+  fireChange() {
+    if (this.changeLocked || this.disposed) {
+      return;
+    }
+    if (this._batch.batching) {
+      this._batch.hasChangesInBatch = true;
+      return;
+    }
+    this._version++;
+    this.value$.next(this);
+    this.dispatchGlobalEvent({ type: "UpdateAST" });
+    this.parent?.fireChange();
+  }
+  /**
+   * The version value of the ASTNode.
+   * - You can used to check whether ASTNode are updated.
+   */
+  get version() {
+    return this._version;
+  }
+  /**
+   * The unique hash value of the ASTNode.
+   * - It will update when the ASTNode is updated.
+   * - You can used to check two ASTNode are equal.
+   */
+  get hash() {
+    return `${this._version}${this.kind}${this.key}`;
+  }
+  /**
+   * Listens for changes to the ASTNode.
+   * @param observer The listener callback.
+   * @param selector Listens for specified data.
+   * @returns
+   */
+  subscribe(observer, { selector, debounceAnimation, triggerOnInit } = {}) {
+    return subsToDisposable(
+      this.value$.pipe(
+        rxjs.map(() => selector ? selector(this) : this),
+        rxjs.distinctUntilChanged(
+          (a, b) => fastEquals.shallowEqual(a, b),
+          (value) => {
+            if (value instanceof _ASTNode) {
+              return value.hash;
+            }
+            return value;
+          }
+        ),
+        // By default, skip the first trigger of BehaviorSubject.
+        triggerOnInit ? rxjs.tap(() => null) : rxjs.skip(1),
+        // All updates within each animationFrame are merged into one.
+        debounceAnimation ? rxjs.debounceTime(0, rxjs.animationFrameScheduler) : rxjs.tap(() => null)
+      ).subscribe(observer)
+    );
+  }
+  /**
+   * Dispatches a global event for the current ASTNode.
+   * @param event The global event.
+   */
+  dispatchGlobalEvent(event) {
+    this.scope.event.dispatch({
+      ...event,
+      ast: this
+    });
+  }
+  /**
+   * Disposes the ASTNode.
+   */
+  dispose() {
+    if (this.toDispose.disposed) {
+      return;
+    }
+    this.toDispose.dispose();
+    this.dispatchGlobalEvent({ type: "DisposeAST" });
+    this.value$.complete();
+    this.value$.unsubscribe();
+  }
+  get disposed() {
+    return this.toDispose.disposed;
+  }
+};
+
+// src/ast/type/base-type.ts
+var BaseType = class extends ASTNode {
+  constructor() {
+    super(...arguments);
+    this.flags = 8 /* BasicType */;
+  }
+  /**
+   * Check if the current type is equal to the target type.
+   * @param targetTypeJSONOrKind The type to compare with.
+   * @returns `true` if the types are equal, `false` otherwise.
+   */
+  isTypeEqual(targetTypeJSONOrKind) {
+    const targetTypeJSON = parseTypeJsonOrKind(targetTypeJSONOrKind);
+    if (targetTypeJSON?.kind === "Union" /* Union */) {
+      return (targetTypeJSON?.types || [])?.some(
+        (_subType) => this.isTypeEqual(_subType)
+      );
+    }
+    return this.kind === targetTypeJSON?.kind;
+  }
+  /**
+   * Get a variable field by key path.
+   *
+   * This method should be implemented by drillable types.
+   * @param keyPath The key path to search for.
+   * @returns The variable field if found, otherwise `undefined`.
+   */
+  getByKeyPath(keyPath = []) {
+    throw new Error(`Get By Key Path is not implemented for Type: ${this.kind}`);
+  }
+};
+
+// src/ast/type/array.ts
+var ArrayType = class extends BaseType {
+  constructor() {
+    super(...arguments);
+    this.flags = 16 /* DrilldownType */ | 32 /* EnumerateType */;
+  }
+  /**
+   * Deserializes the `ArrayJSON` to the `ArrayType`.
+   * @param json The `ArrayJSON` to deserialize.
+   */
+  fromJSON({ items }) {
+    this.updateChildNodeByKey("items", parseTypeJsonOrKind(items));
+  }
+  /**
+   * Whether the items type can be drilled down.
+   */
+  get canDrilldownItems() {
+    return !!(this.items?.flags & 16 /* DrilldownType */);
+  }
+  /**
+   * Get a variable field by key path.
+   * @param keyPath The key path to search for.
+   * @returns The variable field if found, otherwise `undefined`.
+   */
+  getByKeyPath(keyPath) {
+    const [curr, ...rest] = keyPath || [];
+    if (curr === "0" && this.canDrilldownItems) {
+      return this.items.getByKeyPath(rest);
+    }
+    return void 0;
+  }
+  /**
+   * Check if the current type is equal to the target type.
+   * @param targetTypeJSONOrKind The type to compare with.
+   * @returns `true` if the types are equal, `false` otherwise.
+   */
+  isTypeEqual(targetTypeJSONOrKind) {
+    const targetTypeJSON = parseTypeJsonOrKind(targetTypeJSONOrKind);
+    const isSuperEqual = super.isTypeEqual(targetTypeJSONOrKind);
+    if (targetTypeJSON?.weak || targetTypeJSON?.kind === "Union" /* Union */) {
+      return isSuperEqual;
+    }
+    return targetTypeJSON && isSuperEqual && // Weak comparison, only need to compare the Kind.
+    (targetTypeJSON?.weak || this.customStrongEqual(targetTypeJSON));
+  }
+  /**
+   * Array strong comparison.
+   * @param targetTypeJSON The type to compare with.
+   * @returns `true` if the types are equal, `false` otherwise.
+   */
+  customStrongEqual(targetTypeJSON) {
+    if (!this.items) {
+      return !targetTypeJSON?.items;
+    }
+    return this.items?.isTypeEqual(targetTypeJSON.items);
+  }
+  /**
+   * Serialize the `ArrayType` to `ArrayJSON`
+   * @returns The JSON representation of `ArrayType`.
+   */
+  toJSON() {
+    return {
+      kind: "Array" /* Array */,
+      items: this.items?.toJSON()
+    };
+  }
+};
+ArrayType.kind = "Array" /* Array */;
+
+// src/ast/type/string.ts
+var StringType = class extends BaseType {
+  constructor() {
+    super(...arguments);
+    this.flags = 8 /* BasicType */;
+  }
+  /**
+   * see https://json-schema.org/understanding-json-schema/reference/string#format
+   */
+  get format() {
+    return this._format;
+  }
+  /**
+   * Deserialize the `StringJSON` to the `StringType`.
+   *
+   * @param json StringJSON representation of the `StringType`.
+   */
+  fromJSON(json) {
+    if (json?.format !== this._format) {
+      this._format = json?.format;
+      this.fireChange();
+    }
+  }
+  /**
+   * Serialize the `StringType` to `StringJSON`.
+   * @returns The JSON representation of `StringType`.
+   */
+  toJSON() {
+    return {
+      format: this._format
+    };
+  }
+};
+StringType.kind = "String" /* String */;
+
+// src/ast/type/integer.ts
+var IntegerType = class extends BaseType {
+  constructor() {
+    super(...arguments);
+    this.flags = 8 /* BasicType */;
+  }
+  /**
+   * Deserializes the `IntegerJSON` to the `IntegerType`.
+   * @param json The `IntegerJSON` to deserialize.
+   */
+  fromJSON() {
+  }
+  toJSON() {
+    return {};
+  }
+};
+IntegerType.kind = "Integer" /* Integer */;
+
+// src/ast/type/boolean.ts
+var BooleanType = class extends BaseType {
+  /**
+   * Deserializes the `BooleanJSON` to the `BooleanType`.
+   * @param json The `BooleanJSON` to deserialize.
+   */
+  fromJSON() {
+  }
+  toJSON() {
+    return {};
+  }
+};
+BooleanType.kind = "Boolean" /* Boolean */;
+
+// src/ast/type/number.ts
+var NumberType = class extends BaseType {
+  /**
+   * Deserializes the `NumberJSON` to the `NumberType`.
+   * @param json The `NumberJSON` to deserialize.
+   */
+  fromJSON() {
+  }
+  toJSON() {
+    return {};
+  }
+};
+NumberType.kind = "Number" /* Number */;
+
+// src/ast/type/map.ts
+var MapType = class extends BaseType {
+  /**
+   * Deserializes the `MapJSON` to the `MapType`.
+   * @param json The `MapJSON` to deserialize.
+   */
+  fromJSON({ keyType = "String" /* String */, valueType }) {
+    this.updateChildNodeByKey("keyType", parseTypeJsonOrKind(keyType));
+    this.updateChildNodeByKey("valueType", parseTypeJsonOrKind(valueType));
+  }
+  /**
+   * Check if the current type is equal to the target type.
+   * @param targetTypeJSONOrKind The type to compare with.
+   * @returns `true` if the types are equal, `false` otherwise.
+   */
+  isTypeEqual(targetTypeJSONOrKind) {
+    const targetTypeJSON = parseTypeJsonOrKind(targetTypeJSONOrKind);
+    const isSuperEqual = super.isTypeEqual(targetTypeJSONOrKind);
+    if (targetTypeJSON?.weak || targetTypeJSON?.kind === "Union" /* Union */) {
+      return isSuperEqual;
+    }
+    return targetTypeJSON && isSuperEqual && // Weak comparison, only need to compare the Kind.
+    (targetTypeJSON?.weak || this.customStrongEqual(targetTypeJSON));
+  }
+  /**
+   * Map strong comparison.
+   * @param targetTypeJSON The type to compare with.
+   * @returns `true` if the types are equal, `false` otherwise.
+   */
+  customStrongEqual(targetTypeJSON) {
+    const { keyType = "String" /* String */, valueType } = targetTypeJSON;
+    const isValueTypeEqual = !valueType && !this.valueType || this.valueType?.isTypeEqual(valueType);
+    return isValueTypeEqual && this.keyType?.isTypeEqual(keyType);
+  }
+  /**
+   * Serialize the node to a JSON object.
+   * @returns The JSON representation of the node.
+   */
+  toJSON() {
+    return {
+      kind: "Map" /* Map */,
+      keyType: this.keyType?.toJSON(),
+      valueType: this.valueType?.toJSON()
+    };
+  }
+};
+MapType.kind = "Map" /* Map */;
+var ObjectType = class extends BaseType {
+  constructor() {
+    super(...arguments);
+    this.flags = 16 /* DrilldownType */;
+    /**
+     * A map of property keys to `Property` instances.
+     */
+    this.propertyTable = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Deserializes the `ObjectJSON` to the `ObjectType`.
+   * @param json The `ObjectJSON` to deserialize.
+   */
+  fromJSON({ properties }) {
+    const removedKeys = new Set(this.propertyTable.keys());
+    const prev = [...this.properties || []];
+    this.properties = (properties || []).map((property) => {
+      const existProperty = this.propertyTable.get(property.key);
+      removedKeys.delete(property.key);
+      if (existProperty) {
+        existProperty.fromJSON(property);
+        return existProperty;
+      } else {
+        const newProperty = this.createChildNode({
+          ...property,
+          kind: "Property" /* Property */
+        });
+        this.fireChange();
+        this.propertyTable.set(property.key, newProperty);
+        return newProperty;
+      }
+    });
+    removedKeys.forEach((key) => {
+      const property = this.propertyTable.get(key);
+      property?.dispose();
+      this.propertyTable.delete(key);
+      this.fireChange();
+    });
+    this.dispatchGlobalEvent({
+      type: "ObjectPropertiesChange",
+      payload: {
+        prev,
+        next: [...this.properties]
+      }
+    });
+  }
+  /**
+   * Serialize the `ObjectType` to `ObjectJSON`.
+   * @returns The JSON representation of `ObjectType`.
+   */
+  toJSON() {
+    return {
+      properties: this.properties.map((_property) => _property.toJSON())
+    };
+  }
+  /**
+   * Get a variable field by key path.
+   * @param keyPath The key path to search for.
+   * @returns The variable field if found, otherwise `undefined`.
+   */
+  getByKeyPath(keyPath) {
+    const [curr, ...restKeyPath] = keyPath;
+    const property = this.propertyTable.get(curr);
+    if (!restKeyPath.length) {
+      return property;
+    }
+    if (property?.type && property?.type?.flags & 16 /* DrilldownType */) {
+      return property.type.getByKeyPath(restKeyPath);
+    }
+    return void 0;
+  }
+  /**
+   * Check if the current type is equal to the target type.
+   * @param targetTypeJSONOrKind The type to compare with.
+   * @returns `true` if the types are equal, `false` otherwise.
+   */
+  isTypeEqual(targetTypeJSONOrKind) {
+    const targetTypeJSON = parseTypeJsonOrKind(targetTypeJSONOrKind);
+    const isSuperEqual = super.isTypeEqual(targetTypeJSONOrKind);
+    if (targetTypeJSON?.weak || targetTypeJSON?.kind === "Union" /* Union */) {
+      return isSuperEqual;
+    }
+    return targetTypeJSON && isSuperEqual && // Weak comparison, only need to compare the Kind.
+    (targetTypeJSON?.weak || this.customStrongEqual(targetTypeJSON));
+  }
+  /**
+   * Object type strong comparison.
+   * @param targetTypeJSON The type to compare with.
+   * @returns `true` if the types are equal, `false` otherwise.
+   */
+  customStrongEqual(targetTypeJSON) {
+    const targetProperties = targetTypeJSON.properties || [];
+    const sourcePropertyKeys = Array.from(this.propertyTable.keys());
+    const targetPropertyKeys = targetProperties.map((_target) => _target.key);
+    const isKeyStrongEqual = !lodashEs.xor(sourcePropertyKeys, targetPropertyKeys).length;
+    return isKeyStrongEqual && targetProperties.every((targetProperty) => {
+      const sourceProperty = this.propertyTable.get(targetProperty.key);
+      return sourceProperty && sourceProperty.key === targetProperty.key && sourceProperty.type?.isTypeEqual(targetProperty?.type);
+    });
+  }
+};
+ObjectType.kind = "Object" /* Object */;
+
+// src/ast/type/custom-type.ts
+var CustomType = class extends BaseType {
+  /**
+   * The name of the custom type.
+   */
+  get typeName() {
+    return this._typeName;
+  }
+  /**
+   * Deserializes the `CustomTypeJSON` to the `CustomType`.
+   * @param json The `CustomTypeJSON` to deserialize.
+   */
+  fromJSON(json) {
+    if (this._typeName !== json.typeName) {
+      this._typeName = json.typeName;
+      this.fireChange();
+    }
+  }
+  /**
+   * Check if the current type is equal to the target type.
+   * @param targetTypeJSONOrKind The type to compare with.
+   * @returns `true` if the types are equal, `false` otherwise.
+   */
+  isTypeEqual(targetTypeJSONOrKind) {
+    const targetTypeJSON = parseTypeJsonOrKind(targetTypeJSONOrKind);
+    if (targetTypeJSON?.kind === "Union" /* Union */) {
+      return (targetTypeJSON?.types || [])?.some(
+        (_subType) => this.isTypeEqual(_subType)
+      );
+    }
+    return targetTypeJSON?.kind === this.kind && targetTypeJSON?.typeName === this.typeName;
+  }
+  toJSON() {
+    return {
+      typeName: this.typeName
+    };
+  }
+};
+CustomType.kind = "CustomType" /* CustomType */;
+
+// src/ast/utils/variable-field.ts
+function getParentFields(ast) {
+  let curr = ast.parent;
+  const res = [];
+  while (curr) {
+    if (curr.flags & 1 /* VariableField */) {
+      res.push(curr);
+    }
+    curr = curr.parent;
+  }
+  return res;
+}
+
+// src/ast/expression/base-expression.ts
+var BaseExpression = class extends ASTNode {
+  constructor(params, opts) {
+    super(params, opts);
+    this.flags = 4 /* Expression */;
+    /**
+     * The variable fields referenced by the expression.
+     */
+    this._refs = [];
+    this.refreshRefs$ = new rxjs.Subject();
+    /**
+     * An observable that emits the referenced variable fields when they change.
+     */
+    this.refs$ = this.refreshRefs$.pipe(
+      rxjs.map(() => this.getRefFields()),
+      rxjs.distinctUntilChanged(fastEquals.shallowEqual),
+      rxjs.switchMap(
+        (refs) => !refs?.length ? rxjs.of([]) : rxjs.combineLatest(
+          refs.map(
+            (ref) => ref ? ref.value$ : rxjs.of(void 0)
+          )
+        )
+      ),
+      rxjs.share()
+    );
+    this.toDispose.push(
+      subsToDisposable(
+        this.refs$.subscribe((_refs) => {
+          this._refs = _refs;
+          this.fireChange();
+        })
+      )
+    );
+  }
+  /**
+   * Get the global variable table, which is used to access referenced variables.
+   */
+  get globalVariableTable() {
+    return this.scope.variableEngine.globalVariableTable;
+  }
+  /**
+   * Parent variable fields, sorted from closest to farthest.
+   */
+  get parentFields() {
+    return getParentFields(this);
+  }
+  /**
+   * The variable fields referenced by the expression.
+   */
+  get refs() {
+    return this._refs;
+  }
+  /**
+   * Refresh the variable references.
+   */
+  refreshRefs() {
+    this.refreshRefs$.next();
+  }
+};
+
+// src/ast/expression/enumerate-expression.ts
+var EnumerateExpression = class extends BaseExpression {
+  /**
+   * The expression to be enumerated.
+   */
+  get enumerateFor() {
+    return this._enumerateFor;
+  }
+  /**
+   * The return type of the expression.
+   */
+  get returnType() {
+    const childReturnType = this.enumerateFor?.returnType;
+    if (childReturnType?.kind === "Array" /* Array */) {
+      return childReturnType.items;
+    }
+    return void 0;
+  }
+  /**
+   * Get the variable fields referenced by the expression.
+   * @returns An empty array, as this expression does not reference any variables.
+   */
+  getRefFields() {
+    return [];
+  }
+  /**
+   * Deserializes the `EnumerateExpressionJSON` to the `EnumerateExpression`.
+   * @param json The `EnumerateExpressionJSON` to deserialize.
+   */
+  fromJSON({ enumerateFor: expression }) {
+    this.updateChildNodeByKey("_enumerateFor", expression);
+  }
+  /**
+   * Serialize the `EnumerateExpression` to `EnumerateExpressionJSON`.
+   * @returns The JSON representation of `EnumerateExpression`.
+   */
+  toJSON() {
+    return {
+      kind: "EnumerateExpression" /* EnumerateExpression */,
+      enumerateFor: this.enumerateFor?.toJSON()
+    };
+  }
+};
+EnumerateExpression.kind = "EnumerateExpression" /* EnumerateExpression */;
+function getAllRefs(ast) {
+  return getAllChildren(ast).filter((_child) => _child.flags & 4 /* Expression */).map((_child) => _child.refs).flat().filter(Boolean);
+}
+function checkRefCycle(curr, refNodes) {
+  if (lodashEs.intersection(curr.scope.coverScopes, refNodes.map((_ref) => _ref?.scope).filter(Boolean)).length === 0) {
+    return false;
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [...refNodes];
+  while (queue.length) {
+    const currNode = queue.shift();
+    visited.add(currNode);
+    for (const ref of getAllRefs(currNode).filter((_ref) => !visited.has(_ref))) {
+      queue.push(ref);
+    }
+  }
+  return lodashEs.intersection(Array.from(visited), getParentFields(curr)).length > 0;
+}
+
+// src/ast/expression/keypath-expression.ts
+var KeyPathExpression = class extends BaseExpression {
+  constructor(params, opts) {
+    super(params, opts);
+    this._keyPath = [];
+    this.toDispose.pushAll([
+      // Can be used when the variable list changes (when there are additions or deletions).
+      this.scope.available.onVariableListChange(() => {
+        this.refreshRefs();
+      }),
+      // When the referable variable pointed to by this._keyPath changes, refresh the reference data.
+      this.scope.available.onAnyVariableChange((_v) => {
+        if (_v.key === this._keyPath[0]) {
+          this.refreshRefs();
+        }
+      }),
+      subsToDisposable(
+        this.refs$.pipe(
+          rxjs.distinctUntilChanged(
+            (prev, next) => prev === next,
+            (_refs) => _refs?.[0]?.type?.hash
+          )
+        ).subscribe((_type) => {
+          const [ref] = this._refs;
+          this.updateChildNodeByKey("_returnType", this.getReturnTypeJSONByRef(ref));
+        })
+      )
+    ]);
+  }
+  /**
+   * The key path of the variable.
+   */
+  get keyPath() {
+    return this._keyPath;
+  }
+  /**
+   * Get the variable fields referenced by the expression.
+   * @returns An array of referenced variable fields.
+   */
+  getRefFields() {
+    const ref = this.scope.available.getByKeyPath(this._keyPath);
+    if (checkRefCycle(this, [ref])) {
+      console.warn(
+        "[CustomKeyPathExpression] checkRefCycle: Reference Cycle Existed",
+        this.parentFields.map((_field) => _field.key).reverse()
+      );
+      return [];
+    }
+    return ref ? [ref] : [];
+  }
+  /**
+   * The return type of the expression.
+   */
+  get returnType() {
+    return this._returnType;
+  }
+  /**
+   * Parse the business-defined path expression into a key path.
+   *
+   * Businesses can quickly customize their own path expressions by modifying this method.
+   * @param json The path expression defined by the business.
+   * @returns The key path.
+   */
+  parseToKeyPath(json) {
+    return json.keyPath;
+  }
+  /**
+   * Deserializes the `KeyPathExpressionJSON` to the `KeyPathExpression`.
+   * @param json The `KeyPathExpressionJSON` to deserialize.
+   */
+  fromJSON(json) {
+    const keyPath = this.parseToKeyPath(json);
+    if (!fastEquals.shallowEqual(keyPath, this._keyPath)) {
+      this._keyPath = keyPath;
+      this._rawPathJson = json;
+      this.refreshRefs();
+    }
+  }
+  /**
+   * Get the return type JSON by reference.
+   * @param _ref The referenced variable field.
+   * @returns The JSON representation of the return type.
+   */
+  getReturnTypeJSONByRef(_ref) {
+    return _ref?.type?.toJSON();
+  }
+  /**
+   * Serialize the `KeyPathExpression` to `KeyPathExpressionJSON`.
+   * @returns The JSON representation of `KeyPathExpression`.
+   */
+  toJSON() {
+    return this._rawPathJson;
+  }
+};
+KeyPathExpression.kind = "KeyPathExpression" /* KeyPathExpression */;
+var LegacyKeyPathExpression = class extends BaseExpression {
+  constructor(params, opts) {
+    super(params, opts);
+    this._keyPath = [];
+    this.toDispose.pushAll([
+      // Can be used when the variable list changes (when there are additions or deletions).
+      this.scope.available.onVariableListChange(() => {
+        this.refreshRefs();
+      }),
+      // When the referable variable pointed to by this._keyPath changes, refresh the reference data.
+      this.scope.available.onAnyVariableChange((_v) => {
+        if (_v.key === this._keyPath[0]) {
+          this.refreshRefs();
+        }
+      })
+    ]);
+  }
+  /**
+   * The key path of the variable.
+   */
+  get keyPath() {
+    return this._keyPath;
+  }
+  /**
+   * Get the variable fields referenced by the expression.
+   * @returns An array of referenced variable fields.
+   */
+  getRefFields() {
+    const ref = this.scope.available.getByKeyPath(this._keyPath);
+    return ref ? [ref] : [];
+  }
+  /**
+   * The return type of the expression.
+   */
+  get returnType() {
+    const [refNode] = this._refs || [];
+    if (refNode && refNode.flags & 1 /* VariableField */) {
+      return refNode.type;
+    }
+    return;
+  }
+  /**
+   * Parse the business-defined path expression into a key path.
+   *
+   * Businesses can quickly customize their own path expressions by modifying this method.
+   * @param json The path expression defined by the business.
+   * @returns The key path.
+   */
+  parseToKeyPath(json) {
+    return json.keyPath;
+  }
+  /**
+   * Deserializes the `KeyPathExpressionJSON` to the `KeyPathExpression`.
+   * @param json The `KeyPathExpressionJSON` to deserialize.
+   */
+  fromJSON(json) {
+    const keyPath = this.parseToKeyPath(json);
+    if (!fastEquals.shallowEqual(keyPath, this._keyPath)) {
+      this._keyPath = keyPath;
+      this._rawPathJson = json;
+      this.refreshRefs();
+    }
+  }
+  /**
+   * Serialize the `KeyPathExpression` to `KeyPathExpressionJSON`.
+   * @returns The JSON representation of `KeyPathExpression`.
+   */
+  toJSON() {
+    return this._rawPathJson;
+  }
+};
+LegacyKeyPathExpression.kind = "KeyPathExpression" /* KeyPathExpression */;
+
+// src/ast/expression/wrap-array-expression.ts
+var WrapArrayExpression = class extends BaseExpression {
+  /**
+   * The expression to be wrapped.
+   */
+  get wrapFor() {
+    return this._wrapFor;
+  }
+  /**
+   * The return type of the expression.
+   */
+  get returnType() {
+    return this._returnType;
+  }
+  /**
+   * Refresh the return type of the expression.
+   */
+  refreshReturnType() {
+    const childReturnTypeJSON = this.wrapFor?.returnType?.toJSON();
+    this.updateChildNodeByKey("_returnType", {
+      kind: "Array" /* Array */,
+      items: childReturnTypeJSON
+    });
+  }
+  /**
+   * Get the variable fields referenced by the expression.
+   * @returns An empty array, as this expression does not reference any variables.
+   */
+  getRefFields() {
+    return [];
+  }
+  /**
+   * Deserializes the `WrapArrayExpressionJSON` to the `WrapArrayExpression`.
+   * @param json The `WrapArrayExpressionJSON` to deserialize.
+   */
+  fromJSON({ wrapFor: expression }) {
+    this.updateChildNodeByKey("_wrapFor", expression);
+  }
+  /**
+   * Serialize the `WrapArrayExpression` to `WrapArrayExpressionJSON`.
+   * @returns The JSON representation of `WrapArrayExpression`.
+   */
+  toJSON() {
+    return {
+      kind: "WrapArrayExpression" /* WrapArrayExpression */,
+      wrapFor: this.wrapFor?.toJSON()
+    };
+  }
+  init() {
+    this.refreshReturnType = this.refreshReturnType.bind(this);
+    this.toDispose.push(
+      this.subscribe(this.refreshReturnType, {
+        selector: (curr) => curr.wrapFor?.returnType,
+        triggerOnInit: true
+      })
+    );
+  }
+};
+WrapArrayExpression.kind = "WrapArrayExpression" /* WrapArrayExpression */;
+__decorateClass([
+  postConstructAST()
+], WrapArrayExpression.prototype, "init", 1);
+var BaseVariableField = class extends ASTNode {
+  constructor() {
+    super(...arguments);
+    this.flags = 1 /* VariableField */;
+    this._meta = {};
+  }
+  /**
+   * Parent variable fields, sorted from closest to farthest
+   */
+  get parentFields() {
+    return getParentFields(this);
+  }
+  /**
+   * KeyPath of the variable field, sorted from farthest to closest
+   */
+  get keyPath() {
+    return [...this.parentFields.reverse().map((_field) => _field.key), this.key];
+  }
+  /**
+   * Metadata of the variable field, you cans store information like `title`, `icon`, etc.
+   */
+  get meta() {
+    return this._meta;
+  }
+  /**
+   * Type of the variable field, similar to js code:
+   * `const v: string`
+   */
+  get type() {
+    return this._initializer?.returnType || this._type;
+  }
+  /**
+   * Initializer of the variable field, similar to js code:
+   * `const v = 'hello'`
+   *
+   * with initializer, the type of field will be inferred from the initializer.
+   */
+  get initializer() {
+    return this._initializer;
+  }
+  /**
+   * The global unique hash of the field, and will be changed when the field is updated.
+   */
+  get hash() {
+    return `[${this._version}]${this.keyPath.join(".")}`;
+  }
+  /**
+   * Deserialize the `BaseVariableFieldJSON` to the `BaseVariableField`.
+   * @param json ASTJSON representation of `BaseVariableField`
+   */
+  fromJSON({ type, initializer, meta }) {
+    this.updateType(type);
+    this.updateInitializer(initializer);
+    this.updateMeta(meta);
+  }
+  /**
+   * Update the type of the variable field
+   * @param type type ASTJSON representation of Type
+   */
+  updateType(type) {
+    const nextTypeJson = typeof type === "string" ? { kind: type } : type;
+    this.updateChildNodeByKey("_type", nextTypeJson);
+  }
+  /**
+   * Update the initializer of the variable field
+   * @param nextInitializer initializer ASTJSON representation of Expression
+   */
+  updateInitializer(nextInitializer) {
+    this.updateChildNodeByKey("_initializer", nextInitializer);
+  }
+  /**
+   * Update the meta data of the variable field
+   * @param nextMeta meta data of the variable field
+   */
+  updateMeta(nextMeta) {
+    if (!fastEquals.shallowEqual(nextMeta, this._meta)) {
+      this._meta = nextMeta;
+      this.fireChange();
+    }
+  }
+  /**
+   * Get the variable field by keyPath, similar to js code:
+   * `v.a.b`
+   * @param keyPath
+   * @returns
+   */
+  getByKeyPath(keyPath) {
+    if (this.type?.flags & 16 /* DrilldownType */) {
+      return this.type.getByKeyPath(keyPath);
+    }
+    return void 0;
+  }
+  /**
+   * Subscribe to type change of the variable field
+   * @param observer
+   * @returns
+   */
+  onTypeChange(observer) {
+    return this.subscribe(observer, { selector: (curr) => curr.type });
+  }
+  /**
+   * Serialize the variable field to JSON
+   * @returns ASTNodeJSON representation of `BaseVariableField`
+   */
+  toJSON() {
+    return {
+      key: this.key,
+      type: this.type?.toJSON(),
+      initializer: this.initializer?.toJSON(),
+      meta: this._meta
+    };
+  }
+};
+
+// src/ast/declaration/variable-declaration.ts
+var VariableDeclaration = class extends BaseVariableField {
+  constructor(params) {
+    super(params);
+    this._order = 0;
+  }
+  /**
+   * Variable sorting order, which is used to sort variables in `scope.outputs.variables`
+   */
+  get order() {
+    return this._order;
+  }
+  /**
+   * Deserialize the `VariableDeclarationJSON` to the `VariableDeclaration`.
+   */
+  fromJSON({ order, ...rest }) {
+    this.updateOrder(order);
+    super.fromJSON(rest);
+  }
+  /**
+   * Update the sorting order of the variable declaration.
+   * @param order Variable sorting order. Default is 0.
+   */
+  updateOrder(order = 0) {
+    if (order !== this._order) {
+      this._order = order;
+      this.dispatchGlobalEvent({
+        type: "ReSortVariableDeclarations"
+      });
+      this.fireChange();
+    }
+  }
+  /**
+   * Serialize the `VariableDeclaration` to `VariableDeclarationJSON`.
+   * @returns The JSON representation of `VariableDeclaration`.
+   */
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      order: this.order
+    };
+  }
+};
+VariableDeclaration.kind = "VariableDeclaration" /* VariableDeclaration */;
+
+// src/ast/declaration/variable-declaration-list.ts
+var VariableDeclarationList = class extends ASTNode {
+  constructor() {
+    super(...arguments);
+    /**
+     * Map of variable declarations, keyed by variable name.
+     */
+    this.declarationTable = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Deserialize the `VariableDeclarationListJSON` to the `VariableDeclarationList`.
+   * - VariableDeclarationListChangeAction will be dispatched after deserialization.
+   *
+   * @param declarations Variable declarations.
+   * @param startOrder The starting order number for variables. Default is 0.
+   */
+  fromJSON({ declarations, startOrder }) {
+    const removedKeys = new Set(this.declarationTable.keys());
+    const prev = [...this.declarations || []];
+    this.declarations = (declarations || []).map(
+      (declaration, idx) => {
+        const order = (startOrder || 0) + idx;
+        const declarationKey = declaration.key || this.declarations?.[idx]?.key;
+        const existDeclaration = this.declarationTable.get(declarationKey);
+        if (declarationKey) {
+          removedKeys.delete(declarationKey);
+        }
+        if (existDeclaration) {
+          existDeclaration.fromJSON({ order, ...declaration });
+          return existDeclaration;
+        } else {
+          const newDeclaration = this.createChildNode({
+            order,
+            ...declaration,
+            kind: "VariableDeclaration" /* VariableDeclaration */
+          });
+          this.fireChange();
+          this.declarationTable.set(newDeclaration.key, newDeclaration);
+          return newDeclaration;
+        }
+      }
+    );
+    removedKeys.forEach((key) => {
+      const declaration = this.declarationTable.get(key);
+      declaration?.dispose();
+      this.declarationTable.delete(key);
+    });
+    this.dispatchGlobalEvent({
+      type: "VariableListChange",
+      payload: {
+        prev,
+        next: [...this.declarations]
+      }
+    });
+  }
+  /**
+   * Serialize the `VariableDeclarationList` to the `VariableDeclarationListJSON`.
+   * @returns ASTJSON representation of `VariableDeclarationList`
+   */
+  toJSON() {
+    return {
+      kind: "VariableDeclarationList" /* VariableDeclarationList */,
+      declarations: this.declarations.map((_declaration) => _declaration.toJSON())
+    };
+  }
+};
+VariableDeclarationList.kind = "VariableDeclarationList" /* VariableDeclarationList */;
+
+// src/ast/declaration/property.ts
+var Property = class extends BaseVariableField {
+};
+Property.kind = "Property" /* Property */;
+var DataNode = class extends ASTNode {
+  /**
+   * The data of the node.
+   */
+  get data() {
+    return this._data;
+  }
+  /**
+   * Deserializes the `DataNodeJSON` to the `DataNode`.
+   * @param json The `DataNodeJSON` to deserialize.
+   */
+  fromJSON(json) {
+    const { kind, ...restData } = json;
+    if (!fastEquals.shallowEqual(restData, this._data)) {
+      this._data = restData;
+      this.fireChange();
+    }
+  }
+  /**
+   * Serialize the `DataNode` to `DataNodeJSON`.
+   * @returns The JSON representation of `DataNode`.
+   */
+  toJSON() {
+    return {
+      kind: "DataNode" /* DataNode */,
+      ...this._data
+    };
+  }
+  /**
+   * Partially update the data of the node.
+   * @param nextData The data to be updated.
+   */
+  partialUpdate(nextData) {
+    if (!fastEquals.shallowEqual(nextData, this._data)) {
+      this._data = {
+        ...this._data,
+        ...nextData
+      };
+      this.fireChange();
+    }
+  }
+};
+DataNode.kind = "DataNode" /* DataNode */;
+
+// src/ast/common/list-node.ts
+var ListNode = class extends ASTNode {
+  /**
+   * The list of nodes.
+   */
+  get list() {
+    return this._list;
+  }
+  /**
+   * Deserializes the `ListNodeJSON` to the `ListNode`.
+   * @param json The `ListNodeJSON` to deserialize.
+   */
+  fromJSON({ list }) {
+    this._list.slice(list.length).forEach((_item) => {
+      _item.dispose();
+      this.fireChange();
+    });
+    this._list = list.map((_item, idx) => {
+      const prevItem = this._list[idx];
+      if (prevItem.kind !== _item.kind) {
+        prevItem.dispose();
+        this.fireChange();
+        return this.createChildNode(_item);
+      }
+      prevItem.fromJSON(_item);
+      return prevItem;
+    });
+  }
+  /**
+   * Serialize the `ListNode` to `ListNodeJSON`.
+   * @returns The JSON representation of `ListNode`.
+   */
+  toJSON() {
+    return {
+      kind: "ListNode" /* ListNode */,
+      list: this._list.map((item) => item.toJSON())
+    };
+  }
+};
+ListNode.kind = "ListNode" /* ListNode */;
+
+// src/ast/common/map-node.ts
+var MapNode = class extends ASTNode {
+  constructor() {
+    super(...arguments);
+    this.map = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Deserializes the `MapNodeJSON` to the `MapNode`.
+   * @param json The `MapNodeJSON` to deserialize.
+   */
+  fromJSON({ map: map4 }) {
+    const removedKeys = new Set(this.map.keys());
+    for (const [key, item] of map4 || []) {
+      removedKeys.delete(key);
+      this.set(key, item);
+    }
+    for (const removeKey of Array.from(removedKeys)) {
+      this.remove(removeKey);
+    }
+  }
+  /**
+   * Serialize the `MapNode` to `MapNodeJSON`.
+   * @returns The JSON representation of `MapNode`.
+   */
+  toJSON() {
+    return {
+      kind: "MapNode" /* MapNode */,
+      map: Array.from(this.map.entries())
+    };
+  }
+  /**
+   * Set a node in the map.
+   * @param key The key of the node.
+   * @param nextJSON The JSON representation of the node.
+   * @returns The node instance.
+   */
+  set(key, nextJSON) {
+    return this.withBatchUpdate(updateChildNodeHelper).call(this, {
+      getChildNode: () => this.get(key),
+      removeChildNode: () => this.map.delete(key),
+      updateChildNode: (nextNode) => this.map.set(key, nextNode),
+      nextJSON
+    });
+  }
+  /**
+   * Remove a node from the map.
+   * @param key The key of the node.
+   */
+  remove(key) {
+    this.get(key)?.dispose();
+    this.map.delete(key);
+    this.fireChange();
+  }
+  /**
+   * Get a node from the map.
+   * @param key The key of the node.
+   * @returns The node instance if found, otherwise `undefined`.
+   */
+  get(key) {
+    return this.map.get(key);
+  }
+};
+MapNode.kind = "MapNode" /* MapNode */;
+
+// src/ast/ast-registers.ts
+exports.ASTRegisters = class ASTRegisters {
+  /**
+   * Core AST node registration.
+   */
+  constructor() {
+    /**
+     * @deprecated Please use `@injectToAst(XXXService) declare xxxService: XXXService` to achieve external dependency injection.
+     */
+    this.injectors = /* @__PURE__ */ new Map();
+    this.astMap = /* @__PURE__ */ new Map();
+    this.registerAST(StringType);
+    this.registerAST(NumberType);
+    this.registerAST(BooleanType);
+    this.registerAST(IntegerType);
+    this.registerAST(ObjectType);
+    this.registerAST(ArrayType);
+    this.registerAST(MapType);
+    this.registerAST(CustomType);
+    this.registerAST(Property);
+    this.registerAST(VariableDeclaration);
+    this.registerAST(VariableDeclarationList);
+    this.registerAST(KeyPathExpression);
+    this.registerAST(EnumerateExpression);
+    this.registerAST(WrapArrayExpression);
+    this.registerAST(MapNode);
+    this.registerAST(DataNode);
+  }
+  /**
+   * Creates an AST node.
+   * @param param Creation parameters.
+   * @returns
+   */
+  createAST(json, { parent, scope }) {
+    const Registry = this.astMap.get(json.kind);
+    if (!Registry) {
+      throw Error(`ASTKind: ${String(json.kind)} can not find its ASTNode Registry`);
+    }
+    const injector = this.injectors.get(json.kind);
+    const node = new Registry(
+      {
+        key: json.key,
+        scope,
+        parent
+      },
+      injector?.() || {}
+    );
+    node.changeLocked = true;
+    node.fromJSON(lodashEs.omit(json, ["key", "kind"]));
+    node.changeLocked = false;
+    node.dispatchGlobalEvent({ type: "NewAST" });
+    if (Reflect.hasMetadata(POST_CONSTRUCT_AST_SYMBOL, node)) {
+      const postConstructKey = Reflect.getMetadata(POST_CONSTRUCT_AST_SYMBOL, node);
+      node[postConstructKey]?.();
+    }
+    return node;
+  }
+  /**
+   * Gets the node Registry by AST node type.
+   * @param kind
+   * @returns
+   */
+  getASTRegistryByKind(kind) {
+    return this.astMap.get(kind);
+  }
+  /**
+   * Registers an AST node.
+   * @param ASTNode
+   */
+  registerAST(ASTNode2, injector) {
+    this.astMap.set(ASTNode2.kind, ASTNode2);
+    if (injector) {
+      this.injectors.set(ASTNode2.kind, injector);
+    }
+  }
+};
+exports.ASTRegisters = __decorateClass([
+  inversify.injectable()
+], exports.ASTRegisters);
+
+// src/ast/factory.ts
+exports.ASTFactory = void 0;
+((ASTFactory2) => {
+  ASTFactory2.createString = (json) => ({
+    kind: "String" /* String */,
+    ...json || {}
+  });
+  ASTFactory2.createNumber = () => ({ kind: "Number" /* Number */ });
+  ASTFactory2.createBoolean = () => ({ kind: "Boolean" /* Boolean */ });
+  ASTFactory2.createInteger = () => ({ kind: "Integer" /* Integer */ });
+  ASTFactory2.createObject = (json) => ({
+    kind: "Object" /* Object */,
+    ...json
+  });
+  ASTFactory2.createArray = (json) => ({
+    kind: "Array" /* Array */,
+    ...json
+  });
+  ASTFactory2.createMap = (json) => ({
+    kind: "Map" /* Map */,
+    ...json
+  });
+  ASTFactory2.createUnion = (json) => ({
+    kind: "Union" /* Union */,
+    ...json
+  });
+  ASTFactory2.createCustomType = (json) => ({
+    kind: "CustomType" /* CustomType */,
+    ...json
+  });
+  ASTFactory2.createVariableDeclaration = (json) => ({
+    kind: "VariableDeclaration" /* VariableDeclaration */,
+    ...json
+  });
+  ASTFactory2.createProperty = (json) => ({
+    kind: "Property" /* Property */,
+    ...json
+  });
+  ASTFactory2.createVariableDeclarationList = (json) => ({
+    kind: "VariableDeclarationList" /* VariableDeclarationList */,
+    ...json
+  });
+  ASTFactory2.createEnumerateExpression = (json) => ({
+    kind: "EnumerateExpression" /* EnumerateExpression */,
+    ...json
+  });
+  ASTFactory2.createKeyPathExpression = (json) => ({
+    kind: "KeyPathExpression" /* KeyPathExpression */,
+    ...json
+  });
+  ASTFactory2.createWrapArrayExpression = (json) => ({
+    kind: "WrapArrayExpression" /* WrapArrayExpression */,
+    ...json
+  });
+  ASTFactory2.create = (targetType, json) => ({ kind: targetType.kind, ...json });
+})(exports.ASTFactory || (exports.ASTFactory = {}));
+
+// src/scope/datas/scope-output-data.ts
+var ScopeOutputData = class {
+  constructor(scope) {
+    this.scope = scope;
+    this.memo = createMemo();
+    this._hasChanges = false;
+    this.variableTable = new VariableTable(scope.variableEngine.globalVariableTable);
+    this.scope.toDispose.pushAll([
+      // When the root AST node is updated, check if there are any changes.
+      this.scope.ast.subscribe(() => {
+        if (this._hasChanges) {
+          this.memo.clear();
+          this.notifyCoversChange();
+          this.variableTable.fireChange();
+          this._hasChanges = false;
+        }
+      }),
+      this.scope.event.on("DisposeAST", (_action) => {
+        if (_action.ast?.kind === "VariableDeclaration" /* VariableDeclaration */) {
+          this.removeVariableFromTable(_action.ast.key);
+        }
+      }),
+      this.scope.event.on("NewAST", (_action) => {
+        if (_action.ast?.kind === "VariableDeclaration" /* VariableDeclaration */) {
+          this.addVariableToTable(_action.ast);
+        }
+      }),
+      this.scope.event.on("ReSortVariableDeclarations", () => {
+        this._hasChanges = true;
+      }),
+      this.variableTable
+    ]);
+  }
+  /**
+   * The variable engine instance.
+   */
+  get variableEngine() {
+    return this.scope.variableEngine;
+  }
+  /**
+   * The global variable table from the variable engine.
+   */
+  get globalVariableTable() {
+    return this.scope.variableEngine.globalVariableTable;
+  }
+  /**
+   * The current version of the output data, which increments on each change.
+   */
+  get version() {
+    return this.variableTable.version;
+  }
+  /**
+   * @deprecated use onListOrAnyVarChange instead
+   */
+  get onDataChange() {
+    return this.variableTable.onDataChange.bind(this.variableTable);
+  }
+  /**
+   * An event that fires when the list of output variables changes.
+   */
+  get onVariableListChange() {
+    return this.variableTable.onVariableListChange.bind(this.variableTable);
+  }
+  /**
+   * An event that fires when any output variable's value changes.
+   */
+  get onAnyVariableChange() {
+    return this.variableTable.onAnyVariableChange.bind(this.variableTable);
+  }
+  /**
+   * An event that fires when the output variable list changes or any variable's value is updated.
+   */
+  get onListOrAnyVarChange() {
+    return this.variableTable.onListOrAnyVarChange.bind(this.variableTable);
+  }
+  /**
+   * The output variable declarations of the scope, sorted by order.
+   */
+  get variables() {
+    return this.memo(
+      "variables",
+      () => this.variableTable.variables.sort((a, b) => a.order - b.order)
+    );
+  }
+  /**
+   * The keys of the output variables.
+   */
+  get variableKeys() {
+    return this.memo("variableKeys", () => this.variableTable.variableKeys);
+  }
+  addVariableToTable(variable) {
+    if (variable.scope !== this.scope) {
+      throw Error("VariableDeclaration must be a ast node in scope");
+    }
+    this.variableTable.addVariableToTable(variable);
+    this._hasChanges = true;
+  }
+  removeVariableFromTable(key) {
+    this.variableTable.removeVariableFromTable(key);
+    this._hasChanges = true;
+  }
+  /**
+   * Retrieves a variable declaration by its key.
+   * @param key The key of the variable.
+   * @returns The `VariableDeclaration` or `undefined` if not found.
+   */
+  getVariableByKey(key) {
+    return this.variableTable.getVariableByKey(key);
+  }
+  /**
+   * Notifies the covering scopes that the available variables have changed.
+   */
+  notifyCoversChange() {
+    this.scope.coverScopes.forEach((scope) => scope.available.refresh());
+  }
+};
+var ScopeAvailableData = class {
+  constructor(scope) {
+    this.scope = scope;
+    this.memo = createMemo();
+    this._version = 0;
+    this.refresh$ = new rxjs.Subject();
+    this._variables = [];
+    /**
+     * An observable that emits when the list of available variables changes.
+     */
+    this.variables$ = this.refresh$.pipe(
+      // Map to the flattened list of variables from all dependency scopes.
+      rxjs.map(() => lodashEs.flatten(this.depScopes.map((scope) => scope.output.variables || []))),
+      // Use shallow equality to check if the variable list has changed.
+      rxjs.distinctUntilChanged(fastEquals.shallowEqual),
+      rxjs.share()
+    );
+    /**
+     * An observable that emits when any variable in the available list changes its value.
+     */
+    this.anyVariableChange$ = this.variables$.pipe(
+      rxjs.switchMap(
+        (_variables) => rxjs.merge(
+          ..._variables.map(
+            (_v) => _v.value$.pipe(
+              // Skip the initial value of the BehaviorSubject.
+              rxjs.skip(1)
+            )
+          )
+        )
+      ),
+      rxjs.share()
+    );
+    /**
+     * @deprecated
+     */
+    this.onDataChangeEmitter = new utils.Emitter();
+    this.onListOrAnyVarChangeEmitter = new utils.Emitter();
+    /**
+     * @deprecated use available.onListOrAnyVarChange instead
+     */
+    this.onDataChange = this.onDataChangeEmitter.event;
+    /**
+     * An event that fires when the variable list changes or any variable's value is updated.
+     */
+    this.onListOrAnyVarChange = this.onListOrAnyVarChangeEmitter.event;
+    this.scope.toDispose.pushAll([
+      this.onVariableListChange((_variables) => {
+        this._variables = _variables;
+        this.memo.clear();
+        this.onDataChangeEmitter.fire(this._variables);
+        this.bumpVersion();
+        this.onListOrAnyVarChangeEmitter.fire(this._variables);
+      }),
+      this.onAnyVariableChange(() => {
+        this.onDataChangeEmitter.fire(this._variables);
+        this.bumpVersion();
+        this.onListOrAnyVarChangeEmitter.fire(this._variables);
+      }),
+      utils.Disposable.create(() => {
+        this.refresh$.complete();
+        this.refresh$.unsubscribe();
+      })
+    ]);
+  }
+  /**
+   * The global variable table from the variable engine.
+   */
+  get globalVariableTable() {
+    return this.scope.variableEngine.globalVariableTable;
+  }
+  /**
+   * The current version of the available data, which increments on each change.
+   */
+  get version() {
+    return this._version;
+  }
+  bumpVersion() {
+    this._version = this._version + 1;
+    if (this._version === Number.MAX_SAFE_INTEGER) {
+      this._version = 0;
+    }
+  }
+  /**
+   * Refreshes the list of available variables.
+   * This should be called when the dependencies of the scope change.
+   */
+  refresh() {
+    if (this.scope.disposed) {
+      return;
+    }
+    this.refresh$.next();
+  }
+  /**
+   * Subscribes to changes in any variable's value in the available list.
+   * @param observer A function to be called with the changed variable.
+   * @returns A disposable to unsubscribe from the changes.
+   */
+  onAnyVariableChange(observer) {
+    return subsToDisposable(this.anyVariableChange$.subscribe(observer));
+  }
+  /**
+   * Subscribes to changes in the list of available variables.
+   * @param observer A function to be called with the new list of variables.
+   * @returns A disposable to unsubscribe from the changes.
+   */
+  onVariableListChange(observer) {
+    return subsToDisposable(this.variables$.subscribe(observer));
+  }
+  /**
+   * Gets the list of available variables.
+   */
+  get variables() {
+    return this._variables;
+  }
+  /**
+   * Gets the keys of the available variables.
+   */
+  get variableKeys() {
+    return this.memo("availableKeys", () => this._variables.map((_v) => _v.key));
+  }
+  /**
+   * Gets the dependency scopes.
+   */
+  get depScopes() {
+    return this.scope.depScopes;
+  }
+  /**
+   * Retrieves a variable field by its key path from the available variables.
+   * @param keyPath The key path to the variable field.
+   * @returns The found `BaseVariableField` or `undefined`.
+   */
+  getByKeyPath(keyPath = []) {
+    if (!this.variableKeys.includes(keyPath[0])) {
+      return;
+    }
+    return this.globalVariableTable.getByKeyPath(keyPath);
+  }
+  /**
+   * Tracks changes to a variable field by its key path.
+   * This includes changes to its type, value, or any nested properties.
+   * @param keyPath The key path to the variable field to track.
+   * @param cb The callback to execute when the variable changes.
+   * @param opts Configuration options for the subscription.
+   * @returns A disposable to unsubscribe from the tracking.
+   */
+  trackByKeyPath(keyPath = [], cb, opts) {
+    const { triggerOnInit = true, debounceAnimation, selector } = opts || {};
+    return subsToDisposable(
+      rxjs.merge(this.anyVariableChange$, this.variables$).pipe(
+        triggerOnInit ? rxjs.startWith() : rxjs.tap(() => null),
+        rxjs.map(() => {
+          const v = this.getByKeyPath(keyPath);
+          return selector ? selector(v) : v;
+        }),
+        rxjs.distinctUntilChanged(
+          (a, b) => fastEquals.shallowEqual(a, b),
+          (value) => {
+            if (value instanceof ASTNode) {
+              return value.hash;
+            }
+            return value;
+          }
+        ),
+        // Debounce updates to a single emission per animation frame.
+        debounceAnimation ? rxjs.debounceTime(0, rxjs.animationFrameScheduler) : rxjs.tap(() => null)
+      ).subscribe(cb)
+    );
+  }
+};
+var ScopeEventData = class {
+  constructor(scope) {
+    this.scope = scope;
+    this.event$ = new rxjs.Subject();
+    scope.toDispose.pushAll([
+      this.subscribe((_action) => {
+        scope.variableEngine.fireGlobalEvent(_action);
+      })
+    ]);
+  }
+  /**
+   * Dispatches a global event.
+   * @param action The event action to dispatch.
+   */
+  dispatch(action) {
+    if (this.scope.disposed) {
+      return;
+    }
+    this.event$.next(action);
+  }
+  /**
+   * Subscribes to all global events.
+   * @param observer The observer function to call with the event action.
+   * @returns A disposable to unsubscribe from the events.
+   */
+  subscribe(observer) {
+    return subsToDisposable(this.event$.subscribe(observer));
+  }
+  /**
+   * Subscribes to a specific type of global event.
+   * @param type The type of the event to subscribe to.
+   * @param observer The observer function to call with the event action.
+   * @returns A disposable to unsubscribe from the event.
+   */
+  on(type, observer) {
+    return subsToDisposable(
+      this.event$.pipe(rxjs.filter((_action) => _action.type === type)).subscribe(observer)
+    );
+  }
+};
+
+// src/scope/scope.ts
+var Scope = class {
+  constructor(options) {
+    /**
+     * A memoization utility for caching computed values.
+     */
+    this.memo = createMemo();
+    this.toDispose = new utils.DisposableCollection();
+    this.onDispose = this.toDispose.onDispose;
+    this.id = options.id;
+    this.meta = options.meta || {};
+    this.variableEngine = options.variableEngine;
+    this.event = new ScopeEventData(this);
+    this.ast = this.variableEngine.astRegisters.createAST(
+      {
+        kind: "MapNode" /* MapNode */,
+        key: String(this.id)
+      },
+      {
+        scope: this
+      }
+    );
+    this.output = new ScopeOutputData(this);
+    this.available = new ScopeAvailableData(this);
+  }
+  /**
+   * Refreshes the covering scopes.
+   */
+  refreshCovers() {
+    this.memo.clear("covers");
+  }
+  /**
+   * Refreshes the dependency scopes and the available variables.
+   */
+  refreshDeps() {
+    this.memo.clear("deps");
+    this.available.refresh();
+  }
+  /**
+   * Gets the scopes that this scope depends on.
+   */
+  get depScopes() {
+    return this.memo(
+      "deps",
+      () => this.variableEngine.chain.getDeps(this).filter((_scope) => Boolean(_scope) && !_scope?.disposed)
+    );
+  }
+  /**
+   * Gets the scopes that are covered by this scope.
+   */
+  get coverScopes() {
+    return this.memo(
+      "covers",
+      () => this.variableEngine.chain.getCovers(this).filter((_scope) => Boolean(_scope) && !_scope?.disposed)
+    );
+  }
+  /**
+   * Disposes of the scope and its resources.
+   * This will also trigger updates in dependent and covering scopes.
+   */
+  dispose() {
+    this.ast.dispose();
+    this.toDispose.dispose();
+    this.coverScopes.forEach((_scope) => _scope.refreshDeps());
+    this.depScopes.forEach((_scope) => _scope.refreshCovers());
+  }
+  get disposed() {
+    return this.toDispose.disposed;
+  }
+  setVar(arg1, arg2) {
+    if (typeof arg1 === "string" && arg2 !== void 0) {
+      return this.ast.set(arg1, arg2);
+    }
+    if (typeof arg1 === "object" && arg2 === void 0) {
+      return this.ast.set("outputs", arg1);
+    }
+    throw new Error("Invalid arguments");
+  }
+  /**
+   * Retrieves a variable from the scope by its key.
+   *
+   * @param key The key of the variable to retrieve. Defaults to 'outputs'.
+   * @returns The AST node for the variable, or `undefined` if not found.
+   */
+  getVar(key = "outputs") {
+    return this.ast.get(key);
+  }
+  /**
+   * Clears a variable from the scope by its key.
+   *
+   * @param key The key of the variable to clear. Defaults to 'outputs'.
+   */
+  clearVar(key = "outputs") {
+    return this.ast.remove(key);
+  }
+};
+
+// src/variable-engine.ts
+exports.VariableEngine = class VariableEngine {
+  constructor(chain, astRegisters) {
+    this.chain = chain;
+    this.astRegisters = astRegisters;
+    this.toDispose = new utils.DisposableCollection();
+    this.memo = createMemo();
+    this.scopeMap = /* @__PURE__ */ new Map();
+    /**
+     * A rxjs subject that emits global events occurring within the variable engine.
+     */
+    this.globalEvent$ = new rxjs.Subject();
+    this.onScopeChangeEmitter = new utils.Emitter();
+    /**
+     * A table containing all global variables.
+     */
+    this.globalVariableTable = new VariableTable();
+    /**
+     * An event that fires whenever a scope is added, updated, or deleted.
+     */
+    this.onScopeChange = this.onScopeChangeEmitter.event;
+    this.toDispose.pushAll([
+      chain,
+      utils.Disposable.create(() => {
+        this.getAllScopes().forEach((scope) => scope.dispose());
+        this.globalVariableTable.dispose();
+      })
+    ]);
+  }
+  /**
+   * The Inversify container instance.
+   */
+  get container() {
+    return this.containerProvider();
+  }
+  dispose() {
+    this.toDispose.dispose();
+  }
+  /**
+   * Retrieves a scope by its unique identifier.
+   * @param scopeId The ID of the scope to retrieve.
+   * @returns The scope if found, otherwise undefined.
+   */
+  getScopeById(scopeId) {
+    return this.scopeMap.get(scopeId);
+  }
+  /**
+   * Removes a scope by its unique identifier and disposes of it.
+   * @param scopeId The ID of the scope to remove.
+   */
+  removeScopeById(scopeId) {
+    this.getScopeById(scopeId)?.dispose();
+  }
+  /**
+   * Creates a new scope or retrieves an existing one if the ID and type match.
+   * @param id The unique identifier for the scope.
+   * @param meta Optional metadata for the scope, defined by the user.
+   * @param options Options for creating the scope.
+   * @param options.ScopeConstructor The constructor to use for creating the scope. Defaults to `Scope`.
+   * @returns The created or existing scope.
+   */
+  createScope(id, meta, options = {}) {
+    const { ScopeConstructor = Scope } = options;
+    let scope = this.getScopeById(id);
+    if (!scope) {
+      scope = new ScopeConstructor({ variableEngine: this, meta, id });
+      this.scopeMap.set(id, scope);
+      this.onScopeChangeEmitter.fire({ type: "add", scope });
+      scope.toDispose.pushAll([
+        scope.ast.subscribe(() => {
+          this.onScopeChangeEmitter.fire({ type: "update", scope });
+        }),
+        // Fires when available variables change
+        scope.available.onDataChange(() => {
+          this.onScopeChangeEmitter.fire({ type: "available", scope });
+        })
+      ]);
+      scope.onDispose(() => {
+        this.scopeMap.delete(id);
+        this.onScopeChangeEmitter.fire({ type: "delete", scope });
+      });
+    }
+    return scope;
+  }
+  /**
+   * Retrieves all scopes currently managed by the engine.
+   * @param options Options for retrieving the scopes.
+   * @param options.sort Whether to sort the scopes based on their dependency chain.
+   * @returns An array of all scopes.
+   */
+  getAllScopes({
+    sort
+  } = {}) {
+    const allScopes = Array.from(this.scopeMap.values());
+    if (sort) {
+      const sortScopes = this.chain.sortAll();
+      const remainScopes = new Set(allScopes);
+      sortScopes.forEach((_scope) => remainScopes.delete(_scope));
+      return [...sortScopes, ...Array.from(remainScopes)];
+    }
+    return [...allScopes];
+  }
+  /**
+   * Fires a global event to be broadcast to all listeners.
+   * @param event The global event to fire.
+   */
+  fireGlobalEvent(event) {
+    this.globalEvent$.next(event);
+  }
+  /**
+   * Subscribes to a specific type of global event.
+   * @param type The type of the event to listen for.
+   * @param observer A function to be called when the event is observed.
+   * @returns A disposable object to unsubscribe from the event.
+   */
+  onGlobalEvent(type, observer) {
+    return subsToDisposable(
+      this.globalEvent$.subscribe((_action) => {
+        if (_action.type === type) {
+          observer(_action);
+        }
+      })
+    );
+  }
+};
+__decorateClass([
+  inversify.inject(ContainerProvider)
+], exports.VariableEngine.prototype, "containerProvider", 2);
+__decorateClass([
+  inversify.preDestroy()
+], exports.VariableEngine.prototype, "dispose", 1);
+exports.VariableEngine = __decorateClass([
+  inversify.injectable(),
+  __decorateParam(0, inversify.inject(exports.ScopeChain)),
+  __decorateParam(1, inversify.inject(exports.ASTRegisters))
+], exports.VariableEngine);
+exports.VariableFieldKeyRenameService = class VariableFieldKeyRenameService {
+  constructor() {
+    this.toDispose = new utils.DisposableCollection();
+    this.renameEmitter = new utils.Emitter();
+    /**
+     * Emits events for fields that are disposed of during a list change, but not renamed.
+     * This helps distinguish between a field that was truly removed and one that was renamed.
+     */
+    this.disposeInListEmitter = new utils.Emitter();
+    /**
+     * An event that fires when a variable field key is successfully renamed.
+     */
+    this.onRename = this.renameEmitter.event;
+    /**
+     * An event that fires when a field is removed from a list (and not part of a rename).
+     */
+    this.onDisposeInList = this.disposeInListEmitter.event;
+  }
+  /**
+   * Handles changes in a list of fields to detect rename operations.
+   * @param ast The AST node where the change occurred.
+   * @param prev The list of fields before the change.
+   * @param next The list of fields after the change.
+   */
+  handleFieldListChange(ast, prev, next) {
+    if (!ast || !prev?.length || !next?.length) {
+      this.notifyFieldsDispose(prev, next);
+      return;
+    }
+    if (prev.length !== next.length) {
+      this.notifyFieldsDispose(prev, next);
+      return;
+    }
+    let renameNodeInfo = null;
+    let existFieldChanged = false;
+    for (const [index, prevField] of prev.entries()) {
+      const nextField = next[index];
+      if (prevField.key !== nextField.key) {
+        if (existFieldChanged) {
+          this.notifyFieldsDispose(prev, next);
+          return;
+        }
+        existFieldChanged = true;
+        if (prevField.type?.kind === nextField.type?.kind) {
+          renameNodeInfo = { before: prevField, after: nextField };
+        }
+      }
+    }
+    if (!renameNodeInfo) {
+      this.notifyFieldsDispose(prev, next);
+      return;
+    }
+    this.renameEmitter.fire(renameNodeInfo);
+  }
+  /**
+   * Notifies listeners about fields that were removed from a list.
+   * @param prev The list of fields before the change.
+   * @param next The list of fields after the change.
+   */
+  notifyFieldsDispose(prev, next) {
+    const removedFields = lodashEs.difference(prev || [], next || []);
+    removedFields.forEach((_field) => this.disposeInListEmitter.fire(_field));
+  }
+  init() {
+    this.toDispose.pushAll([
+      this.variableEngine.onGlobalEvent(
+        "VariableListChange",
+        (_action) => {
+          this.handleFieldListChange(_action.ast, _action.payload?.prev, _action.payload?.next);
+        }
+      ),
+      this.variableEngine.onGlobalEvent(
+        "ObjectPropertiesChange",
+        (_action) => {
+          this.handleFieldListChange(_action.ast, _action.payload?.prev, _action.payload?.next);
+        }
+      )
+    ]);
+  }
+  dispose() {
+    this.toDispose.dispose();
+  }
+};
+__decorateClass([
+  inversify.inject(exports.VariableEngine)
+], exports.VariableFieldKeyRenameService.prototype, "variableEngine", 2);
+__decorateClass([
+  inversify.postConstruct()
+], exports.VariableFieldKeyRenameService.prototype, "init", 1);
+__decorateClass([
+  inversify.preDestroy()
+], exports.VariableFieldKeyRenameService.prototype, "dispose", 1);
+exports.VariableFieldKeyRenameService = __decorateClass([
+  inversify.injectable()
+], exports.VariableFieldKeyRenameService);
+
+// src/variable-container-module.ts
+var VariableContainerModule = new inversify.ContainerModule((bind) => {
+  bind(exports.VariableEngine).toSelf().inSingletonScope();
+  bind(exports.ASTRegisters).toSelf().inSingletonScope();
+  bind(exports.VariableFieldKeyRenameService).toSelf().inSingletonScope();
+  bind(VariableEngineProvider).toDynamicValue((ctx) => () => ctx.container.get(exports.VariableEngine));
+  bind(ContainerProvider).toDynamicValue((ctx) => () => ctx.container);
+});
+var ScopeKey = /* @__PURE__ */ Symbol("Scope");
+var ScopeProvider = vue.defineComponent({
+  name: "ScopeProvider",
+  props: {
+    /**
+     * scope used in the context
+     */
+    scope: {
+      type: Object
+    },
+    /**
+     * @deprecated use scope prop instead, this is kept for backward compatibility
+     */
+    value: {
+      type: Object
+    }
+  },
+  setup(props, { slots }) {
+    const scopeToUse = vue.computed(() => props.scope || props.value?.scope);
+    if (!scopeToUse.value) {
+      throw new Error("[ScopeProvider] scope is required");
+    }
+    vue.provide(ScopeKey, scopeToUse);
+    return () => slots.default?.();
+  }
+});
+var useCurrentScope = (params) => {
+  const { strict = false } = params || {};
+  const context = vue.inject(ScopeKey, void 0);
+  if (!context) {
+    if (strict) {
+      throw new Error("useCurrentScope must be used within a <ScopeProvider scope={scope}>");
+    }
+    console.warn("useCurrentScope should be used within a <ScopeProvider scope={scope}>");
+  }
+  return vue.unref(context);
+};
+function useScopeAvailable(params) {
+  const { autoRefresh = true } = params || {};
+  const scope = useCurrentScope({ strict: true });
+  const tick = vue.shallowRef(0);
+  if (autoRefresh) {
+    const disposable = scope.available.onListOrAnyVarChange(() => {
+      tick.value += 1;
+    });
+    vue.onScopeDispose(() => disposable.dispose());
+  }
+  return vue.computed(() => {
+    tick.value;
+    return scope.available;
+  });
+}
+function useAvailableVariables() {
+  const scope = useCurrentScope();
+  const variableEngine = core.useService(exports.VariableEngine);
+  const tick = vue.shallowRef(0);
+  const disposable = !scope ? variableEngine.globalVariableTable.onListOrAnyVarChange(() => {
+    tick.value += 1;
+  }) : scope.available.onDataChange(() => {
+    tick.value += 1;
+  });
+  vue.onScopeDispose(() => disposable.dispose());
+  return vue.computed(() => {
+    tick.value;
+    return scope ? scope.available.variables : variableEngine.globalVariableTable.variables;
+  });
+}
+function useOutputVariables() {
+  const scope = useCurrentScope();
+  const tick = vue.shallowRef(0);
+  if (!scope) {
+    throw new Error(
+      "[useOutputVariables]: No scope found, useOutputVariables must be used in <ScopeProvider>"
+    );
+  }
+  const disposable = scope.output.onListOrAnyVarChange(() => {
+    tick.value += 1;
+  });
+  vue.onScopeDispose(() => disposable.dispose());
+  return vue.computed(() => {
+    tick.value;
+    return scope.output.variables;
+  });
+}
+
+exports.ASTKind = ASTKind;
+exports.ASTNode = ASTNode;
+exports.ASTNodeFlags = ASTNodeFlags;
+exports.ArrayType = ArrayType;
+exports.BaseExpression = BaseExpression;
+exports.BaseType = BaseType;
+exports.BaseVariableField = BaseVariableField;
+exports.BooleanType = BooleanType;
+exports.CustomType = CustomType;
+exports.DataNode = DataNode;
+exports.EnumerateExpression = EnumerateExpression;
+exports.IntegerType = IntegerType;
+exports.KeyPathExpression = KeyPathExpression;
+exports.LegacyKeyPathExpression = LegacyKeyPathExpression;
+exports.ListNode = ListNode;
+exports.MapNode = MapNode;
+exports.MapType = MapType;
+exports.NumberType = NumberType;
+exports.ObjectType = ObjectType;
+exports.Property = Property;
+exports.Scope = Scope;
+exports.ScopeKey = ScopeKey;
+exports.ScopeOutputData = ScopeOutputData;
+exports.ScopeProvider = ScopeProvider;
+exports.StringType = StringType;
+exports.VariableContainerModule = VariableContainerModule;
+exports.VariableDeclaration = VariableDeclaration;
+exports.VariableDeclarationList = VariableDeclarationList;
+exports.VariableEngineProvider = VariableEngineProvider;
+exports.WrapArrayExpression = WrapArrayExpression;
+exports.injectToAST = injectToAST;
+exports.isMatchAST = isMatchAST;
+exports.postConstructAST = postConstructAST;
+exports.useAvailableVariables = useAvailableVariables;
+exports.useCurrentScope = useCurrentScope;
+exports.useOutputVariables = useOutputVariables;
+exports.useScopeAvailable = useScopeAvailable;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map