@flowgram.ai/variable-layout 0.1.0-alpha.10

package/dist/index.js

@@ -0,0 +1,689 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+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);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  FixedLayoutScopeChain: () => FixedLayoutScopeChain,
+  FlowNodeScopeType: () => FlowNodeScopeTypeEnum,
+  FlowNodeVariableData: () => FlowNodeVariableData,
+  FreeLayoutScopeChain: () => FreeLayoutScopeChain,
+  GlobalScope: () => GlobalScope,
+  ScopeChainTransformService: () => ScopeChainTransformService,
+  VariableChainConfig: () => VariableChainConfig,
+  bindGlobalScope: () => bindGlobalScope,
+  getNodePrivateScope: () => getNodePrivateScope,
+  getNodeScope: () => getNodeScope
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/flow-node-variable-data.ts
+var import_core = require("@flowgram.ai/core");
+
+// src/types.ts
+var FlowNodeScopeTypeEnum = /* @__PURE__ */ ((FlowNodeScopeTypeEnum2) => {
+  FlowNodeScopeTypeEnum2["public"] = "public";
+  FlowNodeScopeTypeEnum2["private"] = "private";
+  return FlowNodeScopeTypeEnum2;
+})(FlowNodeScopeTypeEnum || {});
+
+// src/flow-node-variable-data.ts
+var FlowNodeVariableData = class extends import_core.EntityData {
+  constructor(entity, opts) {
+    super(entity);
+    this.opts = opts;
+    const { variableEngine } = opts || {};
+    this.variableEngine = variableEngine;
+    this._public = this.variableEngine.createScope(this.entity.id, {
+      node: this.entity,
+      type: "public" /* public */
+    });
+    this.toDispose.push(this._public);
+  }
+  get private() {
+    return this._private;
+  }
+  get public() {
+    return this._public;
+  }
+  setVar(arg1, arg2) {
+    if (typeof arg1 === "string" && arg2 !== void 0) {
+      return this.public.ast.set(arg1, arg2);
+    }
+    if (typeof arg1 === "object" && arg2 === void 0) {
+      return this.public.ast.set("outputs", arg1);
+    }
+    throw new Error("Invalid arguments");
+  }
+  /**
+   * Retrieves a variable from the public AST (Abstract Syntax Tree) by key.
+   *
+   * @param key - The key of the variable to retrieve. Defaults to 'outputs'.
+   * @returns The value of the variable, or undefined if not found.
+   */
+  getVar(key = "outputs") {
+    return this.public.ast.get(key);
+  }
+  /**
+   * Clears a variable from the public AST (Abstract Syntax Tree) by key.
+   *
+   * @param key - The key of the variable to clear. Defaults to 'outputs'.
+   * @returns The updated AST node.
+   */
+  clearVar(key = "outputs") {
+    return this.public.ast.remove(key);
+  }
+  setPrivateVar(arg1, arg2) {
+    if (typeof arg1 === "string" && arg2 !== void 0) {
+      return this.initPrivate().ast.set(arg1, arg2);
+    }
+    if (typeof arg1 === "object" && arg2 === void 0) {
+      return this.initPrivate().ast.set("outputs", arg1);
+    }
+    throw new Error("Invalid arguments");
+  }
+  /**
+   * Retrieves a variable from the private AST (Abstract Syntax Tree) by key.
+   *
+   * @param key - The key of the variable to retrieve. Defaults to 'outputs'.
+   * @returns The value of the variable, or undefined if not found.
+   */
+  getPrivateVar(key = "outputs") {
+    return this.private?.ast.get(key);
+  }
+  /**
+   * Clears a variable from the private AST (Abstract Syntax Tree) by key.
+   *
+   * @param key - The key of the variable to clear. Defaults to 'outputs'.
+   * @returns The updated AST node.
+   */
+  clearPrivateVar(key = "outputs") {
+    return this.private?.ast.remove(key);
+  }
+  get allScopes() {
+    const res = [];
+    if (this._public) {
+      res.push(this._public);
+    }
+    if (this._private) {
+      res.push(this._private);
+    }
+    return res;
+  }
+  getDefaultData() {
+    return {};
+  }
+  initPrivate() {
+    if (!this._private) {
+      this._private = this.variableEngine.createScope(`${this.entity.id}_private`, {
+        node: this.entity,
+        type: "private" /* private */
+      });
+      this.variableEngine.chain.refreshAllChange();
+      this.toDispose.push(this._private);
+    }
+    return this._private;
+  }
+  /**
+   * Find a variable field by key path in the public scope by scope chain.
+   * @param keyPath - The key path of the variable field.
+   * @returns The variable field, or undefined if not found.
+   */
+  getByKeyPath(keyPath) {
+    return this.public.available.getByKeyPath(keyPath);
+  }
+  /**
+   * Find a variable field by key path in the private scope by scope chain.
+   * @param keyPath - The key path of the variable field.
+   * @returns The variable field, or undefined if not found.
+   */
+  getByKeyPathInPrivate(keyPath) {
+    return this.private?.available.getByKeyPath(keyPath);
+  }
+};
+FlowNodeVariableData.type = "FlowNodeVariableData";
+
+// src/chains/free-layout-scope-chain.ts
+var import_inversify3 = require("inversify");
+var import_variable_core3 = require("@flowgram.ai/variable-core");
+var import_free_layout_core = require("@flowgram.ai/free-layout-core");
+var import_document2 = require("@flowgram.ai/document");
+var import_core3 = require("@flowgram.ai/core");
+
+// src/variable-chain-config.ts
+var VariableChainConfig = Symbol("VariableChainConfig");
+
+// src/services/scope-chain-transform-service.ts
+var import_inversify = require("inversify");
+var import_variable_core = require("@flowgram.ai/variable-core");
+var import_document = require("@flowgram.ai/document");
+var import_core2 = require("@flowgram.ai/core");
+var passthrough = (scopes, ctx) => scopes;
+var ScopeChainTransformService = class {
+  constructor(configs) {
+    this.configs = configs;
+    this.transformerMap = /* @__PURE__ */ new Map();
+    if (this.configs?.transformDeps || this.configs?.transformCovers) {
+      this.transformerMap.set("VARIABLE_LAYOUT_CONFIG", {
+        transformDeps: this.configs.transformDeps || passthrough,
+        transformCovers: this.configs.transformCovers || passthrough
+      });
+    }
+  }
+  /**
+   * check if transformer registered
+   * @param transformerId used to identify transformer, prevent duplicated
+   * @returns
+   */
+  hasTransformer(transformerId) {
+    return this.transformerMap.has(transformerId);
+  }
+  /**
+   * register new transform function
+   * @param transformerId used to identify transformer, prevent duplicated transformer
+   * @param transformer
+   */
+  registerTransformer(transformerId, transformer) {
+    this.transformerMap.set(transformerId, transformer);
+  }
+  transformDeps(scopes, { scope }) {
+    return Array.from(this.transformerMap.values()).reduce((scopes2, transformer) => {
+      if (!transformer.transformDeps) {
+        return scopes2;
+      }
+      scopes2 = transformer.transformDeps(scopes2, {
+        scope,
+        document: this.document,
+        variableEngine: this.variableEngine
+      });
+      return scopes2;
+    }, scopes);
+  }
+  transformCovers(scopes, { scope }) {
+    return Array.from(this.transformerMap.values()).reduce((scopes2, transformer) => {
+      if (!transformer.transformCovers) {
+        return scopes2;
+      }
+      scopes2 = transformer.transformCovers(scopes2, {
+        scope,
+        document: this.document,
+        variableEngine: this.variableEngine
+      });
+      return scopes2;
+    }, scopes);
+  }
+};
+__decorateClass([
+  (0, import_core2.lazyInject)(import_document.FlowDocument)
+], ScopeChainTransformService.prototype, "document", 2);
+__decorateClass([
+  (0, import_core2.lazyInject)(import_variable_core.VariableEngine)
+], ScopeChainTransformService.prototype, "variableEngine", 2);
+ScopeChainTransformService = __decorateClass([
+  (0, import_inversify.injectable)(),
+  __decorateParam(0, (0, import_inversify.optional)()),
+  __decorateParam(0, (0, import_inversify.inject)(VariableChainConfig))
+], ScopeChainTransformService);
+
+// src/scopes/global-scope.ts
+var import_inversify2 = require("inversify");
+var import_variable_core2 = require("@flowgram.ai/variable-core");
+var GlobalScope = class extends import_variable_core2.Scope {
+  static is(scope) {
+    return scope.id === GlobalScope.ID;
+  }
+};
+GlobalScope.ID = Symbol("GlobalScope");
+GlobalScope = __decorateClass([
+  (0, import_inversify2.injectable)()
+], GlobalScope);
+var bindGlobalScope = (bind) => {
+  bind(GlobalScope).toDynamicValue((ctx) => {
+    const variableEngine = ctx.container.get(import_variable_core2.VariableEngine);
+    let scope = variableEngine.getScopeById(GlobalScope.ID);
+    if (!scope) {
+      scope = variableEngine.createScope(
+        GlobalScope.ID,
+        {},
+        { ScopeConstructor: GlobalScope }
+      );
+      variableEngine.chain.refreshAllChange();
+    }
+    return scope;
+  });
+};
+
+// src/chains/free-layout-scope-chain.ts
+var FreeLayoutScopeChain = class extends import_variable_core3.ScopeChain {
+  get tree() {
+    return this.flowDocument.originTree;
+  }
+  onInit() {
+    this.toDispose.pushAll([
+      // 线条发生变化时，会触发作用域链的更新
+      this.entityManager.onEntityDataChange(({ entityDataType }) => {
+        if (entityDataType === import_free_layout_core.WorkflowNodeLinesData.type) {
+          this.refreshAllChange();
+        }
+      }),
+      // 树变化时候刷新作用域
+      this.tree.onTreeChange(() => {
+        this.refreshAllChange();
+      })
+    ]);
+  }
+  // 获取同一层级所有输入节点
+  getAllInputLayerNodes(curr) {
+    const currParent = this.getNodeParent(curr);
+    return (curr.getData(import_free_layout_core.WorkflowNodeLinesData)?.allInputNodes || []).filter(
+      (_node) => this.getNodeParent(_node) === currParent
+    );
+  }
+  // 获取同一层级所有输出节点
+  getAllOutputLayerNodes(curr) {
+    const currParent = this.getNodeParent(curr);
+    return (curr.getData(import_free_layout_core.WorkflowNodeLinesData)?.allOutputNodes || []).filter(
+      (_node) => this.getNodeParent(_node) === currParent
+    );
+  }
+  getDeps(scope) {
+    const { node } = scope.meta || {};
+    if (!node) {
+      return this.transformService.transformDeps([], { scope });
+    }
+    const deps = [];
+    let curr = node;
+    while (curr) {
+      const allInputNodes = this.getAllInputLayerNodes(curr);
+      deps.push(
+        ...allInputNodes.map((_node) => _node.getData(FlowNodeVariableData).public).filter(Boolean)
+      );
+      deps.push(...allInputNodes.map((_node) => this.getAllPublicChildScopes(_node)).flat());
+      const currVarData = curr.getData(FlowNodeVariableData);
+      if (currVarData?.private && scope !== currVarData.private) {
+        deps.push(currVarData.private);
+      }
+      curr = this.getNodeParent(curr);
+    }
+    const globalScope = this.variableEngine.getScopeById(GlobalScope.ID);
+    if (globalScope) {
+      deps.unshift(globalScope);
+    }
+    const uniqDeps = Array.from(new Set(deps));
+    return this.transformService.transformDeps(uniqDeps, { scope });
+  }
+  getCovers(scope) {
+    if (GlobalScope.is(scope)) {
+      const scopes2 = this.variableEngine.getAllScopes({ sort: true }).filter((_scope) => !GlobalScope.is(_scope));
+      return this.transformService.transformCovers(scopes2, { scope });
+    }
+    const { node } = scope.meta || {};
+    if (!node) {
+      return this.transformService.transformCovers([], { scope });
+    }
+    const isPrivate = scope.meta.type === "private" /* private */;
+    const queue = [];
+    if (isPrivate) {
+      queue.push(...this.getNodeChildren(node));
+    } else {
+      queue.push(...this.getAllOutputLayerNodes(node) || []);
+      let parent = this.getNodeParent(node);
+      while (parent) {
+        if (this.isNodeChildrenPrivate(parent)) {
+          break;
+        }
+        queue.push(...this.getAllOutputLayerNodes(parent));
+        parent = this.getNodeParent(parent);
+      }
+    }
+    const scopes = [];
+    while (queue.length) {
+      const _node = queue.shift();
+      const variableData = _node.getData(FlowNodeVariableData);
+      scopes.push(...variableData.allScopes);
+      const children = _node && this.getNodeChildren(_node);
+      if (children?.length) {
+        queue.push(...children);
+      }
+    }
+    const currentVariableData = node.getData(FlowNodeVariableData);
+    if (isPrivate && currentVariableData.public) {
+      scopes.push(currentVariableData.public);
+    }
+    const uniqScopes = Array.from(new Set(scopes));
+    return this.transformService.transformCovers(uniqScopes, { scope });
+  }
+  getNodeChildren(node) {
+    if (this.configs?.getNodeChildren) {
+      return this.configs.getNodeChildren?.(node);
+    }
+    const nodeMeta = node.getNodeMeta();
+    const subCanvas = nodeMeta.subCanvas?.(node);
+    if (subCanvas) {
+      if (subCanvas.isCanvas) {
+        return [];
+      } else {
+        return subCanvas.canvasNode.collapsedChildren;
+      }
+    }
+    return this.tree.getChildren(node);
+  }
+  /**
+   * Get All children of nodes
+   * @param node
+   * @returns
+   */
+  getAllPublicChildScopes(node) {
+    if (this.isNodeChildrenPrivate(node)) {
+      return [];
+    }
+    return this.getNodeChildren(node).map((_node) => [
+      _node.getData(FlowNodeVariableData).public,
+      ...this.getAllPublicChildScopes(_node)
+    ]).flat();
+  }
+  getNodeParent(node) {
+    if (this.configs?.getNodeParent) {
+      return this.configs.getNodeParent(node);
+    }
+    let parent = node.document.originTree.getParent(node);
+    while (parent?.flowNodeType === import_document2.FlowNodeBaseType.GROUP) {
+      parent = parent.parent;
+    }
+    if (!parent) {
+      return parent;
+    }
+    const nodeMeta = parent.getNodeMeta();
+    const subCanvas = nodeMeta.subCanvas?.(parent);
+    if (subCanvas?.isCanvas) {
+      return subCanvas.parentNode;
+    }
+    return parent;
+  }
+  // Child nodes can not be accessed
+  isNodeChildrenPrivate(node) {
+    if (this.configs?.isNodeChildrenPrivate) {
+      return node ? this.configs?.isNodeChildrenPrivate(node) : false;
+    }
+    const isSystemNode = node?.id.startsWith("$");
+    return !isSystemNode && node?.flowNodeType !== import_document2.FlowNodeBaseType.GROUP;
+  }
+  sortAll() {
+    console.warn("FreeLayoutScopeChain.sortAll is not implemented");
+    return [];
+  }
+};
+__decorateClass([
+  (0, import_inversify3.inject)(import_core3.EntityManager)
+], FreeLayoutScopeChain.prototype, "entityManager", 2);
+__decorateClass([
+  (0, import_inversify3.inject)(import_document2.FlowDocument)
+], FreeLayoutScopeChain.prototype, "flowDocument", 2);
+__decorateClass([
+  (0, import_inversify3.optional)(),
+  (0, import_inversify3.inject)(VariableChainConfig)
+], FreeLayoutScopeChain.prototype, "configs", 2);
+__decorateClass([
+  (0, import_inversify3.inject)(ScopeChainTransformService)
+], FreeLayoutScopeChain.prototype, "transformService", 2);
+__decorateClass([
+  (0, import_inversify3.postConstruct)()
+], FreeLayoutScopeChain.prototype, "onInit", 1);
+
+// src/chains/fixed-layout-scope-chain.ts
+var import_inversify4 = require("inversify");
+var import_variable_core4 = require("@flowgram.ai/variable-core");
+var import_document3 = require("@flowgram.ai/document");
+var FixedLayoutScopeChain = class extends import_variable_core4.ScopeChain {
+  constructor(flowDocument, configs) {
+    super();
+    this.flowDocument = flowDocument;
+    this.configs = configs;
+    this.bindTree(flowDocument.originTree);
+    this.toDispose.push(
+      // REFRACTOR: onTreeChange 触发时机精细化
+      flowDocument.originTree.onTreeChange(() => {
+        this.refreshAllChange();
+      })
+    );
+  }
+  // 绑定树
+  bindTree(tree) {
+    this.tree = tree;
+  }
+  // 获取依赖作用域
+  getDeps(scope) {
+    if (!this.tree) {
+      return this.transformService.transformDeps([], { scope });
+    }
+    const node = scope.meta.node;
+    if (!node) {
+      return this.transformService.transformDeps([], { scope });
+    }
+    const deps = [];
+    let curr = node;
+    while (curr) {
+      const { parent, pre } = this.tree.getInfo(curr);
+      const currData = this.getVariableData(curr);
+      if (curr === node) {
+        if (scope.meta.type === "public" /* public */ && currData?.private) {
+          deps.unshift(currData.private);
+        }
+      } else if (this.hasChildren(curr) && !this.isNodeChildrenPrivate(curr)) {
+        deps.unshift(
+          ...this.getAllSortedChildScope(curr, {
+            ignoreNodeChildrenPrivate: true
+          })
+        );
+      }
+      if (currData && curr !== node) {
+        deps.unshift(currData.public);
+      }
+      if (pre) {
+        curr = pre;
+        continue;
+      }
+      if (parent) {
+        let currParent = parent;
+        let currParentPre = this.tree.getPre(currParent);
+        while (currParent) {
+          const currParentData = this.getVariableData(currParent);
+          if (currParentData) {
+            deps.unshift(...currParentData.allScopes);
+          }
+          if (currParentPre) {
+            break;
+          }
+          currParent = this.tree.getParent(currParent);
+          currParentPre = currParent ? this.tree.getPre(currParent) : void 0;
+        }
+        curr = currParentPre;
+        continue;
+      }
+      curr = void 0;
+    }
+    const globalScope = this.variableEngine.getScopeById(GlobalScope.ID);
+    if (globalScope) {
+      deps.unshift(globalScope);
+    }
+    return this.transformService.transformDeps(deps, { scope });
+  }
+  // 获取覆盖作用域
+  getCovers(scope) {
+    if (!this.tree) {
+      return this.transformService.transformCovers([], { scope });
+    }
+    if (GlobalScope.is(scope)) {
+      const scopes = this.variableEngine.getAllScopes({ sort: true }).filter((_scope) => !GlobalScope.is(_scope));
+      return this.transformService.transformCovers(scopes, { scope });
+    }
+    const node = scope.meta.node;
+    if (!node) {
+      return this.transformService.transformCovers([], { scope });
+    }
+    const covers = [];
+    if (scope.meta.type === "private" /* private */) {
+      covers.push(
+        ...this.getAllSortedChildScope(node, {
+          addNodePrivateScope: true
+        }).filter((_scope) => _scope !== scope)
+      );
+      return this.transformService.transformCovers(covers, { scope });
+    }
+    let curr = node;
+    while (curr) {
+      const { next, parent } = this.tree.getInfo(curr);
+      const currData = this.getVariableData(curr);
+      if (curr !== node) {
+        if (this.hasChildren(curr)) {
+          covers.push(
+            ...this.getAllSortedChildScope(curr, {
+              addNodePrivateScope: true
+            })
+          );
+        } else if (currData) {
+          covers.push(...currData.allScopes);
+        }
+      }
+      if (next) {
+        curr = next;
+        continue;
+      }
+      if (parent) {
+        let currParent = parent;
+        let currParentNext = this.tree.getNext(currParent);
+        while (currParent) {
+          if (this.isNodeChildrenPrivate(currParent)) {
+            return this.transformService.transformCovers(covers, { scope });
+          }
+          if (currParentNext) {
+            break;
+          }
+          currParent = this.tree.getParent(currParent);
+          currParentNext = currParent ? this.tree.getNext(currParent) : void 0;
+        }
+        if (!currParentNext && currParent) {
+          break;
+        }
+        curr = currParentNext;
+        continue;
+      }
+      curr = void 0;
+    }
+    return this.transformService.transformCovers(covers, { scope });
+  }
+  // 排序所有作用域
+  sortAll() {
+    const startNode = this.flowDocument.getAllNodes().find((_node) => _node.isStart);
+    if (!startNode) {
+      return [];
+    }
+    const startVariableData = startNode.getData(FlowNodeVariableData);
+    const startPublicScope = startVariableData.public;
+    const deps = this.getDeps(startPublicScope);
+    const covers = this.getCovers(startPublicScope).filter(
+      (_scope) => !deps.includes(_scope) && _scope !== startPublicScope
+    );
+    return [...deps, startPublicScope, ...covers];
+  }
+  // 获取变量 Data 数据
+  getVariableData(node) {
+    if (node.flowNodeType === "virtualNode") {
+      return;
+    }
+    if (node.id.startsWith("$")) {
+      return;
+    }
+    return node.getData(FlowNodeVariableData);
+  }
+  // 子节点不可以被后续节点访问
+  isNodeChildrenPrivate(node) {
+    if (this.configs?.isNodeChildrenPrivate) {
+      return node ? this.configs?.isNodeChildrenPrivate(node) : false;
+    }
+    const isSystemNode = node?.id.startsWith("$");
+    return !isSystemNode && this.hasChildren(node);
+  }
+  hasChildren(node) {
+    return Boolean(this.tree && node && this.tree.getChildren(node).length > 0);
+  }
+  // 子节点按照顺序进行排序（含自身）
+  getAllSortedChildScope(node, {
+    ignoreNodeChildrenPrivate,
+    addNodePrivateScope
+  } = {}) {
+    const scopes = [];
+    const variableData = this.getVariableData(node);
+    if (variableData) {
+      scopes.push(variableData.public);
+    }
+    if (ignoreNodeChildrenPrivate && this.isNodeChildrenPrivate(node)) {
+      return scopes;
+    }
+    if (addNodePrivateScope && variableData?.private) {
+      scopes.push(variableData.private);
+    }
+    const children = this.tree?.getChildren(node) || [];
+    scopes.push(
+      ...children.map(
+        (child) => this.getAllSortedChildScope(child, { ignoreNodeChildrenPrivate, addNodePrivateScope })
+      ).flat()
+    );
+    return scopes;
+  }
+};
+__decorateClass([
+  (0, import_inversify4.inject)(ScopeChainTransformService)
+], FixedLayoutScopeChain.prototype, "transformService", 2);
+FixedLayoutScopeChain = __decorateClass([
+  __decorateParam(0, (0, import_inversify4.inject)(import_document3.FlowDocument)),
+  __decorateParam(1, (0, import_inversify4.optional)()),
+  __decorateParam(1, (0, import_inversify4.inject)(VariableChainConfig))
+], FixedLayoutScopeChain);
+
+// src/utils.ts
+function getNodeScope(node) {
+  return node.getData(FlowNodeVariableData).public;
+}
+function getNodePrivateScope(node) {
+  return node.getData(FlowNodeVariableData).initPrivate();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FixedLayoutScopeChain,
+  FlowNodeScopeType,
+  FlowNodeVariableData,
+  FreeLayoutScopeChain,
+  GlobalScope,
+  ScopeChainTransformService,
+  VariableChainConfig,
+  bindGlobalScope,
+  getNodePrivateScope,
+  getNodeScope
+});
+//# sourceMappingURL=index.js.map