@player-ui/player 0.0.1-next.1

package/dist/index.cjs.js

@@ -0,0 +1,1394 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var types = require('@player-ui/types');
+var binding = require('@player-ui/binding');
+var data = require('@player-ui/data');
+var expressions = require('@player-ui/expressions');
+var flow = require('@player-ui/flow');
+var logger = require('@player-ui/logger');
+var schema = require('@player-ui/schema');
+var stringResolver = require('@player-ui/string-resolver');
+var validator = require('@player-ui/validator');
+var view = require('@player-ui/view');
+var tapable = require('tapable');
+var timm = require('timm');
+var deferred = require('p-defer');
+var constants = require('@player-ui/constants');
+var queueMicrotask = require('queue-microtask');
+var partialMatchRegistry = require('@player-ui/partial-match-registry');
+var dequal = require('dequal');
+var utils = require('@player-ui/utils');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var deferred__default = /*#__PURE__*/_interopDefaultLegacy(deferred);
+var queueMicrotask__default = /*#__PURE__*/_interopDefaultLegacy(queueMicrotask);
+
+class LocalStateStore {
+  constructor(onUpdate) {
+    this.updateCallback = onUpdate;
+    this.state = new Map();
+  }
+  removeKey(key) {
+    this.state.delete(key);
+  }
+  reset() {
+    this.state.clear();
+  }
+  useSharedState(key) {
+    return (initialState) => {
+      if (!this.state.has(key)) {
+        this.state.set(key, initialState);
+      }
+      return [
+        this.state.get(key),
+        (newState) => {
+          var _a;
+          const current = this.state.get(key);
+          this.state.set(key, newState);
+          if (current !== newState) {
+            (_a = this.updateCallback) == null ? void 0 : _a.call(this);
+          }
+        }
+      ];
+    };
+  }
+  getLocalStateFunction(key, countKey) {
+    return (initialState) => {
+      if (!this.state.has(key)) {
+        this.state.set(key, []);
+      }
+      if (!this.state.has(countKey)) {
+        this.state.set(countKey, 0);
+      }
+      const localState = this.state.get(key);
+      const oldCount = this.state.get(countKey);
+      this.state.set(countKey, oldCount + 1);
+      if (localState.length <= oldCount) {
+        localState.push(initialState);
+      }
+      const value = localState[oldCount];
+      return [
+        value,
+        (newState) => {
+          var _a;
+          const oldValue = localState[oldCount];
+          localState[oldCount] = newState;
+          if (oldValue !== newState) {
+            (_a = this.updateCallback) == null ? void 0 : _a.call(this);
+          }
+        }
+      ];
+    };
+  }
+}
+
+function findUp(node, target) {
+  if (node === target) {
+    return true;
+  }
+  if (node.parent) {
+    return findUp(node.parent, target);
+  }
+  return false;
+}
+class AssetTransformCorePlugin {
+  constructor(registry) {
+    this.registry = registry;
+    this.stateStore = new Map();
+    this.beforeResolveSymbol = Symbol("before resolve");
+    this.resolveSymbol = Symbol("resolve");
+    this.beforeResolveCountSymbol = Symbol("before resolve count");
+    this.resolveCountSymbol = Symbol("resolve count");
+  }
+  apply(viewController) {
+    viewController.hooks.view.tap("asset-transform", (view$1) => {
+      this.stateStore.clear();
+      view$1.hooks.resolver.tap("asset-transform", (resolver) => {
+        let lastUpdatedNode;
+        const updateState = (node) => {
+          lastUpdatedNode = node;
+          view$1.update(new Set());
+        };
+        const getStore = (node, stepKey) => {
+          let store;
+          const countKey = stepKey === this.resolveSymbol ? this.resolveCountSymbol : this.beforeResolveCountSymbol;
+          const storedState = this.stateStore.get(node);
+          if (storedState) {
+            store = storedState;
+            store.removeKey(countKey);
+          } else {
+            store = new LocalStateStore(() => {
+              updateState(node);
+            });
+            this.stateStore.set(node, store);
+          }
+          return {
+            useSharedState: (key) => {
+              return store.useSharedState(key);
+            },
+            useLocalState: (initialState) => {
+              return store.getLocalStateFunction(stepKey, countKey)(initialState);
+            }
+          };
+        };
+        resolver.hooks.beforeResolve.tap("asset-transform", (node, options) => {
+          if (node && (node.type === "asset" || node.type === "view")) {
+            const transform = this.registry.get(node.value);
+            if (transform == null ? void 0 : transform.beforeResolve) {
+              const store = getStore(node, this.beforeResolveSymbol);
+              return transform.beforeResolve(node, options, store);
+            }
+          }
+          return node;
+        });
+        resolver.hooks.afterUpdate.tap("asset-transform", () => {
+          lastUpdatedNode = void 0;
+        });
+        resolver.hooks.skipResolve.tap("asset-transform", (skip, node) => {
+          if (!skip || !lastUpdatedNode) {
+            return skip;
+          }
+          const isParentOfUpdated = findUp(lastUpdatedNode, node);
+          const isChildOfUpdated = findUp(node, lastUpdatedNode);
+          return !isParentOfUpdated && !isChildOfUpdated;
+        });
+        resolver.hooks.afterResolve.tap("asset-transform", (value, node, options) => {
+          if (node.type !== view.NodeType.Asset && node.type !== view.NodeType.View) {
+            return value;
+          }
+          const originalNode = resolver.getSourceNode(node);
+          if (!originalNode) {
+            return value;
+          }
+          const transform = this.registry.get(value);
+          if (transform == null ? void 0 : transform.resolve) {
+            const store = getStore(originalNode, this.resolveSymbol);
+            return transform == null ? void 0 : transform.resolve(value, options, store);
+          }
+          return value;
+        });
+      });
+    });
+  }
+}
+
+var __defProp$3 = Object.defineProperty;
+var __defProps$3 = Object.defineProperties;
+var __getOwnPropDescs$3 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$3 = Object.getOwnPropertySymbols;
+var __hasOwnProp$3 = Object.prototype.hasOwnProperty;
+var __propIsEnum$3 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$3 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$3.call(b, prop))
+      __defNormalProp$3(a, prop, b[prop]);
+  if (__getOwnPropSymbols$3)
+    for (var prop of __getOwnPropSymbols$3(b)) {
+      if (__propIsEnum$3.call(b, prop))
+        __defNormalProp$3(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b));
+class ViewController {
+  constructor(initialViews, options) {
+    this.hooks = {
+      resolveView: new tapable.SyncWaterfallHook([
+        "view",
+        "viewRef",
+        "viewState"
+      ]),
+      view: new tapable.SyncHook(["view"])
+    };
+    this.transformRegistry = new partialMatchRegistry.Registry();
+    this.optimizeUpdates = true;
+    this.viewOptions = options;
+    this.viewMap = initialViews.reduce((viewMap, view) => __spreadProps$3(__spreadValues$3({}, viewMap), {
+      [view.id]: view
+    }), {});
+    new AssetTransformCorePlugin(this.transformRegistry).apply(this);
+    options.flowController.hooks.flow.tap("viewController", (flow) => {
+      flow.hooks.transition.tap("viewController", (_oldState, newState) => {
+        if (newState.value.state_type === "VIEW") {
+          this.onView(newState.value);
+        } else {
+          this.currentView = void 0;
+        }
+      });
+    });
+    options.model.hooks.onUpdate.tap("viewController", (updates) => {
+      if (this.currentView) {
+        if (this.optimizeUpdates) {
+          this.queueUpdate(new Set(updates.map((t) => t.binding)));
+        } else {
+          this.currentView.update();
+        }
+      }
+    });
+  }
+  queueUpdate(bindings) {
+    var _a;
+    if ((_a = this.pendingUpdate) == null ? void 0 : _a.changedBindings) {
+      this.pendingUpdate.changedBindings = new Set([
+        ...this.pendingUpdate.changedBindings,
+        ...bindings
+      ]);
+    } else {
+      this.pendingUpdate = { changedBindings: bindings };
+      queueMicrotask__default["default"](() => {
+        var _a2, _b;
+        const updates = (_a2 = this.pendingUpdate) == null ? void 0 : _a2.changedBindings;
+        this.pendingUpdate = void 0;
+        (_b = this.currentView) == null ? void 0 : _b.update(updates);
+      });
+    }
+  }
+  getViewForRef(viewRef) {
+    if (this.viewMap[viewRef]) {
+      return this.viewMap[viewRef];
+    }
+    const matchingViewId = Object.keys(this.viewMap).find((possibleViewIdMatch) => viewRef === stringResolver.resolveDataRefsInString(possibleViewIdMatch, {
+      model: this.viewOptions.model,
+      evaluate: this.viewOptions.evaluator.evaluate
+    }));
+    if (matchingViewId && this.viewMap[matchingViewId]) {
+      return this.viewMap[matchingViewId];
+    }
+  }
+  onView(state) {
+    const viewId = state.ref;
+    const source = this.hooks.resolveView.call(this.getViewForRef(viewId), viewId, state);
+    if (!source) {
+      throw new Error(`No view with id ${viewId}`);
+    }
+    const view$1 = new view.ViewInstance(source, this.viewOptions);
+    this.currentView = view$1;
+    this.hooks.view.call(view$1);
+    view$1.update();
+  }
+}
+
+class DataController {
+  constructor(model, options) {
+    this.hooks = {
+      resolve: new tapable.SyncWaterfallHook(["binding"]),
+      resolveDataStages: new tapable.SyncWaterfallHook(["pipeline"]),
+      resolveDefaultValue: new tapable.SyncBailHook(["binding"]),
+      onDelete: new tapable.SyncHook(["binding"]),
+      onSet: new tapable.SyncHook(["transaction"]),
+      onGet: new tapable.SyncHook(["binding", "result"]),
+      onUpdate: new tapable.SyncHook(["updates"]),
+      format: new tapable.SyncWaterfallHook(["value", "binding"]),
+      deformat: new tapable.SyncWaterfallHook(["value", "binding"]),
+      serialize: new tapable.SyncWaterfallHook(["data"])
+    };
+    this.logger = options.logger;
+    const middleware = options.middleware || [];
+    this.baseMiddleware = [new data.LocalModel(model), ...middleware];
+    this.trash = new Set();
+    this.pathResolver = options.pathResolver;
+  }
+  getModel() {
+    if (!this.model) {
+      const stages = this.hooks.resolveDataStages.call(this.baseMiddleware);
+      const model = new data.PipelinedDataModel();
+      model.setMiddleware(stages);
+      this.model = model;
+    }
+    return this.model;
+  }
+  resolveDataValue(binding, value, deformat) {
+    if (deformat) {
+      return this.hooks.deformat.call(value, binding);
+    }
+    return value;
+  }
+  set(transaction, options) {
+    let normalizedTransaction = [];
+    if (Array.isArray(transaction)) {
+      normalizedTransaction = transaction.map(([binding, value]) => {
+        const parsed = this.pathResolver.parse(binding);
+        return [
+          parsed,
+          this.resolveDataValue(parsed, value, Boolean(options == null ? void 0 : options.formatted))
+        ];
+      });
+    } else {
+      normalizedTransaction = Object.keys(transaction).map((binding) => {
+        const parsed = this.pathResolver.parse(binding);
+        const val = transaction[binding];
+        return [
+          parsed,
+          this.resolveDataValue(parsed, val, Boolean(options == null ? void 0 : options.formatted))
+        ];
+      });
+    }
+    const setUpdates = normalizedTransaction.reduce((updates, [binding, newVal]) => {
+      var _a;
+      const oldVal = this.get(binding, { includeInvalid: true });
+      if (!dequal.dequal(oldVal, newVal)) {
+        updates.push({
+          binding,
+          newValue: newVal,
+          oldValue: oldVal
+        });
+      }
+      (_a = this.logger) == null ? void 0 : _a.debug(`Setting path: ${binding.asString()} from: ${oldVal} to: ${newVal}`);
+      return updates;
+    }, []);
+    const result = this.getModel().set(normalizedTransaction, options);
+    const setUpdateBindings = new Set(setUpdates.map((su) => su.binding));
+    result.forEach((tr) => {
+      var _a;
+      if (!setUpdateBindings.has(tr.binding) && (tr.force === true || !dequal.dequal(tr.oldValue, tr.newValue))) {
+        (_a = this.logger) == null ? void 0 : _a.debug(`Path: ${tr.binding.asString()} was changed from: ${tr.oldValue} to: ${tr.newValue}`);
+        setUpdates.push(tr);
+      }
+    });
+    this.hooks.onSet.call(normalizedTransaction);
+    if (setUpdates.length > 0) {
+      this.hooks.onUpdate.call(setUpdates);
+    }
+    return result;
+  }
+  resolve(binding) {
+    return Array.isArray(binding) || typeof binding === "string" ? this.pathResolver.parse(binding) : binding;
+  }
+  get(binding$1, options) {
+    const resolved = binding$1 instanceof binding.BindingInstance ? binding$1 : this.resolve(binding$1);
+    let result = this.getModel().get(resolved, options);
+    if (result === void 0 && !(options == null ? void 0 : options.ignoreDefaultValue)) {
+      const defaultVal = this.hooks.resolveDefaultValue.call(resolved);
+      if (defaultVal !== result) {
+        result = defaultVal;
+      }
+    }
+    if (options == null ? void 0 : options.formatted) {
+      result = this.hooks.format.call(result, resolved);
+    }
+    this.hooks.onGet.call(binding$1, result);
+    return result;
+  }
+  delete(binding) {
+    if (binding === void 0 || binding === null) {
+      throw new Error(`Invalid arguments: delete expects a data path (string)`);
+    }
+    const resolved = this.resolve(binding);
+    this.hooks.onDelete.call(resolved);
+    this.deleteData(resolved);
+  }
+  getTrash() {
+    return this.trash;
+  }
+  addToTrash(binding) {
+    this.trash.add(binding);
+  }
+  deleteData(binding) {
+    const parentBinding = binding.parent();
+    const parentPath = parentBinding.asString();
+    const property = binding.key();
+    const existedBeforeDelete = Object.prototype.hasOwnProperty.call(this.get(parentBinding), property);
+    if (property !== void 0) {
+      const parent = parentBinding ? this.get(parentBinding) : void 0;
+      if (parentPath && Array.isArray(parent)) {
+        if (parent.length > property) {
+          this.set([[parentBinding, timm.removeAt(parent, property)]]);
+        }
+      } else if (parentPath && parent[property]) {
+        this.set([[parentBinding, timm.omit(parent, property)]]);
+      } else if (!parentPath) {
+        this.getModel().reset(timm.omit(this.get(""), property));
+      }
+    }
+    if (existedBeforeDelete && !this.get(binding)) {
+      this.addToTrash(binding);
+    }
+  }
+  serialize() {
+    return this.hooks.serialize.call(this.get(""));
+  }
+}
+
+var __defProp$2 = Object.defineProperty;
+var __defProps$2 = Object.defineProperties;
+var __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
+var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
+var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$2 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$2.call(b, prop))
+      __defNormalProp$2(a, prop, b[prop]);
+  if (__getOwnPropSymbols$2)
+    for (var prop of __getOwnPropSymbols$2(b)) {
+      if (__propIsEnum$2.call(b, prop))
+        __defNormalProp$2(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
+const CONTEXT = "validation-binding-tracker";
+class ValidationBindingTrackerViewPlugin {
+  constructor(options) {
+    this.trackedBindings = new Set();
+    this.options = options;
+  }
+  getBindings() {
+    return this.trackedBindings;
+  }
+  applyResolver(resolver) {
+    this.trackedBindings.clear();
+    const tracked = new Map();
+    const sections = new Map();
+    const seenBindings = new Set();
+    let lastViewUpdateChangeSet;
+    const nodeTree = new Map();
+    let lastComputedBindingTree = new Map();
+    let currentBindingTree = new Map();
+    const lastSectionBindingTree = new Map();
+    function addToTree(child, parent) {
+      var _a;
+      if (nodeTree.has(parent)) {
+        (_a = nodeTree.get(parent)) == null ? void 0 : _a.add(child);
+        return;
+      }
+      nodeTree.set(parent, new Set([child]));
+    }
+    resolver.hooks.beforeUpdate.tap(CONTEXT, (changes) => {
+      lastViewUpdateChangeSet = changes;
+    });
+    resolver.hooks.skipResolve.tap(CONTEXT, (shouldSkip, node) => {
+      const trackedBindingsForNode = lastComputedBindingTree.get(node);
+      if (!shouldSkip || !lastViewUpdateChangeSet || !trackedBindingsForNode) {
+        return shouldSkip;
+      }
+      const intersection = new Set([...lastViewUpdateChangeSet].filter((b) => trackedBindingsForNode.has(b)));
+      return intersection.size === 0;
+    });
+    resolver.hooks.resolveOptions.tap(CONTEXT, (options, node) => {
+      if (options.validation === void 0) {
+        return options;
+      }
+      tracked.delete(node);
+      const track = (binding$1) => {
+        var _a, _b, _c, _d;
+        const parsed = binding.isBinding(binding$1) ? binding$1 : this.options.parseBinding(binding$1);
+        if (tracked.has(node)) {
+          (_a = tracked.get(node)) == null ? void 0 : _a.add(parsed);
+        } else {
+          tracked.set(node, new Set([parsed]));
+        }
+        let { parent } = node;
+        while (parent) {
+          if (sections.has(parent)) {
+            (_b = sections.get(parent)) == null ? void 0 : _b.add(node);
+            break;
+          } else {
+            parent = parent.parent;
+          }
+        }
+        if (!seenBindings.has(parsed)) {
+          seenBindings.add(parsed);
+          (_d = (_c = this.options.callbacks) == null ? void 0 : _c.onAdd) == null ? void 0 : _d.call(_c, parsed);
+        }
+      };
+      return __spreadProps$2(__spreadValues$2({}, options), {
+        validation: __spreadProps$2(__spreadValues$2({}, options.validation), {
+          get: (binding, getOptions) => {
+            var _a;
+            if (getOptions == null ? void 0 : getOptions.track) {
+              track(binding);
+            }
+            const eow = (_a = options.validation) == null ? void 0 : _a._getValidationForBinding(binding);
+            if ((eow == null ? void 0 : eow.displayTarget) === void 0 || (eow == null ? void 0 : eow.displayTarget) === "field") {
+              return eow;
+            }
+            return void 0;
+          },
+          getChildren: (type) => {
+            var _a;
+            const validations = new Array();
+            (_a = lastComputedBindingTree.get(node)) == null ? void 0 : _a.forEach((binding) => {
+              var _a2;
+              const eow = (_a2 = options.validation) == null ? void 0 : _a2._getValidationForBinding(binding);
+              if (eow && type === eow.displayTarget) {
+                validations.push(eow);
+              }
+            });
+            return validations;
+          },
+          getValidationsForSection: () => {
+            var _a;
+            const validations = new Array();
+            (_a = lastSectionBindingTree.get(node)) == null ? void 0 : _a.forEach((binding) => {
+              var _a2;
+              const eow = (_a2 = options.validation) == null ? void 0 : _a2._getValidationForBinding(binding);
+              if (eow && eow.displayTarget === "section") {
+                validations.push(eow);
+              }
+            });
+            return validations;
+          },
+          register: (registerOptions) => {
+            if ((registerOptions == null ? void 0 : registerOptions.type) === "section") {
+              if (!sections.has(node)) {
+                sections.set(node, new Set());
+              }
+            }
+          },
+          track
+        })
+      });
+    });
+    resolver.hooks.afterNodeUpdate.tap(CONTEXT, (node, parent, update) => {
+      var _a, _b, _c;
+      if (parent) {
+        addToTree(node, parent);
+      }
+      if (update.updated) {
+        const newlyComputed = new Set(tracked.get(node));
+        (_a = nodeTree.get(node)) == null ? void 0 : _a.forEach((child) => {
+          var _a2;
+          (_a2 = currentBindingTree.get(child)) == null ? void 0 : _a2.forEach((b) => newlyComputed.add(b));
+        });
+        currentBindingTree.set(node, newlyComputed);
+      } else {
+        currentBindingTree.set(node, (_b = lastComputedBindingTree.get(node)) != null ? _b : new Set());
+      }
+      if (node === resolver.root) {
+        this.trackedBindings = (_c = currentBindingTree.get(node)) != null ? _c : new Set();
+        lastComputedBindingTree = currentBindingTree;
+        lastSectionBindingTree.clear();
+        sections.forEach((nodeSet, sectionNode) => {
+          const temp = new Set();
+          nodeSet.forEach((n) => {
+            var _a2;
+            (_a2 = tracked.get(n)) == null ? void 0 : _a2.forEach(temp.add, temp);
+          });
+          lastSectionBindingTree.set(sectionNode, temp);
+        });
+        nodeTree.clear();
+        tracked.clear();
+        sections.clear();
+        currentBindingTree = new Map();
+      }
+    });
+  }
+  apply(view) {
+    view.hooks.resolver.tap(CONTEXT, this.applyResolver.bind(this));
+  }
+}
+
+var __defProp$1 = Object.defineProperty;
+var __defProps$1 = Object.defineProperties;
+var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
+function createStatefulValidationObject(obj) {
+  return {
+    value: obj,
+    type: obj.severity,
+    state: "none"
+  };
+}
+class ValidatedBinding {
+  constructor(possibleValidations, onDismiss, log, weakBindings) {
+    this.applicableValidations = [];
+    this.validationsByState = {
+      load: [],
+      change: [],
+      navigation: []
+    };
+    this.onDismiss = onDismiss;
+    possibleValidations.forEach((vObj) => {
+      const { trigger } = vObj;
+      if (this.validationsByState[trigger]) {
+        this.validationsByState[trigger].push(createStatefulValidationObject(vObj));
+      } else {
+        log == null ? void 0 : log.warn(`Unknown validation trigger: ${trigger}`);
+      }
+    });
+    this.weakBindings = weakBindings != null ? weakBindings : new Set();
+  }
+  get() {
+    const firstError = this.applicableValidations.find((statefulObj) => {
+      const blocking = this.currentPhase === "navigation" ? statefulObj.value.blocking : true;
+      return statefulObj.state === "active" && blocking !== false;
+    });
+    if ((firstError == null ? void 0 : firstError.state) === "active") {
+      return firstError.response;
+    }
+  }
+  runApplicableValidations(runner, canDismiss) {
+    this.applicableValidations = this.applicableValidations.map((obj) => {
+      var _a, _b, _c;
+      if (obj.state === "dismissed") {
+        return obj;
+      }
+      const blocking = (_a = obj.value.blocking) != null ? _a : obj.value.severity === "warning" && "once" || obj.value.severity === "error" && true;
+      const dismissable = canDismiss && blocking === "once";
+      if (this.currentPhase === "navigation" && obj.state === "active" && dismissable) {
+        if (obj.value.severity === "warning") {
+          const warn = obj;
+          if (warn.dismissable && warn.response.dismiss) {
+            warn.response.dismiss();
+          } else {
+            warn.dismissable = true;
+          }
+          return obj;
+        }
+        if (obj.value.severity === "error") {
+          const err = obj;
+          err.state = "none";
+          return obj;
+        }
+      }
+      const response = runner(obj.value);
+      const newState = {
+        type: obj.type,
+        value: obj.value,
+        state: response ? "active" : "none",
+        dismissable: obj.value.severity === "warning" && this.currentPhase === "navigation",
+        response: response ? __spreadProps$1(__spreadValues$1({}, obj.value), {
+          message: (_b = response.message) != null ? _b : "Something is broken",
+          severity: obj.value.severity,
+          displayTarget: (_c = obj.value.displayTarget) != null ? _c : "field"
+        }) : void 0
+      };
+      if (newState.state === "active" && obj.value.severity === "warning") {
+        newState.response.dismiss = () => {
+          var _a2;
+          newState.state = "dismissed";
+          (_a2 = this.onDismiss) == null ? void 0 : _a2.call(this);
+        };
+      }
+      return newState;
+    });
+  }
+  update(phase, canDismiss, runner) {
+    if (phase === "load" && this.currentPhase !== void 0) {
+      return;
+    }
+    if (this.currentPhase === "navigation" || phase === this.currentPhase) {
+      this.runApplicableValidations(runner, canDismiss);
+      return;
+    }
+    if (phase === "load") {
+      this.currentPhase = "load";
+      this.applicableValidations = [...this.validationsByState.load];
+    } else if (phase === "change" && this.currentPhase === "load") {
+      this.currentPhase = "change";
+      this.applicableValidations = [
+        ...this.applicableValidations,
+        ...this.validationsByState.change
+      ];
+    } else if (phase === "navigation" && (this.currentPhase === "load" || this.currentPhase === "change")) {
+      this.applicableValidations = [
+        ...this.applicableValidations,
+        ...this.currentPhase === "load" ? this.validationsByState.change : [],
+        ...this.validationsByState.navigation
+      ];
+      this.currentPhase = "navigation";
+    }
+    this.runApplicableValidations(runner, canDismiss);
+  }
+}
+class ValidationController {
+  constructor(schema, options) {
+    this.hooks = {
+      createValidatorRegistry: new tapable.SyncHook(["registry"]),
+      onAddValidation: new tapable.SyncWaterfallHook(["validation", "binding"]),
+      onRemoveValidation: new tapable.SyncWaterfallHook(["validation", "binding"])
+    };
+    this.validations = new Map();
+    this.weakBindingTracker = new Set();
+    this.lastActiveBindings = new Set();
+    this.schema = schema;
+    this.options = options;
+    this.providers = [schema];
+  }
+  setOptions(options) {
+    this.options = options;
+  }
+  getDataMiddleware() {
+    return [
+      new validator.ValidationMiddleware((binding) => {
+        if (!this.options) {
+          return;
+        }
+        this.updateValidationsForBinding(binding, "change", this.options);
+        const strongValidation = this.getValidationForBinding(binding);
+        if (strongValidation == null ? void 0 : strongValidation.get())
+          return strongValidation.get();
+        const newInvalidBindings = new Set();
+        for (const [, weakValidation] of Array.from(this.validations)) {
+          if (view.caresAboutDataChanges(new Set([binding]), weakValidation.weakBindings) && (weakValidation == null ? void 0 : weakValidation.get())) {
+            weakValidation == null ? void 0 : weakValidation.weakBindings.forEach(newInvalidBindings.add, newInvalidBindings);
+          }
+        }
+        if (newInvalidBindings.size > 0) {
+          return newInvalidBindings;
+        }
+      }, { logger: new logger.ProxyLogger(() => {
+        var _a;
+        return (_a = this.options) == null ? void 0 : _a.logger;
+      }) })
+    ];
+  }
+  onView(view) {
+    this.validations.clear();
+    if (!this.options) {
+      return;
+    }
+    const bindingTrackerPlugin = new ValidationBindingTrackerViewPlugin(__spreadProps$1(__spreadValues$1({}, this.options), {
+      callbacks: {
+        onAdd: (binding) => {
+          if (!this.options) {
+            return;
+          }
+          const originalValue = this.options.model.get(binding);
+          const withoutDefault = this.options.model.get(binding, {
+            ignoreDefaultValue: true
+          });
+          if (originalValue !== withoutDefault) {
+            this.options.model.set([[binding, originalValue]]);
+          }
+          this.updateValidationsForBinding(binding, "load", this.options, () => {
+            view.update(new Set([binding]));
+          });
+        }
+      }
+    }));
+    this.tracker = bindingTrackerPlugin;
+    this.providers = [this.schema, view];
+    bindingTrackerPlugin.apply(view);
+  }
+  updateValidationsForBinding(binding, trigger, context, onDismiss) {
+    var _a;
+    if (trigger === "load") {
+      const possibleValidations = this.providers.reduce((vals, provider) => {
+        var _a2, _b;
+        return [
+          ...vals,
+          ...(_b = (_a2 = provider.getValidationsForBinding) == null ? void 0 : _a2.call(provider, binding)) != null ? _b : []
+        ];
+      }, []);
+      if (possibleValidations.length === 0) {
+        return;
+      }
+      this.validations.set(binding, new ValidatedBinding(possibleValidations, onDismiss, (_a = this.options) == null ? void 0 : _a.logger));
+    }
+    const trackedValidations = this.validations.get(binding);
+    trackedValidations == null ? void 0 : trackedValidations.update(trigger, true, (validationObj) => {
+      const response = this.validationRunner(validationObj, context, binding);
+      if (this.weakBindingTracker.size > 0) {
+        const t = this.validations.get(binding);
+        this.weakBindingTracker.forEach((b) => t.weakBindings.add(b));
+      }
+      return response ? { message: response.message } : void 0;
+    });
+    if (trigger !== "load") {
+      this.validations.forEach((validation, vBinding) => {
+        if (vBinding !== binding && view.caresAboutDataChanges(new Set([binding]), validation.weakBindings)) {
+          validation.update(trigger, true, (validationObj) => {
+            const response = this.validationRunner(validationObj, context, binding);
+            return response ? { message: response.message } : void 0;
+          });
+        }
+      });
+    }
+  }
+  validationRunner(validationObj, context, binding$1) {
+    const handler = this.getValidator(validationObj.type);
+    const weakBindings = new Set();
+    const model = {
+      get(b, options = { includeInvalid: true }) {
+        weakBindings.add(binding.isBinding(b) ? binding$1 : context.parseBinding(b));
+        return context.model.get(b, options);
+      },
+      set: context.model.set
+    };
+    const result = handler == null ? void 0 : handler(__spreadProps$1(__spreadValues$1({}, context), {
+      evaluate: (exp, options = { model }) => context.evaluate(exp, options),
+      model,
+      validation: validationObj
+    }), context.model.get(binding$1, {
+      includeInvalid: true,
+      formatted: validationObj.dataTarget === "formatted"
+    }), validationObj);
+    this.weakBindingTracker = weakBindings;
+    if (result) {
+      let { message } = result;
+      const { parameters } = result;
+      if (validationObj.message) {
+        message = stringResolver.resolveDataRefs(validationObj.message, {
+          model,
+          evaluate: context.evaluate
+        });
+        if (parameters) {
+          message = utils.replaceParams(message, parameters);
+        }
+      }
+      return {
+        message
+      };
+    }
+  }
+  updateValidationsForView(trigger) {
+    const { activeBindings } = this;
+    const canDismiss = trigger !== "navigation" || this.setCompare(this.lastActiveBindings, activeBindings);
+    this.getBindings().forEach((binding) => {
+      var _a;
+      (_a = this.validations.get(binding)) == null ? void 0 : _a.update(trigger, canDismiss, (obj) => {
+        if (!this.options) {
+          return;
+        }
+        return this.validationRunner(obj, this.options, binding);
+      });
+    });
+    if (trigger === "navigation") {
+      this.lastActiveBindings = activeBindings;
+    }
+  }
+  setCompare(set1, set2) {
+    if (set1.size !== set2.size)
+      return false;
+    for (const entry of set1)
+      if (!set2.has(entry))
+        return false;
+    return true;
+  }
+  get activeBindings() {
+    return new Set(Array.from(this.getBindings()).filter((b) => {
+      var _a;
+      return ((_a = this.validations.get(b)) == null ? void 0 : _a.get()) !== void 0;
+    }));
+  }
+  getValidator(type) {
+    if (this.validatorRegistry) {
+      return this.validatorRegistry.get(type);
+    }
+    const registry = new validator.ValidatorRegistry();
+    this.hooks.createValidatorRegistry.call(registry);
+    this.validatorRegistry = registry;
+    return registry.get(type);
+  }
+  getBindings() {
+    var _a, _b;
+    return (_b = (_a = this.tracker) == null ? void 0 : _a.getBindings()) != null ? _b : new Set();
+  }
+  validateView(trigger = "navigation") {
+    var _a, _b;
+    this.updateValidationsForView(trigger);
+    const validations = new Map();
+    for (const b of this.getBindings()) {
+      const invalid = (_a = this.getValidationForBinding(b)) == null ? void 0 : _a.get();
+      if (invalid) {
+        (_b = this.options) == null ? void 0 : _b.logger.debug(`Validation on binding: ${b.asString()} is preventing navigation. ${JSON.stringify(invalid)}`);
+        validations.set(b, invalid);
+      }
+    }
+    return {
+      canTransition: validations.size === 0,
+      validations: validations.size ? validations : void 0
+    };
+  }
+  getValidationForBinding(binding) {
+    return this.validations.get(binding);
+  }
+  forView(parser) {
+    return {
+      _getValidationForBinding: (binding$1) => {
+        var _a;
+        return (_a = this.getValidationForBinding(binding.isBinding(binding$1) ? binding$1 : parser(binding$1))) == null ? void 0 : _a.get();
+      },
+      getAll: () => {
+        const bindings = this.getBindings();
+        if (bindings.size === 0) {
+          return void 0;
+        }
+        const validationMapping = new Map();
+        bindings.forEach((b) => {
+          var _a;
+          const validation = (_a = this.getValidationForBinding(b)) == null ? void 0 : _a.get();
+          if (validation) {
+            validationMapping.set(b, validation);
+          }
+        });
+        return validationMapping.size === 0 ? void 0 : validationMapping;
+      },
+      get() {
+        throw new Error("Error Access be provided by the view plugin");
+      },
+      getChildren() {
+        throw new Error("Error rollup should be provided by the view plugin");
+      },
+      getValidationsForSection() {
+        throw new Error("Error rollup should be provided by the view plugin");
+      },
+      track: () => {
+        throw new Error("Tracking should be provided by the view plugin");
+      },
+      register: () => {
+        throw new Error("Section funcationality hould be provided by the view plugin");
+      },
+      type: (binding$1) => this.schema.getType(binding.isBinding(binding$1) ? binding$1 : parser(binding$1))
+    };
+  }
+}
+
+class FlowExpPlugin {
+  constructor() {
+    this.name = "flow-exp-plugin";
+  }
+  apply(player) {
+    let expressionEvaluator;
+    const handleEval = (exp) => {
+      if (exp) {
+        if (typeof exp === "object" && "exp" in exp) {
+          expressionEvaluator == null ? void 0 : expressionEvaluator.evaluate(exp.exp);
+        } else {
+          expressionEvaluator == null ? void 0 : expressionEvaluator.evaluate(exp);
+        }
+      }
+    };
+    player.hooks.expressionEvaluator.tap(this.name, (evaluator) => {
+      expressionEvaluator = evaluator;
+    });
+    player.hooks.flowController.tap(this.name, (fc) => {
+      fc.hooks.flow.tap(this.name, (flow) => {
+        flow.hooks.onStart.tap(this.name, (exp) => handleEval(exp));
+        flow.hooks.onEnd.tap(this.name, (exp) => handleEval(exp));
+        flow.hooks.resolveTransitionNode.intercept({
+          call: (nextState) => {
+            var _a;
+            const currentState = () => player.getState();
+            const currentFlowState = (_a = currentState().controllers.flow.current) == null ? void 0 : _a.currentState;
+            if (currentFlowState == null ? void 0 : currentFlowState.value.onEnd) {
+              handleEval(currentFlowState.value.onEnd);
+            }
+            if (nextState == null ? void 0 : nextState.onStart) {
+              handleEval(nextState.onStart);
+            }
+          }
+        });
+      });
+    });
+  }
+}
+
+const NOT_STARTED_STATE = {
+  ref: Symbol("not-started"),
+  status: "not-started"
+};
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+const PLAYER_VERSION = "!!STABLE_VERSION!!";
+const COMMIT = "!!STABLE_GIT_COMMIT!!";
+const _Player = class {
+  constructor(config) {
+    this.logger = new logger.TapableLogger();
+    this.constantsController = new constants.ConstantsController();
+    this.state = NOT_STARTED_STATE;
+    this.hooks = {
+      flowController: new tapable.SyncHook(["flowController"]),
+      viewController: new tapable.SyncHook(["viewController"]),
+      view: new tapable.SyncHook(["view"]),
+      expressionEvaluator: new tapable.SyncHook([
+        "expressionEvaluator"
+      ]),
+      dataController: new tapable.SyncHook(["dataController"]),
+      schema: new tapable.SyncHook(["schema"]),
+      validationController: new tapable.SyncHook([
+        "validationController"
+      ]),
+      bindingParser: new tapable.SyncHook(["bindingParser"]),
+      state: new tapable.SyncHook(["state"]),
+      onStart: new tapable.SyncHook(["flow"]),
+      onEnd: new tapable.SyncHook(),
+      resolveFlowContent: new tapable.SyncWaterfallHook(["content"])
+    };
+    var _a;
+    const initialPlugins = [];
+    const flowExpPlugin = new FlowExpPlugin();
+    initialPlugins.push(flowExpPlugin);
+    if (config == null ? void 0 : config.logger) {
+      this.logger.addHandler(config.logger);
+    }
+    this.config = config || {};
+    this.config.plugins = [...this.config.plugins || [], ...initialPlugins];
+    (_a = this.config.plugins) == null ? void 0 : _a.forEach((plugin) => {
+      plugin.apply(this);
+    });
+  }
+  findPlugin(symbol) {
+    var _a;
+    return (_a = this.config.plugins) == null ? void 0 : _a.find((el) => el.symbol === symbol);
+  }
+  applyTo(symbol, apply) {
+    const plugin = this.findPlugin(symbol);
+    if (plugin) {
+      apply(plugin);
+    }
+  }
+  registerPlugin(plugin) {
+    var _a;
+    plugin.apply(this);
+    (_a = this.config.plugins) == null ? void 0 : _a.push(plugin);
+  }
+  getVersion() {
+    return _Player.info.version;
+  }
+  getCommit() {
+    return _Player.info.commit;
+  }
+  getState() {
+    return this.state;
+  }
+  setState(state) {
+    this.state = state;
+    this.hooks.state.call(state);
+  }
+  setupFlow(userContent) {
+    const userFlow = this.hooks.resolveFlowContent.call(userContent);
+    const flowController = new flow.FlowController(userFlow.navigation, {
+      logger: this.logger
+    });
+    this.hooks.onStart.call(userFlow);
+    this.hooks.flowController.call(flowController);
+    let expressionEvaluator;
+    let dataController;
+    const pathResolver = new binding.BindingParser({
+      get: (binding) => {
+        return dataController.get(binding);
+      },
+      set: (transaction) => {
+        return dataController.set(transaction);
+      },
+      evaluate: (expression) => {
+        return expressionEvaluator.evaluate(expression);
+      }
+    });
+    this.hooks.bindingParser.call(pathResolver);
+    const parseBinding = pathResolver.parse;
+    const flowResultDeferred = deferred__default["default"]();
+    const schema$1 = new schema.SchemaController(userFlow.schema);
+    this.hooks.schema.call(schema$1);
+    const validationController = new ValidationController(schema$1);
+    this.hooks.validationController.call(validationController);
+    dataController = new DataController(userFlow.data, {
+      pathResolver,
+      middleware: validationController.getDataMiddleware(),
+      logger: this.logger
+    });
+    dataController.hooks.format.tap("player", (value, binding) => {
+      const formatter = schema$1.getFormatter(binding);
+      return formatter ? formatter.format(value) : value;
+    });
+    dataController.hooks.deformat.tap("player", (value, binding) => {
+      const formatter = schema$1.getFormatter(binding);
+      return formatter ? formatter.deformat(value) : value;
+    });
+    dataController.hooks.resolveDefaultValue.tap("player", (binding) => {
+      var _a;
+      return (_a = schema$1.getApparentType(binding)) == null ? void 0 : _a.default;
+    });
+    let viewController;
+    expressionEvaluator = new expressions.ExpressionEvaluator({
+      model: dataController,
+      logger: this.logger
+    });
+    this.hooks.expressionEvaluator.call(expressionEvaluator);
+    expressionEvaluator.hooks.onError.tap("player", (e) => {
+      flowResultDeferred.reject(e);
+      return true;
+    });
+    function resolveStrings(val) {
+      return stringResolver.resolveDataRefs(val, {
+        model: dataController,
+        evaluate: expressionEvaluator.evaluate
+      });
+    }
+    flowController.hooks.flow.tap("player", (flow) => {
+      flow.hooks.beforeTransition.tap("player", (state, transitionVal) => {
+        if (!("transitions" in state) || !state.transitions[transitionVal]) {
+          return state;
+        }
+        return timm.setIn(state, ["transitions", transitionVal], resolveStrings(state.transitions[transitionVal]));
+      });
+      flow.hooks.skipTransition.tap("validation", (currentState) => {
+        var _a;
+        if ((currentState == null ? void 0 : currentState.value.state_type) === "VIEW") {
+          const { canTransition, validations } = validationController.validateView("navigation");
+          if (!canTransition && validations) {
+            const bindings = new Set(validations.keys());
+            (_a = viewController == null ? void 0 : viewController.currentView) == null ? void 0 : _a.update(bindings);
+            return true;
+          }
+        }
+        return void 0;
+      });
+      flow.hooks.resolveTransitionNode.tap("player", (state) => {
+        let newState = state;
+        if ("ref" in state) {
+          newState = timm.setIn(state, ["ref"], resolveStrings(state.ref));
+        }
+        if ("param" in state) {
+          newState = timm.setIn(state, ["param"], resolveStrings(state.param));
+        }
+        return newState;
+      });
+      flow.hooks.transition.tap("player", (_oldState, newState) => {
+        if (newState.value.state_type === "ACTION") {
+          const { exp } = newState.value;
+          queueMicrotask__default["default"](() => {
+            flowController == null ? void 0 : flowController.transition(String(expressionEvaluator == null ? void 0 : expressionEvaluator.evaluate(exp)));
+          });
+        }
+        expressionEvaluator.reset();
+      });
+    });
+    this.hooks.dataController.call(dataController);
+    validationController.setOptions({
+      parseBinding,
+      model: dataController,
+      logger: this.logger,
+      evaluate: expressionEvaluator.evaluate,
+      constants: this.constantsController
+    });
+    viewController = new ViewController(userFlow.views || [], {
+      evaluator: expressionEvaluator,
+      parseBinding,
+      transition: flowController.transition,
+      model: dataController,
+      logger: this.logger,
+      flowController,
+      schema: schema$1,
+      format: (binding, value) => {
+        const formatter = schema$1.getFormatter(binding);
+        return (formatter == null ? void 0 : formatter.format) ? formatter.format(value) : value;
+      },
+      formatValue: (ref, value) => {
+        const formatter = schema$1.getFormatterForType(ref);
+        return (formatter == null ? void 0 : formatter.format) ? formatter.format(value) : value;
+      },
+      validation: __spreadProps(__spreadValues({}, validationController.forView(parseBinding)), {
+        type: (b) => schema$1.getType(parseBinding(b))
+      })
+    });
+    viewController.hooks.view.tap("player", (view) => {
+      validationController.onView(view);
+      this.hooks.view.call(view);
+    });
+    this.hooks.viewController.call(viewController);
+    const formatFunction = (ctx, value, formatName) => {
+      var _a, _b;
+      return (_b = (_a = schema$1.getFormatterForType({ type: formatName })) == null ? void 0 : _a.format(value)) != null ? _b : value;
+    };
+    expressionEvaluator.addExpressionFunction("format", formatFunction);
+    return {
+      start: () => {
+        flowController.start().then((endState) => {
+          const flowResult = {
+            endState: resolveStrings(endState),
+            data: dataController.serialize()
+          };
+          return flowResult;
+        }).then(flowResultDeferred.resolve).catch((e) => {
+          this.logger.error(`Something went wrong: ${e.message}`);
+          throw e;
+        }).catch(flowResultDeferred.reject).finally(() => this.hooks.onEnd.call());
+      },
+      state: {
+        status: "in-progress",
+        flowResult: flowResultDeferred.promise,
+        controllers: {
+          data: dataController,
+          view: viewController,
+          flow: flowController,
+          schema: schema$1,
+          expression: expressionEvaluator,
+          binding: pathResolver,
+          validation: validationController
+        },
+        fail: flowResultDeferred.reject,
+        flow: userFlow,
+        logger: this.logger
+      }
+    };
+  }
+  start(payload) {
+    return __async(this, null, function* () {
+      var _a;
+      const ref = Symbol((_a = payload == null ? void 0 : payload.id) != null ? _a : "payload");
+      const maybeUpdateState = (newState) => {
+        if (this.state.ref !== ref) {
+          this.logger.warn(`Received update for a flow that's not the current one`);
+          return newState;
+        }
+        this.setState(newState);
+        return newState;
+      };
+      this.setState({
+        status: "not-started",
+        ref
+      });
+      try {
+        const { state, start } = this.setupFlow(payload);
+        this.setState(__spreadValues({
+          ref
+        }, state));
+        start();
+        const endProps = {
+          ref,
+          status: "completed",
+          flow: state.flow,
+          dataModel: state.controllers.data.getModel()
+        };
+        return maybeUpdateState(__spreadValues(__spreadValues({}, yield state.flowResult), endProps));
+      } catch (error) {
+        const errorState = {
+          status: "error",
+          ref,
+          flow: payload,
+          error
+        };
+        maybeUpdateState(errorState);
+        throw error;
+      }
+    });
+  }
+};
+let Player = _Player;
+Player.info = {
+  version: PLAYER_VERSION,
+  commit: COMMIT
+};
+
+exports.AssetTransformCorePlugin = AssetTransformCorePlugin;
+exports.DataController = DataController;
+exports.FlowExpPlugin = FlowExpPlugin;
+exports.LocalStateStore = LocalStateStore;
+exports.NOT_STARTED_STATE = NOT_STARTED_STATE;
+exports.Player = Player;
+exports.ValidationBindingTrackerViewPlugin = ValidationBindingTrackerViewPlugin;
+exports.ValidationController = ValidationController;
+exports.ViewController = ViewController;
+Object.keys(types).forEach(function (k) {
+  if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return types[k]; }
+  });
+});
+Object.keys(binding).forEach(function (k) {
+  if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return binding[k]; }
+  });
+});
+Object.keys(data).forEach(function (k) {
+  if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return data[k]; }
+  });
+});
+Object.keys(expressions).forEach(function (k) {
+  if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return expressions[k]; }
+  });
+});
+Object.keys(flow).forEach(function (k) {
+  if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return flow[k]; }
+  });
+});
+Object.keys(logger).forEach(function (k) {
+  if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return logger[k]; }
+  });
+});
+Object.keys(schema).forEach(function (k) {
+  if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return schema[k]; }
+  });
+});
+Object.keys(stringResolver).forEach(function (k) {
+  if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return stringResolver[k]; }
+  });
+});
+Object.keys(validator).forEach(function (k) {
+  if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return validator[k]; }
+  });
+});
+Object.keys(view).forEach(function (k) {
+  if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return view[k]; }
+  });
+});
+//# sourceMappingURL=index.cjs.js.map