@entryscape/rdforms 10.14.0 → 10.15.0

package/dist/rdforms.node.js

@@ -0,0 +1,4027 @@
+/******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 229:
+/***/ ((module) => {
+
+module.exports = require("node-fetch");
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/compat get default export */
+/******/ 	(() => {
+/******/ 		// getDefaultExport function for compatibility with non-harmony modules
+/******/ 		__webpack_require__.n = (module) => {
+/******/ 			var getter = module && module.__esModule ?
+/******/ 				() => (module['default']) :
+/******/ 				() => (module);
+/******/ 			__webpack_require__.d(getter, { a: getter });
+/******/ 			return getter;
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = (exports) => {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  ItemStore: () => (/* reexport */ ItemStore),
+  bundleLoader: () => (/* reexport */ bundleLoader),
+  engine: () => (/* reexport */ engine),
+  system: () => (/* reexport */ system),
+  utils: () => (/* reexport */ utils),
+  validate: () => (/* reexport */ validate)
+});
+
+;// external "@entryscape/rdfjson"
+const rdfjson_namespaceObject = require("@entryscape/rdfjson");
+;// external "moment"
+const external_moment_namespaceObject = require("moment");
+var external_moment_default = /*#__PURE__*/__webpack_require__.n(external_moment_namespaceObject);
+;// external "lodash"
+const external_lodash_namespaceObject = require("lodash");
+;// ./src/model/system.js
+/* eslint-disable no-unused-vars */
+
+const generateUIDNotMoreThan1million = () =>
+// eslint-disable-next-line no-restricted-properties,no-bitwise
+`0000${(Math.random() * Math.pow(36, 4) << 0).toString(36)}`.slice(-4);
+const createURI = (item, parentBinding) => {
+  const parentURI = parentBinding.getChildrenRootUri();
+  const hash = parentURI.lastIndexOf('#');
+  const newURIBase = hash === -1 ? `${parentURI}#` : parentURI.substring(0, hash + 1);
+  const graph = parentBinding.getGraph()._graph;
+  while (true) {
+    const newURI = newURIBase + generateUIDNotMoreThan1million();
+    if (graph[newURI] == null) {
+      return newURI;
+    }
+  }
+};
+const getFallbackChoice = (item, value, seeAlso, graph) => {
+  if (item.getNodetype() === 'URI' || item.getNodetype() === 'RESOURCE') {
+    let lmap = utils.getLocalizedMap(graph, value, item.getURIValueLabelProperties());
+    if (!lmap) {
+      const lastHash = value.lastIndexOf('#');
+      const lastSlash = value.lastIndexOf('/');
+      if (lastHash > 0 || lastSlash > 0) {
+        lmap = {
+          '': decodeURIComponent(value.substring(1 + (lastHash > lastSlash ? lastHash : lastSlash)))
+        };
+      } else {
+        lmap = {
+          '': value
+        };
+      }
+    }
+    return {
+      value,
+      label: lmap
+    };
+  }
+  return {
+    value,
+    label: value
+  };
+};
+
+/**
+ * This method is a default implementation, feel free to override with specific construction of matched choices.
+ * Returns a choice object containing a value and a label.
+ * Override this function to provide specific loading of a choice.
+ * If you need to do this asynchonously provide a "load" method on the returned choice object.
+ * To indicate that a matched value is not acceptable anymore,
+ * set the flag mismatch to true in the returned choice object.
+ *
+ * @param item the RDForms template item matched against.
+ * @param value the value to match
+ * @param seeAlso if provided the value is a URI and a rdfs:seeAlso property has been found in the graph
+ * @param graph the RDF graph where the value was matched
+ * @returns {Object} an object containing a value, a label (object with language codes as attributes),
+ * an optional load callback method and an optional mismatch flag.
+ * @see openChoiceSelector
+ */
+const getChoice = (item, value, seeAlso, graph) => getFallbackChoice(item, value, seeAlso, graph);
+const labelProperties = ['http://www.w3.org/2000/01/rdf-schema#label', 'http://purl.org/dc/terms/title', 'http://purl.org/dc/elements/1.1/title', 'http://www.w3.org/2004/02/skos/core#prefLabel', 'http://xmlns.com/foaf/0.1/name', 'http://xmlns.com/foaf/name'];
+
+/**
+ * This method is a fake implementation for launching a dialog for choosing system choices.
+ * The method MUST be overridden if the template you use depends on system choices.
+ * (System choices in a RDForm template choice items means that there are neither inline choices
+ * or an ontology URL given in combination with provided cached choices for the given ontology URL).
+ *
+ * @param {rdforms.model.Binding} binding the binding where the choice will be given
+ * @param {Function} callback a method to call with a choice object when the user has selected an appropriate choice.
+ */
+const openChoiceSelector = (binding, callback) => {
+  alert('This alert is a placeholder for a search dialog that should be provided as part of the integration of ' + 'RDForms into a wider system.\nSimply override the methods "getChoices" and "openChoiceSelector" in the ' + 'system module.');
+  callback({
+    value: 'http://example.com/choice1',
+    label: {
+      en: 'First choice',
+      sv: 'Första valet'
+    }
+  });
+};
+
+/** The implementor is expected to provide an application specific override
+ * For example:
+ * system.attachExternalLinkBehaviour = (node, binding) => node.setAttribute("target", "_blank");
+ */
+const attachExternalLinkBehaviour = () => false;
+
+/** The implementor is expected to provide an application specific override
+ * For example:
+ * system.attachLinkBehaviour = (node, binding) => node.setAttribute("target", "_blank");
+ */
+const attachLinkBehaviour = (node, binding) => false;
+const hasDnDSupport = binding => false;
+const addDnD = (binding, node, onDrop) => ({});
+/* harmony default export */ const system = ({
+  hasDnDSupport,
+  addDnD,
+  attachExternalLinkBehaviour,
+  attachLinkBehaviour,
+  openChoiceSelector,
+  getChoice,
+  getFallbackChoice,
+  labelProperties,
+  createURI
+});
+;// ./src/utils.js
+
+
+
+const getLocalizedValue = (hash, locale) => {
+  const _locale = locale || external_moment_default().locale();
+  if (hash == null) {
+    return {
+      precision: 'none'
+    };
+  } else if (typeof hash === 'string') {
+    return {
+      value: hash,
+      precision: 'nolang',
+      lang: ''
+    };
+  } else if (hash.hasOwnProperty(_locale)) {
+    return {
+      value: hash[_locale],
+      precision: 'exact',
+      lang: _locale
+    };
+  }
+  const pos = _locale.indexOf('_');
+  if (pos > -1 && hash.hasOwnProperty(_locale.substr(0, 2))) {
+    return {
+      value: hash[_locale.substr(0, 2)],
+      precision: 'coarsen',
+      lang: _locale.substr(0, 2)
+    };
+  } else if (hash.hasOwnProperty('en')) {
+    return {
+      value: hash.en,
+      precision: 'default',
+      lang: 'en'
+    };
+  } else if (hash.hasOwnProperty('')) {
+    return {
+      value: hash[''],
+      precision: 'nolang',
+      lang: ''
+    };
+  }
+  const allLangs = Object.keys(hash);
+  if (allLangs.length > 0) {
+    return {
+      value: hash[allLangs[0]],
+      precision: 'any',
+      lang: allLangs[0]
+    };
+  }
+  return {
+    precision: 'none'
+  };
+};
+const f = (graph, subject, prop) => {
+  const stmts = graph.find(subject, prop);
+  if (stmts.length > 0) {
+    const obj = {};
+    for (let s = 0; s < stmts.length; s++) {
+      obj[stmts[s].getLanguage() || ''] = stmts[s].getValue();
+    }
+    return obj;
+  }
+  return undefined;
+};
+const getLocalizedMap = (graphOrBinding, subject, propArr) => {
+  let graph;
+  let _subject = subject;
+  let _propArr = propArr;
+  if (graphOrBinding.getItem) {
+    // graphOrBinding is a Binding
+    graph = graphOrBinding.getGraph();
+    _subject = graphOrBinding.getValue();
+    _propArr = graphOrBinding.getItem().getURIValueLabelProperties();
+  } else {
+    graph = graphOrBinding;
+  }
+  if (_propArr == null || _propArr.length === 0) {
+    _propArr = system.labelProperties;
+  }
+  for (let i = 0; i < _propArr.length; i++) {
+    const props = _propArr[i];
+    if (Array.isArray(props)) {
+      const valueArr = [];
+      for (let j = 0; j < props.length; j++) {
+        const value = f(graph, _subject, props[j]);
+        if (value) {
+          valueArr.push(getLocalizedValue(value).value);
+        }
+      }
+      if (valueArr.length > 0) {
+        return {
+          '': valueArr.join(' ')
+        };
+      }
+    } else {
+      const value = f(graph, _subject, props);
+      if (value) {
+        return value;
+      }
+    }
+  }
+  return undefined;
+};
+const cloneArrayWithLabels = (objects, noSort) => {
+  const itemsArray = [];
+  for (let i = 0; i < objects.length; i++) {
+    const o = objects[i];
+    const currentLabel = getLocalizedValue(o.label);
+    const obj = {
+      value: o.value,
+      label: currentLabel.value || o.value || ''
+    };
+    if (o.top === true) {
+      obj.top = true;
+    }
+    if (o.children != null) {
+      obj.children = (0,external_lodash_namespaceObject.cloneDeep)(o.children);
+    }
+    if (o.selectable === false) {
+      obj.selectable = false;
+    } else {
+      obj.selectable = true;
+    }
+    itemsArray.push(obj);
+  }
+  if (noSort !== true) {
+    itemsArray.sort((o1, o2) => o1.label > o2.label ? 1 : -1);
+  }
+  return itemsArray;
+};
+const extractGist = (str, template) => {
+  let _template = template;
+  if (_template) {
+    if (_template.indexOf('$1') === -1) {
+      _template += '$1';
+    }
+    const r = `${_template}`.replace(/([.?*+^$[\]\\(){}|-])/g, '\\$1').replace('\\$1', '(.*)');
+    const e = new RegExp(r).exec(str);
+    if (e != null) {
+      return e[1];
+    }
+  }
+  return str;
+};
+const findFirstValue = (engine, graph, uri, template) => {
+  const fvb = engine.findFirstValueBinding(engine.match(graph, uri, template), false);
+  if (!fvb) {
+    return undefined;
+  }
+  if (fvb.getChoice) {
+    return getLocalizedValue(fvb.getChoice().label).value;
+  }
+  return fvb.getGist();
+};
+const generateUUID = () => {
+  // Public Domain/MIT
+  let d = new Date().getTime();
+  if (typeof performance !== 'undefined' && typeof performance.now === 'function') {
+    d += performance.now(); // use high-precision timer if available
+  }
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
+    // eslint-disable-next-line no-mixed-operators,no-bitwise
+    const r = (d + Math.random() * 16) % 16 | 0;
+    d = Math.floor(d / 16);
+    // eslint-disable-next-line no-bitwise,no-mixed-operators
+    return (c === 'x' ? r : r & 0x3 | 0x8).toString(16);
+  });
+};
+/* harmony default export */ const utils = ({
+  getLocalizedValue,
+  getLocalizedMap,
+  cloneArrayWithLabels,
+  extractGist,
+  findFirstValue,
+  generateUUID
+});
+;// ./src/template/Item.js
+
+
+let itemCount = 0;
+const setObjAttr = (obj, attr, value) => {
+  if (value === null || typeof value === 'undefined' || value === '' || Array.isArray(value) && value.length === 0) {
+    delete obj[attr];
+  } else {
+    obj[attr] = value;
+  }
+};
+class Item {
+  /**
+   * Base functionality of Text, Group and Choice item classes.
+   */
+  constructor({
+    source = {},
+    bundle,
+    itemStore
+  }) {
+    this._itemStore = itemStore;
+    this._source = source;
+    this._bundle = bundle;
+    itemCount += 1;
+    this._internalId = itemCount;
+    this._styles = ['heading', 'invisible', 'invisibleGroup', 'stars', 'commentOn', 'multiline', 'horizontalRadioButtons', 'verticalRadioButtons', 'horizontalCheckBoxes', 'verticalCheckBoxes', 'nonEditable', 'expandable', 'compact', 'nonCompact', 'dropDown', 'table', 'firstcolumnfixedtable', 'tree', 'externalLink', 'internalLink', 'noLink', 'image', 'label', 'tooltip', 'strictmatch', 'relaxedDatatypeMatch', 'viewAllTranslations', 'filterTranslations', 'email', 'atLeastOneChild', 'atMostOneChild', 'exactlyOneChild', 'noLabelInPresent', 'autoInitDate', 'autoUpdateDate', 'autoUUID', 'autoValue', 'showURI', 'showLink', 'showValue', 'showDescriptionInPresent', 'showDescriptionInEdit', 'textAsChoice', 'preserveOrderOfChoices', 'linkWithLabel', 'deprecated', 'inline', 'truncate', 'noTruncate', 'card', 'cardInPresent', 'cardInEdit'];
+    this._getLocalizedValue = utils.getLocalizedValue;
+  }
+
+  //= ==================================================
+  // Public API
+  //= ==================================================
+  getId() {
+    const s = this.getSource(true);
+    return s.id || s['@id'];
+  }
+  setId(id) {
+    setObjAttr(this.getSource(true), 'id', id);
+    delete s['@id'];
+  }
+  getType(original) {
+    const s = this.getSource(original);
+    return s.type || s['@type'];
+  }
+  setType(typeStr) {
+    setObjAttr(this.getSource(true), 'type', typeStr);
+    delete s['@type'];
+    this.refreshExtends();
+  }
+  getExtends() {
+    return this.getSource(true).extends || '';
+  }
+  refreshExtends() {
+    if (this.isExtention) {
+      this.setExtends(this.getExtends());
+    }
+  }
+  setExtends(extendsStr) {
+    const s = this.getSource(true);
+    const ei = this._itemStore.getItem(extendsStr);
+    if (ei == null) {
+      this._source = s;
+    } else {
+      this._source = this._itemStore.createExtendedSource(ei.getSource(), s);
+    }
+    if (extendsStr === '' || extendsStr == null) {
+      delete s.extends;
+    } else {
+      s.extends = extendsStr;
+    }
+  }
+  isExtention() {
+    return this.getExtends() != null;
+  }
+  _getText(attr, returnDetails, original) {
+    const s = this.getSource(original);
+    return returnDetails ? utils.getLocalizedValue(s[attr]) : utils.getLocalizedValue(s[attr]).value;
+  }
+  _setText(attr, value, lang) {
+    const s = this.getSource(true);
+    s[attr] = this._setLangHash(s[attr], value, lang);
+    this.refreshExtends();
+  }
+  _setTextMap(attr, map) {
+    setObjAttr(this.getSource(true), attr, map);
+    this.refreshExtends();
+  }
+  getLabel(returnDetails, original) {
+    return this._getText('label', returnDetails, original);
+  }
+  setLabel(value, lang) {
+    this._setText('label', value, lang);
+  }
+  getLabelMap(original) {
+    return this.getSource(original).label;
+  }
+  setLabelMap(map) {
+    this._setTextMap('label', map);
+  }
+  getEditLabel(returnDetails, original) {
+    return this._getText('editlabel', returnDetails, original);
+  }
+  setEditLabel(value, lang) {
+    this._setText('editlabel', value, lang);
+  }
+  getEditLabelMap(original) {
+    return this.getSource(original).editlabel;
+  }
+  setEditLabelMap(map) {
+    this._setTextMap('editlabel', map);
+  }
+  getDescription(returnDetails, original) {
+    return this._getText('description', returnDetails, original);
+  }
+  setDescription(value, lang) {
+    this._setText('description', value, lang);
+  }
+  getDescriptionMap(original) {
+    return this.getSource(original).description;
+  }
+  setDescriptionMap(map) {
+    this._setTextMap('description', map);
+  }
+  getEditDescription(returnDetails, original) {
+    return this._getText('editdescription', returnDetails, original);
+  }
+  setEditDescription(value, lang) {
+    this._setText('editdescription', value, lang);
+  }
+  getEditDescriptionMap(original) {
+    return this.getSource(original).editdescription;
+  }
+  setEditDescriptionMap(map) {
+    this._setTextMap('editdescription', map);
+  }
+  getHelp(returnDetails, original) {
+    return this._getText('help', returnDetails, original);
+  }
+  setHelp(value, lang) {
+    this._setText('help', value, lang);
+  }
+  getHelpMap(original) {
+    return this.getSource(original).help;
+  }
+  setHelpMap(map) {
+    this._setTextMap('help', map);
+  }
+  getPlaceholder(returnDetails, original) {
+    return this._getText('placeholder', returnDetails, original);
+  }
+  setPlaceholder(value, lang) {
+    this._setText('placeholder', value, lang);
+  }
+  getPlaceholderMap(original) {
+    return this.getSource(original).placeholder;
+  }
+  setPlaceholderMap(map) {
+    this._setTextMap('placeholder', map);
+  }
+  getPurpose(returnDetails, original) {
+    return this._getText('purpose', returnDetails, original);
+  }
+  setPurpose(value, lang) {
+    this._setText('purpose', value, lang);
+  }
+  getPurposeMap(original) {
+    return this.getSource(original).purpose;
+  }
+  setPurposeMap(map) {
+    this._setTextMap('purpose', map);
+  }
+  getSpecification(returnDetails, original) {
+    return this._getText('specification', returnDetails, original);
+  }
+  setSpecification(value, lang) {
+    this._setText('specification', value, lang);
+  }
+  getSpecificationMap(original) {
+    return this.getSource(original).specification;
+  }
+  setSpecificationMap(map) {
+    this._setTextMap('specification', map);
+  }
+  getText(attr, returnDetails, original) {
+    const s = this.getSource(original);
+    const t = s.text || {};
+    return returnDetails ? utils.getLocalizedValue(t[attr]) : utils.getLocalizedValue(t[attr]).value;
+  }
+  setText(attr, value, lang) {
+    const s = this.getSource(true);
+    const t = s.text = s.text || {};
+    t[attr] = this._setLangHash(t[attr], value, lang);
+    this.refreshExtends();
+  }
+  setTextMap(attr, map) {
+    const s = this.getSource(true);
+    const t = s.text = s.text || {};
+    setObjAttr(t, attr, map);
+    this.refreshExtends();
+  }
+  getEnhanced(attribute) {
+    const s = this.getSource(true);
+    if (typeof s.enhanced === 'boolean') {
+      return s.enhanced;
+    }
+    return s.enhanced && s.enhanced[attribute] || false;
+  }
+  setEnhanced(attribute, enhanced) {
+    const s = this.getSource(true);
+    if (typeof attribute === 'boolean') {
+      if (attribute === true) {
+        s.enhanced = true;
+      } else {
+        delete s.enhanced;
+      }
+    } else {
+      s.enhanced = typeof s.enhanced === 'boolean' ? {} : s.enhanced || {};
+      if (enhanced) {
+        s.enhanced[attribute] = true;
+      } else {
+        delete s.enhanced[attribute];
+        if (Object.keys(s).length === 0) {
+          delete s.enhanced;
+        }
+      }
+    }
+    // Simple way to refresh this._source which is a cache including potential enhancements
+    this.setExtends(this.getExtends());
+  }
+
+  /**
+   * @return {String|null} as a URI, may be null for Groups, never null for Text or choice
+   * item types.
+   */
+  getProperty(original) {
+    let p = null;
+    const source = this.getSource(original);
+    if (source) {
+      p = source.property;
+      if (p != null && p !== '') {
+        p = rdfjson_namespaceObject.namespaces.expand(p);
+      }
+    }
+    return p;
+  }
+  setProperty(prop) {
+    setObjAttr(this.getSource(true), 'property', prop);
+    this.refreshExtends();
+  }
+
+  /**
+   * If the value is a uri, it is not nice to show it directly.
+   * Hence, we need to discover (or provide if we are in edit mode)
+   * a suitable label for the URI. Labels are typically provided by
+   * having triples with the URI as subject, but which predicates do we use?
+   *
+   * URIValueLabelProperties is an array of properties to be used in this scenario,
+   * were each should be tried in turn. In editing mode the first property should be used,
+   * alternatively a dropdown can be used to select among the properties.
+   *
+   * @return {Array} array of properties
+   * The property value pairs corresponds to predicate and objects in required tripples.
+   */
+  getURIValueLabelProperties(original) {
+    const arr = this.getSource(original).uriValueLabelProperties;
+    if (arr != null) {
+      return arr.map(uri => rdfjson_namespaceObject.namespaces.expand(uri));
+    }
+    return arr;
+  }
+  setURIValueLabelProperties(props) {
+    setObjAttr(this.getSource(true), 'uriValueLabelProperties', props);
+    this.refreshExtends();
+  }
+
+  /**
+   * @return {Object} never available for Text item type.
+   * The property value pairs corresponds to predicate and objects in required tripples.
+   */
+  getConstraints(original) {
+    const constr = this.getSource(original).constraints;
+    if (constr != null) {
+      const nc = {};
+      Object.keys(constr).forEach(key => {
+        const val = constr[key];
+        if (Array.isArray(val)) {
+          nc[rdfjson_namespaceObject.namespaces.expand(key)] = val.map(v => rdfjson_namespaceObject.namespaces.expand(v));
+        } else {
+          nc[rdfjson_namespaceObject.namespaces.expand(key)] = rdfjson_namespaceObject.namespaces.expand(val);
+        }
+      });
+      return nc;
+    }
+    return constr;
+  }
+  setConstraints(constr) {
+    setObjAttr(this.getSource(true), 'constraints', constr);
+    this.refreshExtends();
+  }
+
+  /**
+   * Deps is an array of strings corresponding to predicates, "*" may be used to match
+   * anything. The final string in the path may correspond to the object,
+   * e.g. a literal or uri.
+   * By default, the dependency is given relative to the current items parent.
+   * If dependency path should start higher up it can be indicated by providing one or more
+   * initial strings with value "..".
+   *
+   * @return {Object} dependency path that must exist for this item to be visible.
+   *
+   */
+  getDeps(original) {
+    const deps = this.getSource(original).deps;
+    if (deps != null) {
+      return deps.map(d => {
+        if (d !== '*' && d !== '..') {
+          return rdfjson_namespaceObject.namespaces.expand(d);
+        }
+        return d;
+      });
+    }
+    return deps;
+  }
+  setDeps(deps) {
+    setObjAttr(this.getSource(true), 'deps', deps);
+    this.refreshExtends();
+  }
+
+  /**
+   * @return {String} a URI indicating the datatype, for example: "http://www.w3.org/2001/XMLSchema.xsd#date".
+   */
+  getDatatype(original) {
+    const dt = this.getSource(original).datatype;
+    if (dt != null && dt !== '') {
+      return Array.isArray(dt) ? dt.map(d => rdfjson_namespaceObject.namespaces.expand(d)) : rdfjson_namespaceObject.namespaces.expand(dt);
+    }
+    return dt;
+  }
+  setDatatype(dt) {
+    setObjAttr(this.getSource(true), 'datatype', dt);
+    this.refreshExtends();
+  }
+  getPattern(original) {
+    return this.getSource(original).pattern;
+  }
+  setPattern(pattern) {
+    setObjAttr(this.getSource(true), 'pattern', pattern);
+    this.refreshExtends();
+  }
+
+  /**
+   * @return {String} a two character language code, only relevant if the item type is Text and the nodetype is
+   * a LANGUAGE_LITERAL, indicating that all matching bindings should be set with this language.
+   */
+  getLanguage(original) {
+    return this.getSource(original).language;
+  }
+  setLanguage(lang) {
+    setObjAttr(this.getSource(true), 'language', lang);
+    this.refreshExtends();
+  }
+  getMember(original) {
+    return this.getSource(original).member;
+  }
+  setMember(member) {
+    setObjAttr(this.getSource(true), 'member', member);
+    this.refreshExtends();
+  }
+
+  /**
+   * Allowed values are:
+   * LITERAL, RESOURCE, URI, BLANK, PLAIN_LITERAL, ONLY_LITERAL, LANGUAGE_LITERAL, DATATYPE_LITERAL
+   */
+  getNodetype(original) {
+    const s = this.getSource(original);
+    return s.nodetype || s.nodeType; // Ugly fix because it is often wrong written in SIRFF.
+  }
+  setNodetype(nt) {
+    setObjAttr(this.getSource(true), 'nodetype', nt);
+    this.refreshExtends();
+  }
+  getValue(original) {
+    return this.getSource(original).value;
+  }
+  setValue(value) {
+    setObjAttr(this.getSource(true), 'value', value);
+    this.refreshExtends();
+  }
+  getValueTemplate(original) {
+    return this.getSource(original).valueTemplate;
+  }
+  setValueTemplate(valueTemplate) {
+    setObjAttr(this.getSource(true), 'valueTemplate', valueTemplate);
+    this.refreshExtends();
+  }
+
+  /**
+   * @return {Object} containing max, min, and preferred properties.
+   */
+  getCardinality(original) {
+    if (!this.getProperty() && this.getType() === 'text') {
+      return {
+        min: 1,
+        max: 1
+      };
+    }
+    const source = this.getSource(original);
+    if (source && 'cardinality' in source) {
+      return source.cardinality;
+    }
+    if (!this.getProperty()) {
+      return {
+        max: 1
+      };
+    }
+    return {};
+  }
+  setCardinality(card) {
+    setObjAttr(this.getSource(true), 'cardinality', card);
+    this.refreshExtends();
+  }
+  isEnabled(original) {
+    const s = this.getSource(original);
+    return s.enabled == null ? true : s.enabled;
+  }
+  setEnabled(en) {
+    const s = this.getSource(true);
+    if (en) {
+      delete s.enabled;
+    } else {
+      s.enabled = en;
+    }
+    this.refreshExtends();
+  }
+
+  /**
+   * Classes are exposed in CSS, allows external stylesheets to act on the form.
+   * @returns {Array}
+   */
+  getClasses(original) {
+    const source = this.getSource(original);
+    if (source && 'cls' in source) {
+      return source.cls;
+    }
+    return [];
+  }
+  setClasses(arr) {
+    setObjAttr(this.getSource(true), 'cls', arr);
+    this.refreshExtends();
+  }
+
+  /**
+   * @deprecated only provided for backward compatability, use styles, classes
+   * @param cls
+   * @returns {boolean}
+   */
+  hasClass(cls, original) {
+    const s = this.getSource(original);
+    if (this.hasStyle(cls, original)) {
+      return true;
+    }
+    if (s.cls == null) {
+      return false;
+    }
+    return s.cls.some(c => c.toLowerCase() === cls.toLowerCase());
+  }
+
+  /**
+   * The available styles, see the _styles variable.
+   *
+   * @return {Array} that contains strings with all available styles.
+   */
+  getAvailableStyles() {
+    return this._styles;
+  }
+
+  /**
+   * @return {Array} that contains strings with the style, if no style is defined an empty array is returned
+   */
+  getStyles(original) {
+    return this.getSource(original).styles || [];
+  }
+  setStyles(arr) {
+    setObjAttr(this.getSource(true), 'styles', arr);
+    this.refreshExtends();
+  }
+  hasStyle(sty, original) {
+    const source = this.getSource(original);
+    if (!source || !('styles' in source)) {
+      return false;
+    }
+    return source.styles.some(s => s.toLowerCase() === sty.toLowerCase());
+  }
+  getSource(original, attribute) {
+    if (original === true) {
+      // Get the original source
+      return this._source._extendedSource || this._source;
+    } else if (original === false) {
+      // Get the extended source
+      const entryItem = this._itemStore.getItem(this.getExtends());
+      if (entryItem == null) {
+        return this._source;
+      }
+      return entryItem.getSource();
+    } // Get the merged source.
+    return this._source;
+  }
+  getBundle() {
+    return this._bundle;
+  }
+  toStringShort() {
+    return `'${this.getLabel()}'${this.getId() ? ` (ID: '${this.getId()}')` : ''}`;
+  }
+  toString() {
+    const detailsArr = [];
+    if (this.getId()) {
+      detailsArr.push(`ID: '${this.getId()}'`);
+    }
+    detailsArr.push(`TYPE: '${this.getType()}'`);
+    if (this.getProperty()) {
+      detailsArr.push(`PROPERTY: '${this.getProperty()}'`);
+    }
+    if (this.getExtends()) {
+      detailsArr.push(`EXTENDS: '${this.getExtends()}'`);
+    }
+    return `'${this.getLabel()}' (${detailsArr.join(', ')})`;
+  }
+  getHash() {
+    return `i_${this._internalId}`;
+  }
+
+  //= ==================================================
+  // Inherited methods
+  //= ==================================================
+
+  //= ==================================================
+  // Private methods
+  //= ==================================================
+
+  // eslint-disable-next-line class-methods-use-this
+  _setLangHash(hash, value, lang) {
+    const _hash = hash || {};
+    if (typeof value === 'string') {
+      if (typeof lang === 'string') {
+        _hash[lang] = value;
+      } else {
+        _hash[''] = value;
+      }
+    } else if (typeof value === 'object' && value !== null) {
+      return value;
+    }
+    return _hash;
+  }
+}
+;// ./src/template/Group.js
+
+const sortItems = items => {
+  items.forEach(item => {
+    item.__label = (item.getLabel() || '').toLowerCase();
+  });
+  items.sort((o1, o2) => {
+    if (o1._source.priority != null) {
+      if (o2._source.priority != null) {
+        // eslint-disable-next-line no-nested-ternary
+        return o1._source.priority > o2._source.priority ? -1 : o1._source.priority < o2._source.priority ? 1 : 0;
+      }
+      return o1._source.priority > 0 ? -1 : 1;
+    } else if (o2._source.priority != null) {
+      return o2._source.priority > 0 ? 1 : -1;
+    } else if (o1.__label > o2.__label) {
+      return 1;
+    } else if (o1.__label < o2.__label) {
+      return -1;
+    }
+    return 0;
+  });
+};
+class Group extends Item {
+  /**
+   * Group extends an Item by having children.
+   */
+  constructor(params) {
+    super(params);
+    this._children = params.children;
+    if (this._source.content != null) {
+      this._source.items = this._source.content;
+      delete this._source.content;
+    }
+    this._forceChildrenClones = false;
+    this._parent = null;
+  }
+
+  // ===================================================
+  // Public API
+  // ===================================================
+  getChildren(original) {
+    const _original = original && this.isExtention();
+    let children = _original ? this._ochildren : this._children;
+    if (children == null) {
+      children = this._itemStore.getChildren(this, _original);
+      if (this.getSource().automatic === true && this._itemStore.automaticSortAllowed) {
+        sortItems(children);
+      }
+      this[`_${_original ? 'o' : ''}children`] = children;
+    }
+    return children;
+  }
+  originalChildrenChanged() {
+    if (this.isExtention()) {
+      delete this._children;
+    }
+  }
+  setExtends(extendsStr) {
+    super.setExtends(extendsStr);
+    delete this._children;
+    delete this._ochildren;
+  }
+
+  // ===================================================
+  // Inherited methods
+  // ===================================================
+
+  getNodetype() {
+    return super.getNodetype() || 'RESOURCE'; // Ugly fix because it is often wrong written in SIRFF.
+  }
+}
+;// ./src/template/PropertyGroup.js
+
+class PropertyGroup extends Group {
+  /**
+   * A PropertyGroup captures the special case when both the predicate and object of a
+   * tripple should be changable. This is achieved by having a PropertyGroup where the
+   * first child is a Choice item corresponding to the predicate and the second being
+   * an item corresponding to the object in the triple. The second item can be either a
+   * Text, Choice or Group item depending on the kind of object envisioned in the triple.
+   */
+  getChildren(original) {
+    if (this._delegatedChildren == null) {
+      const getCardinality = () => ({
+        min: 1,
+        max: 1,
+        pref: 1
+      });
+      const children = super.getChildren(original) || [];
+      this._delegatedChildren = children.map(child => {
+        const delegate = Object.create(child);
+        delegate.getCardinality = getCardinality;
+        return delegate;
+      });
+    }
+    return this._delegatedChildren;
+  }
+  getPropertyItem() {
+    return this.getChildren()[0];
+  }
+  getObjectItem() {
+    return this.getChildren()[1];
+  }
+}
+;// ./src/template/Text.js
+
+
+/**
+ * Same functionality as an Item, but separate class to make switching on type possible.
+ */
+class Text extends Item {
+  getLabelProperties(original) {
+    return this.getSource(original).labelProperties;
+  }
+}
+;// ./src/template/Choice.js
+
+
+const expandValues = choices => {
+  if (choices == null) {
+    return;
+  }
+  choices.forEach(c => {
+    c.value = rdfjson_namespaceObject.namespaces.expand(c.value);
+  });
+};
+class Choice extends Item {
+  /**
+   * A choice item type indicates that the value should be one of a range of predefined choices,
+   * these predefined choices can be defined manually in the template or extracted from an external
+   * ontology (indicated by the ontologyUrl) by means of a query that can be constructed from the constraints.
+   *
+   * TODO:
+   * The choices can also be organized into a hierarchy using the parent and hierarchy properties.
+   */
+  constructor(params) {
+    super(params);
+    this._ontologyStore = params.ontologyStore;
+  }
+
+  // ===================================================
+  // Public API
+  // ===================================================
+  /**
+   *  A choice is an object which looks like:
+   * {"value": "http://example.com/choice1",
+   *  "label": {"en": "First choice", "sv": "Första valet"}
+   * }
+   *
+   * @return {Array} of choices.
+   */
+  getChoices(original) {
+    return this.getStaticChoices(original) || this.getDynamicChoices(original) || [];
+  }
+
+  /**
+   * @return {Boolean} true if there is an ontology or static choices.
+   */
+  hasChoices(original) {
+    const s = this.getSource(original);
+    return s.ontologyUrl != null || s.choices != null;
+  }
+  hasStaticChoices(original) {
+    const s = this.getSource(original);
+    return s.choices != null;
+  }
+
+  /**
+   * @return {Array} of choices defined manually in the Template.
+   */
+  getStaticChoices(original) {
+    const s = this.getSource(original);
+    if (s.choices) {
+      const isURI = this.getNodetype().indexOf('LITERAL') === -1;
+      if (original && this.isExtention()) {
+        if (!this._origStaticIsSorted) {
+          if (isURI) {
+            expandValues(s.choices);
+          }
+          this._origStaticIsSorted = true;
+        }
+      } else if (!this._staticIsSorted) {
+        if (isURI) expandValues(s.choices);
+        this._staticIsSorted = true;
+      }
+    }
+    return s.choices;
+  }
+  setStaticChoices(choices) {
+    const s = this.getSource(true);
+    if (s.choices === choices) {
+      return;
+    }
+    if (choices != null) {
+      this._origStaticIsSorted = true;
+    }
+    s.choices = choices;
+    this.refreshExtends();
+  }
+  setExtends(extendsStr) {
+    super.setExtends(extendsStr);
+    delete this._staticIsSorted;
+    delete this._origStaticIsSorted;
+  }
+
+  /**
+   * Fetches choices from an external ontology.
+   *
+   * @param {Object} callback will be called asynchronously, if undefined the call is made synchronously.
+   * @return {Array} of choice objects, only provided if method called without callback.
+   */
+  getDynamicChoices(callback) {
+    if (this._dynamicChoices == null) {
+      if (callback == null) {
+        this._dynamicChoices = this._ontologyStore.getChoices(this);
+        return this._dynamicChoices;
+      }
+      this._ontologyStore.getChoices(this, choices => {
+        this._dynamicChoices = choices;
+        if (this._dynamicChoices == null) {
+          console.log(`Failed lookup of choices for ${this.getLabel()}`);
+          console.log(`OntologyUrl is: ${this._source.ontologyUrl}`);
+        }
+        callback(this._dynamicChoices);
+      });
+    } else {
+      if (callback == null) {
+        return this._dynamicChoices;
+      }
+      callback(this._dynamicChoices);
+    }
+    return undefined;
+  }
+  getOntologyUrl(original) {
+    const ou = this.getSource(original).ontologyUrl;
+    if (ou != null && ou !== '') {
+      return rdfjson_namespaceObject.namespaces.expand(ou);
+    }
+    return ou;
+  }
+  setOntologyUrl(url) {
+    const s = this.getSource(true);
+    if (url == null || url === '') {
+      delete s.ontologyUrl;
+    } else {
+      s.ontologyUrl = url;
+    }
+    this.refreshExtends();
+  }
+  getLabelProperties(original) {
+    return this.getSource(original).labelProperties || ['http://www.w3.org/2000/01/rdf-schema#label'];
+  }
+  getParentProperty(original) {
+    const pp = this.getSource(original).parentProperty;
+    if (pp != null && pp !== '') {
+      return rdfjson_namespaceObject.namespaces.expand(pp);
+    }
+    return pp;
+  }
+  setParentProperty(prop) {
+    const s = this.getSource(true);
+    if (prop == null || prop === '') {
+      delete s.parentProperty;
+    } else {
+      s.parentProperty = prop;
+    }
+    this.refreshExtends();
+  }
+  getHierarchyProperty(original) {
+    const hp = this.getSource(original).hierarchyProperty;
+    if (hp != null && hp !== '') {
+      return rdfjson_namespaceObject.namespaces.expand(hp);
+    }
+    return hp;
+  }
+  setHierarchyProperty(prop) {
+    const s = this.getSource(true);
+    if (prop == null || prop === '') {
+      delete s.hierarchyProperty;
+    } else {
+      s.hierarchyProperty = prop;
+    }
+    this.refreshExtends();
+  }
+  isParentPropertyInverted(original) {
+    return this.getSource(original).isParentPropertyInverted === true;
+  }
+  setParentPropertyInverted(inverted) {
+    const s = this.getSource(true);
+    if (inverted === true) {
+      s.isParentPropertyInverted = true;
+    } else {
+      delete s.isParentPropertyInverted;
+    }
+    this.refreshExtends();
+  }
+  isHierarchyPropertyInverted(original) {
+    return this.getSource(original).isHierarchyPropertyInverted === true;
+  }
+  setHierarchyPropertyInverted(inverted) {
+    const s = this.getSource(true);
+    if (inverted) {
+      s.isHierarchyPropertyInverted = true;
+    } else {
+      delete s.isHierarchyPropertyInverted;
+    }
+    this.refreshExtends();
+  }
+}
+;// ./src/template/OntologyStore.js
+
+class OntologyStore {
+  /**
+   * Simple store of ontologies to allow reuse across templates and items.
+   */
+  constructor() {
+    this._registry = {};
+  }
+
+  //= ==================================================
+  // Public API
+  //= ==================================================
+  importRegistry(registry) {
+    Object.assign(this._registry, registry);
+  }
+  getChoices(choiceItem, callback) {
+    const choices = this._findChoices(choiceItem);
+    if (choices == null) {
+      // TODO load via xhr and deferred.
+    } else {
+      if (callback == null) {
+        return choices;
+      }
+      callback(choices);
+    }
+    return undefined;
+  }
+
+  //= ==================================================
+  // Private methods
+  //= ==================================================
+  _findChoices(item) {
+    const ontologyChoiceArr = this._registry[item.getOntologyUrl()];
+    if (ontologyChoiceArr != null) {
+      for (let ind = 0; ind < ontologyChoiceArr.length; ind++) {
+        const obj = ontologyChoiceArr[ind];
+        if ((0,external_lodash_namespaceObject.isEqual)(obj.constraints, item.getConstraints()) && item.getParentProperty() === obj.parentProperty && item.getHierarchyProperty() === obj.hierarchyProperty && item.isParentPropertyInverted() === (obj.isParentPropertyInverted || false) && item.isHierarchyPropertyInverted() === (obj.isHierarchyPropertyInverted || false)) {
+          return obj.choices;
+        }
+      }
+    }
+    return undefined;
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  _constructLoadUrl(choiceItem) {
+    const params = [];
+    params.push(`constr=${encodeURIComponent(JSON.stringify(choiceItem.getConstraints()))}`);
+    if (choiceItem.getParentProperty() != null) {
+      const pp = choiceItem.isParentPropertyInverted() === true ? 'ipp=' : 'pp=';
+      params.push(pp + encodeURIComponent(choiceItem.getParentProperty()));
+    }
+    if (choiceItem.getHierarchyProperty() != null) {
+      const hp = choiceItem.isHierarchyPropertyInverted() === true ? 'ihp=' : 'hp=';
+      params.push(hp + encodeURIComponent(choiceItem.getHierarchyProperty()));
+    }
+    return `${choiceItem.getOntologyUrl()}?${params.join('&')}`;
+  }
+}
+;// ./src/template/Bundle.js
+let counter = 0;
+class Bundle {
+  /**
+   * A Bundle corresponds to a set of items typically managed in a single file.
+   */
+  constructor({
+    itemStore,
+    source,
+    path,
+    readOnly = false
+  }) {
+    this._itemStore = itemStore;
+    this._source = source;
+    this._path = path;
+    this._readOnly = readOnly;
+    this._items = [];
+    counter += 1;
+    this._id = `_bundle_${counter}`;
+    this._root = null;
+    this._modified = false;
+  }
+  getInternalId() {
+    return this._id;
+  }
+  getSource() {
+    return this._source;
+  }
+  setRoot(itemId) {
+    this._source.root = itemId;
+    return itemId;
+  }
+  getRoot() {
+    if (this._source.root) {
+      return this._itemStore.getItem(this._source.root);
+    }
+    return undefined;
+  }
+  getItemStore() {
+    return this._itemStore;
+  }
+  getPath() {
+    return this._path;
+  }
+  getItems() {
+    return this._items;
+  }
+  addItem(item) {
+    this._items.push(item);
+  }
+  removeItem(item) {
+    this._items.splice(this._items.indexOf(item), 1);
+  }
+  isModified() {
+    return this._modified;
+  }
+  setModified(modified) {
+    this._modified = modified;
+  }
+  isReadOnly() {
+    return this._readOnly || this._path == null;
+  }
+}
+;// ./src/model/Binding.js
+/* eslint-disable class-methods-use-this */
+
+let Binding_counter = 0;
+
+/**
+ * A binding is a pairing between an item and various RDF statement
+ * (a single statement unless the binding is a group with constraints).
+ * It keeps track of cardinality and validity.
+ * If a binding is valid and all parent bindings are valid,
+ * the statement is asserted, that is, inserted into the RDF graph.
+ */
+class Binding {
+  /**
+   * @exports {Binding}
+   * @class
+   */
+  constructor({
+    item,
+    statement,
+    graph,
+    matchingCode
+  }) {
+    this._item = item;
+    this._statement = statement;
+    this._graph = graph;
+    this._ancestorValid = true;
+    this._cardinalityTracker = null;
+    this._hash = `b_${Binding_counter}`;
+    this._matchingCode = matchingCode || 'correct';
+    Binding_counter += 1;
+  }
+
+  // ===================================================
+  // Public API
+  // ===================================================
+  getGraph() {
+    if (!this._graph) {
+      if (this._statement) {
+        this._graph = this._statement.getGraph();
+      } else if (this._parent) {
+        this._graph = this._parent.getGraph();
+      }
+    }
+    return this._graph;
+  }
+  isReadOnly() {
+    if (!('_readOnly' in this)) {
+      const parent = this.getParent();
+      if (parent && parent._readOnly) {
+        this._readyOnly = true;
+      } else {
+        this._readOnly = !!(this._statement && this._statement.getNamedGraph());
+      }
+    }
+    return this._readOnly;
+  }
+  remove() {}
+  setSubject(uri) {}
+  getValue() {}
+  setValue(value, silent) {}
+  getGist() {
+    return utils.extractGist(this.getValue(), this.getItem().getValueTemplate());
+  }
+  setGist(value, silent) {
+    let _value = value;
+    let vt = this.getItem().getValueTemplate();
+    if (vt && _value.length > 0) {
+      if (vt.indexOf('$1') === -1) {
+        vt += '$1';
+      }
+      _value = vt.replace('$1', _value);
+    }
+    this.setValue(_value, silent);
+  }
+  getCardinalityTracker() {
+    return this._cardinalityTracker;
+  }
+  setCardinalityTracker(cardTracker) {
+    this._cardinalityTracker = cardTracker;
+  }
+  getItem() {
+    return this._item;
+  }
+  getStatement() {
+    return this._statement;
+  }
+  getParent() {
+    return this._parent;
+  }
+  setParent(parent) {
+    this._parent = parent;
+  }
+
+  /**
+   * A binding is valid if:
+   * <ol><li> it is a leaf and the corresponding statement is valid, </li>
+   * <li>if it is a group and at least one of its children is valid, or</li>
+   * <li>if it is a predicategroup and both the predicate and the object binding are valid.</ol>
+   */
+  isValid() {}
+  getMatchingCode() {
+    return this._matchingCode;
+  }
+  setMatchingCode(matchingCode) {
+    this._matchingCode = matchingCode;
+  }
+
+  /**
+   * stores the validity of ancestors.
+   */
+  setAncestorValid(valid) {
+    this._ancestorValid = valid;
+    this.updateAssertions();
+  }
+
+  /**
+   *
+   */
+  updateAssertions() {}
+  getHash() {
+    return this._hash;
+  }
+  addListener(listener) {
+    if (!this._listeners) {
+      this._listeners = [];
+    }
+    this._listeners.push(listener);
+  }
+  removeListener(listener) {
+    if (this._listeners) {
+      const idx = this._listeners.indexOf(listener);
+      if (idx !== -1) {
+        this._listeners.splice(idx, 1);
+      }
+    }
+  }
+  bindingChange(binding) {
+    if (this._listeners) {
+      for (let i = 0; i < this._listeners.length; i++) {
+        this._listeners[i](binding);
+      }
+    }
+    if (this._parent) {
+      this._parent.bindingChange(binding);
+    }
+    if (this._cardinalityTracker) {
+      this._cardinalityTracker.touch();
+    }
+  }
+
+  // ===================================================
+  // Private methods
+  // ===================================================
+  _isValidObjectValue(value) {
+    let _value = value;
+    if (typeof _value !== 'string' && _value !== null) {
+      throw new Error('In a binding every object value need to be a string!');
+    }
+    const pattern = this._item.getPattern();
+    if (pattern) {
+      _value = utils.extractGist(_value, this.getItem().getValueTemplate());
+      return _value !== undefined && _value !== null && _value !== '' && new RegExp(`^${pattern}$`).test(_value);
+    }
+    return _value !== undefined && _value !== null && _value !== '';
+  }
+  _isValidPredicateValue(value) {
+    if (typeof value !== 'string' && value !== null) {
+      throw new Error('In a binding every predicate need to be a string!');
+    }
+    return value !== undefined && value !== null && value !== '';
+  }
+}
+;// ./src/model/ValueBinding.js
+
+
+
+class ValueBinding extends Binding {
+  /**
+   * Corresponds to a binding for a Text item type, captures literals, literals with
+   * language, datatyped literals, or non blank resources, that is, URI's.
+   * Validity is determined by a valid predicate and object.
+   * The statement is asserted when the parents are valid and this ValueBinding is valid.
+   * @exports {rdforms/model/ValueBinding}
+   * @class
+   * @see rforms/template/Text
+   */
+  constructor(params) {
+    super(params);
+    this._validObject = true;
+    this._validPredicate = true;
+    this._excludeFromTreeValidityCheck = false;
+    if (this._statement) {
+      this._validPredicate = this._isValidPredicateValue(this._statement.getPredicate(), true);
+      this._validObject = this._isValidObjectValue(this._statement.getValue());
+    }
+  }
+
+  /**
+   * @return {String} corresponding to the value, even if the nodetype is URI
+   * or datatype says for example date.
+   */
+  getValue() {
+    return this._statement.getValue();
+  }
+
+  /**
+   * @param {String} value the value to set, the value will be trimmed and if the value is empty
+   * (like the empty string or null) the statement will be unasserted.
+   * @param {Boolean} silent if true the graph will not be marked as changed,
+   * useful when initializing with default empty values.
+   */
+  setValue(value, silent) {
+    const _value = typeof value === 'string' ? value.trim() : value;
+    const oValidObject = this._validObject;
+    if (this._isValidObjectValue(_value)) {
+      this._statement.setValue(_value, silent);
+      this._validObject = true;
+      if (oValidObject !== true && this._validPredicate === true && !this._excludeFromTreeValidityCheck) {
+        this._parent.oneChildValidityChanged(true);
+      }
+    } else {
+      // If it is a null value, change the statement.
+      if (_value === '' || _value === null) {
+        this._statement.setValue('', silent);
+      }
+      // And unassert the statement.
+      this._validObject = false;
+      if (oValidObject !== false && this._validPredicate === true) {
+        this._parent.oneChildValidityChanged(false);
+      }
+    }
+    this.updateAssertions();
+  }
+  setSubject(uri) {
+    this._statement.setSubject(uri);
+  }
+
+  /**
+   * @return {String} corresponding to a uri.
+   */
+  getPredicate() {
+    return this._statement.getPredicate();
+  }
+
+  /**
+   * @param {String} predicate corresponding to a uri.
+   */
+  setPredicate(predicate) {
+    const oValidPredicate = this._validPredicate;
+    if (this._isValidPredicateValue(predicate)) {
+      this._statement.setPredicate(predicate);
+      this._validPredicate = true;
+      if (oValidPredicate !== true && this._validObject === true) {
+        this._parent.oneChildValidityChanged(true);
+      }
+    } else {
+      // Note that we actually do not set the invalid value, just unassert the statement.
+      this._validPredicate = false;
+      if (oValidPredicate !== false && this._validObject === true) {
+        this._parent.oneChildValidityChanged(false);
+      }
+    }
+    this.updateAssertions();
+  }
+
+  /**
+   * @return {String} a two or three character language code.
+   */
+  getLanguage() {
+    return this._statement.getLanguage();
+  }
+
+  /**
+   * @param {Object} lang a two or three character language code.
+   */
+  setLanguage(lang, silent) {
+    this._statement.setLanguage(lang, silent);
+    if (!silent) {
+      this.bindingChange(this);
+    }
+  }
+
+  /**
+   * @return {String} corresponding to a uri.
+   */
+  getDatatype() {
+    return this._statement.getDatatype();
+  }
+
+  /**
+   * @param {String} dt corresponding to a uri.
+   */
+  setDatatype(dt) {
+    this._statement.setDatatype(rdfjson_namespaceObject.namespaces.expand(dt));
+    this.updateAssertions();
+  }
+  setExcludeFromTreeValidityCheck(value) {
+    this._excludeFromTreeValidityCheck = value;
+  }
+  remove() {
+    this.setValue(null);
+    this._parent.removeChildBinding(this);
+    super.remove(arguments);
+  }
+  updateAssertions() {
+    const assert = this._ancestorValid && this._validObject && this._validPredicate;
+    this._statement.setAsserted(assert, true);
+    this.bindingChange(this);
+  }
+  isValid() {
+    return this._validObject && this._validPredicate && !this._excludeFromTreeValidityCheck;
+  }
+}
+;// ./src/model/CODES.js
+/* harmony default export */ const model_CODES = ({
+  UNKNOWN: 'unknown',
+  // Used as a marker initially, to not mark everything red initially
+  OK: 'correct',
+  TOO_FEW_VALUES: 'few',
+  // deprecated
+  TOO_FEW_VALUES_MIN: 'min',
+  TOO_FEW_VALUES_PREF: 'pref',
+  TOO_MANY_VALUES: 'many',
+  AT_MOST_ONE_CHILD: 'atmostonechild',
+  AT_LEAST_ONE_CHILD: 'atleastonechild',
+  EXACTLY_ONE_CHILD: 'exactlyonechild',
+  WRONG_VALUE: 'value',
+  WRONG_PATTERN: 'pattern',
+  WRONG_NODETYPE: 'nodetype',
+  WRONG_DATATYPE: 'datatype',
+  MISSING_LANGUAGE: 'language',
+  MISSING_CONSTRAINTS: 'constraints'
+});
+;// ./src/model/ChoiceBinding.js
+
+
+const label = 'http://www.w3.org/2000/01/rdf-schema#label';
+const seeAlso = 'http://www.w3.org/2000/01/rdf-schema#seeAlso';
+
+/**
+ * A ValueBinding that only accepts uris from a controlled vocabulary encoded as choices.
+ * @see rforms.template.Choice#getChoices
+ */
+class ChoiceBinding extends ValueBinding {
+  constructor({
+    choice,
+    item,
+    statement,
+    matchingCode
+  }) {
+    super({
+      choice,
+      item,
+      statement,
+      matchingCode
+    });
+    this._choice = choice;
+    this._validPredicate = item.getProperty() != null;
+  }
+
+  // Static property on class ChoiceBinding via static getter,
+  static get seeAlso() {
+    return seeAlso;
+  }
+  setChoice(choice, silent) {
+    this._choice = choice;
+    if (choice == null) {
+      this.setValue(null, null, silent);
+    } else if (this.getValue() !== choice.value) {
+      this.setValue(choice.value, choice, silent);
+    }
+    if (choice && choice.mismatch) {
+      this.setMatchingCode(model_CODES.WRONG_VALUE);
+    } else if ((!choice || !choice.mismatch) && this.getMatchingCode() === model_CODES.WRONG_VALUE) {
+      this.setMatchingCode(model_CODES.OK);
+    }
+  }
+  getChoice() {
+    return this._choice;
+  }
+  setValue(value, choice, silent) {
+    const oldval = this.getValue();
+    super.setValue(value, choice, silent);
+    const graph = this._statement.getGraph();
+    graph.findAndRemove(oldval, label, undefined, silent);
+    graph.findAndRemove(oldval, seeAlso, undefined, silent);
+    if (value != null && choice != null) {
+      if (choice.seeAlso && choice.inlineSeeAlso) {
+        graph.create(value, seeAlso, choice.seeAlso, true, silent);
+      }
+      if (choice.inlineLabel === true) {
+        const labelMap = choice.label || {};
+        Object.keys(labelMap).forEach(lang => graph.create(value, label, {
+          value: labelMap[lang],
+          lang,
+          type: 'literal'
+        }, true, silent));
+      }
+    }
+  }
+}
+;// ./src/model/CardinalityTracker.js
+
+class CardinalityTracker {
+  /**
+   * A counter paired with a item with cardinality restrictions.
+   * To update the counter use the increment and decrement methods.
+   * If the counter passes a cardinality restriction the
+   * corresponding hook is called, that is, maxReached, minReached,
+   * and justFine when the counter moved within the acceptable
+   * cardinality restrictions.
+   */
+  constructor(item) {
+    this._listener = [];
+    this._limits = item.getCardinality() || {};
+    this._counter = 0;
+    this._depsOk = true;
+    this._listeners = [];
+    this._code = 0;
+  }
+  addListener(listener) {
+    this._listeners.push(listener);
+    return listener;
+  }
+  removeListener(listener) {
+    this._listeners.splice(this._listeners.indexOf(listener), 1);
+  }
+  cardinalityChanged() {
+    this._listeners.forEach(listener => listener());
+  }
+
+  // ===================================================
+  // Public API
+  // ===================================================
+  getCardinality() {
+    return this._counter;
+  }
+  isMax() {
+    return this._limits.max != null && this._counter >= this._limits.max;
+  }
+  isMin() {
+    return this._limits.min != null && this._counter <= this._limits.min;
+  }
+  isFine() {
+    return this._fine;
+  }
+  isDepsOk() {
+    return this._depsOk;
+  }
+  getCode() {
+    return this._code;
+  }
+  setCode(code) {
+    if (this._code !== code) {
+      this._code = code;
+      this.cardinalityChanged();
+    }
+  }
+  setDepsOk(ok) {
+    if (this._depsOk !== ok) {
+      this._code = model_CODES.UNKNOWN;
+      this._depsOk = ok;
+      this.cardinalityChanged();
+    }
+  }
+  increment() {
+    this._counter += 1;
+    this._code = model_CODES.UNKNOWN;
+    this._checkCounter();
+  }
+  decrement() {
+    this._counter -= 1;
+    this._code = model_CODES.UNKNOWN;
+    this._checkCounter();
+  }
+  getCounter() {
+    return this._counter;
+  }
+  checkCardinality() {
+    this._checkCounter();
+  }
+  touch() {
+    this._code = model_CODES.UNKNOWN;
+    this.cardinalityChanged();
+  }
+
+  // ===================================================
+  // Private methods
+  // ===================================================
+  _checkCounter() {
+    if (this._limits.max != null && this._counter === this._limits.max) {
+      this._fine = true;
+    } else if (this._limits.max != null && this._counter > this._limits.max) {
+      this._fine = false;
+    } else if (this._limits.min != null && this._counter === this._limits.min) {
+      this._fine = true;
+    } else if (this._limits.min != null && this._counter < this._limits.min) {
+      this._fine = false;
+    }
+    this.cardinalityChanged();
+  }
+}
+;// ./src/model/GroupBinding.js
+
+
+class GroupBinding extends Binding {
+  /**
+   * Corresponds to a binding for a Group item type.
+   * Handles sub-bindings grouped by item.
+   * Validity of a group is determined by at least one of the sub-bindings being valid.
+   * All sub-bindings must notify when their validity changed so that the validity of
+   * the parent group can be checked and possibly updated.
+   * Potential statement and constraints are asserted when both parents are valid and this GroupBinding is valid.
+   *
+   * @see template/Group
+   */
+  constructor(params) {
+    super(params);
+    const {
+      constraints = [],
+      childrenRootUri = null
+    } = params;
+    this._constraints = constraints;
+    // Generates an array of arrays, one array for each child item.
+
+    this._childBindings = this._item.getChildren().map(() => []);
+    this._rootUri = childrenRootUri;
+    this._validPredicate = true;
+    this._validObject = true;
+    if (this._statement) {
+      this._validPredicate = this._isValidPredicateValue(this._statement.getPredicate());
+      this._validObject = this._isValidObjectValue(this._statement.getValue(), this._statement.getType());
+    }
+    this._cachedChildBindings = null;
+  }
+
+  // ===================================================
+  // Public API
+  // ===================================================
+
+  getValue() {
+    return this.getChildrenRootUri();
+  }
+  oneChildValidityChanged(valid) {
+    if (valid === this._oneValidChild) {
+      return false; // No change
+    }
+    if (!valid) {
+      // Since we do not keep track of which children have valid values,
+      // we need to iterate through all children to check if some other child has a valid value
+      // (and check if valid predicate) if so, abort change.
+      delete this._oneValidChild;
+      if (this.isValid()) {
+        return false; // No change
+      }
+    }
+
+    // Below we change the valid state of this group.
+    this._oneValidChild = valid;
+    // If there is no parent or it's valid state did not change,
+    // then the groups assertions has not been changed and the children
+    // have not been notified of this group change in validity.
+    this._notifyValidityChange(valid && this._validPredicate && this._validObject);
+    return this._validPredicate && this._validObject; // Validity of group changed only if valid predicate and object.
+  }
+  setSubject(uri) {
+    if (this._statement) {
+      this._statement.setSubject(uri);
+    } else {
+      this.getChildBindings().forEach(cb => cb.setSubject(uri));
+    }
+  }
+  getChildrenRootUri() {
+    if (this._statement) {
+      // Either the object of the statement.
+      return this._statement.getValue();
+    } else if (this._rootUri != null) {
+      return this._rootUri;
+    } else if (this._parent != null) {
+      return this._parent.getChildrenRootUri();
+    }
+    return undefined;
+  }
+  addChildBinding(binding) {
+    this.addChildBindings([binding]);
+  }
+  addChildBindings(bindings) {
+    this._cachedChildBindings = null;
+    if (!Array.isArray(bindings) || bindings.length === 0) {
+      return;
+    }
+    const item = bindings[0].getItem();
+    const children = this._item.getChildren();
+    for (let i = children.length; i >= 0; i--) {
+      if (item === children[i]) {
+        const cardTracker = this._childBindings[i].length > 0 ? this._childBindings[i][0].getCardinalityTracker() : new CardinalityTracker(item);
+        this._childBindings[i] = this._childBindings[i].concat(bindings);
+        bindings.forEach(binding => {
+          binding.setParent(this);
+          binding.setCardinalityTracker(cardTracker);
+          cardTracker.increment();
+        }, this);
+        break;
+      }
+    }
+  }
+  removeChildBinding(binding) {
+    this._cachedChildBindings = null;
+    const children = this._item.getChildren();
+    for (let i = children.length; i >= 0; i--) {
+      if (binding.getItem() === children[i]) {
+        this._childBindings[i].splice(this._childBindings[i].indexOf(binding), 1);
+        delete binding._parent;
+        binding.getCardinalityTracker().decrement();
+        break;
+      }
+    }
+    this.oneChildValidityChanged();
+    this.bindingChange(binding);
+  }
+  getChildBindingsFor(item) {
+    const children = this._item.getChildren();
+    for (let i = children.length; i >= 0; i--) {
+      if (item === children[i]) {
+        return this._childBindings[i];
+      }
+    }
+    return undefined;
+  }
+  getItemGroupedChildBindings() {
+    return this._childBindings;
+  }
+  getChildBindings() {
+    if (this._cachedChildBindings == null) {
+      if (this._childBindings && this._childBindings.length > 0) {
+        this._cachedChildBindings = [].concat(...this._childBindings);
+      } else {
+        this._cachedChildBindings = [];
+      }
+    }
+    return this._cachedChildBindings;
+  }
+  setPredicate(predicate) {
+    const oValidPredicate = this._validPredicate;
+    if (this._isValidPredicateValue(predicate)) {
+      this._statement.setPredicate(predicate);
+      this._validPredicate = true;
+      if (oValidPredicate !== true && this._validObject && (this.getItem().getNodetype() === 'URI' ? true : this._oneValidChild)) {
+        this._notifyValidityChange(true);
+      }
+    } else {
+      // Note that we actually do not set the invalid value, just unassert the statement.
+      this._validPredicate = false;
+      if (oValidPredicate !== false && this._validObject && (this.getItem().getNodetype() === 'URI' ? true : this._oneValidChild)) {
+        this._notifyValidityChange(false);
+      }
+    }
+    this.updateAssertions();
+  }
+
+  // eslint-disable-next-line no-dupe-class-members
+  getValue() {
+    if (this._statement && this._statement.isObjectBlank()) {
+      return '';
+    }
+    return this._statement && this._statement.getValue();
+  }
+  setValue(value) {
+    if (this.getItem().getNodetype() !== 'URI' || !this._statement) {
+      throw new Error('Cannot change the value of a group unless its nodetype is URI and' + ' also that it corresponds to a statement');
+    }
+    const oldIsValidObject = this._validObject;
+    const isValidObject = this._isValidObjectValue(value, 'uri');
+    if (isValidObject) {
+      this._validObject = true;
+      this._statement._o.type = 'uri';
+      this._statement.setValue(value);
+      this._constraints.forEach(stmt => stmt.setSubject(value));
+      this.getChildBindings().forEach(cb => cb.setSubject(value));
+      if (!oldIsValidObject && this._validPredicate) {
+        this._notifyValidityChange(true);
+      }
+    } else {
+      this._validObject = false;
+      if (oldIsValidObject && this._validPredicate) {
+        this._notifyValidityChange(false);
+      }
+    }
+  }
+  getPredicate() {
+    return this._statement ? this._statement.getPredicate() : undefined;
+  }
+  remove() {
+    this._oneValidChild = false;
+    this.setAncestorValid(false);
+    if (this._parent != null) {
+      this._parent.removeChildBinding(this);
+    }
+    super.remove(arguments);
+  }
+  _isValid() {
+    if (this.getItem().getNodetype() === 'URI') {
+      return this._validObject && this._validPredicate;
+    }
+    return this._oneValidChild && this._validPredicate && this._validObject;
+  }
+  isValid() {
+    if (this._oneValidChild == null) {
+      this._oneValidChild = this._forceOneValidChildCheck();
+    }
+    return this._isValid();
+  }
+  setAncestorValid(valid) {
+    this._ancestorValid = valid;
+    this.updateAssertions();
+    this._childBindings.forEach(bindingArr => bindingArr.forEach(binding => binding.setAncestorValid(valid && this._isValid()), this), this);
+  }
+  updateAssertions() {
+    if (this._oneValidChild == null) {
+      this.isValid();
+    }
+    const assert = this._ancestorValid && this._isValid();
+    if (this._statement != null) {
+      this._statement.setAsserted(assert);
+    }
+    this._constraints.forEach(constraintStmt => constraintStmt.setAsserted(assert));
+    this.getChildBindings().forEach(binding => binding.updateAssertions());
+  }
+
+  // ===================================================
+  // Private methods
+  // ===================================================
+  _forceOneValidChildCheck() {
+    return this._childBindings.some(arr => arr.some(binding => binding.isValid()));
+  }
+  _notifyValidityChange(newValidity) {
+    if (!this._parent || !this._parent.oneChildValidityChanged(newValidity)) {
+      // We can reuse the setAncestorValid method by setting the current value.
+      this.updateAssertions();
+      this._childBindings.forEach(bindingArr => bindingArr.forEach(binding => binding.setAncestorValid(newValidity)));
+    }
+  }
+  _isValidObjectValue(value, type) {
+    if (this.getItem().getNodetype() === 'URI' && type !== 'uri') {
+      return false;
+    }
+    return super._isValidObjectValue(value);
+  }
+}
+;// ./src/model/PropertyChoiceBinding.js
+/* eslint-disable class-methods-use-this */
+
+class PropertyChoiceBinding extends ChoiceBinding {
+  /**
+   * Are only used as the first child of a PropertyGroupBinding to capture
+   * a variable predicate.
+   */
+  constructor(params) {
+    super(params);
+    this._objectBinding = params.objectBinding;
+  }
+
+  /**
+   * Remove shold not be doubled, hence it is handled by the objectBinding
+   * delegated from the parent PropertyGroupBinding.
+   */
+  remove() {}
+
+  /**
+   * The object binding handles the RDF statement, hence go through it to set
+   * the predicate, note not the setValue function because that sets the object
+   * rather than the predicate.
+   * @param {Object} value
+   */
+  setValue(value) {
+    this._objectBinding.setPredicate(value);
+  }
+  getValue() {
+    return this._objectBinding.getPredicate();
+  }
+
+  /**
+   * Validity is controlled via the objectBinding, when it is valid the
+   * parent PropertyGroupBinding will be valid since only one child is
+   * enough to enable validity. Hence, this PropertyChoiceBinding can
+   * be false all the time since it has no children and does not affect
+   * the above hierarchy (and does not control assertment of statements).
+   */
+  isValid() {
+    return false;
+  }
+
+  /**
+   * Does nothing, similar reason as for isValid.
+   */
+  updateAssertions() {}
+}
+;// ./src/model/PropertyGroupBinding.js
+
+
+
+
+
+
+class PropertyGroupBinding extends GroupBinding {
+  /**
+   * This is a syntactical grouping to capture the case when both the predicate and
+   * the object is variable. It is achieved by having exactly two children, the first being
+   * a binding for the predicate in the form of a PredicateChoiceBinding and the second
+   * being a binding for the object. The object binding can be a ValueBinding, ChoiceBinding or
+   * a GroupBinding. It is not allowed to be another PropertyGroupBinding though.
+   *
+   * @see rforms.template.PropertyGroup
+   */
+  constructor(params) {
+    super(params);
+    const {
+      statement,
+      constraints
+    } = params;
+    this._statement = undefined;
+    this._validPredicate = true; // Reset to initial value to ignore check from incorrect given statement in this case.
+    this._constraints = [];
+    const children = this._item.getChildren();
+    const item = children[1];
+    let oBinding;
+    if (item instanceof Group) {
+      oBinding = new GroupBinding({
+        item,
+        statement,
+        constraints
+      });
+    } else if (item instanceof Choice) {
+      oBinding = new ChoiceBinding({
+        item,
+        statement
+      });
+    } else {
+      oBinding = new ValueBinding({
+        item,
+        statement
+      });
+    }
+    const pBinding = new PropertyChoiceBinding({
+      item: children[0],
+      objectBinding: oBinding
+    });
+    this.addChildBinding(pBinding);
+    this.addChildBinding(oBinding);
+  }
+
+  // ===================================================
+  // Public API
+  // ===================================================
+  getPredicateBinding() {
+    return this._childBindings[0][0];
+  }
+  getObjectBinding() {
+    return this._childBindings[1][0];
+  }
+  getGraph() {
+    return this.getObjectBinding().getGraph();
+  }
+}
+;// ./src/model/GroupURIBinding.js
+
+
+/**
+ * A binding corresponding to a text item with no property, allowing editing the
+ * object in the statement of the group above.
+ * The purpose it to allow editing URIs inside of a hierarchy, e.g. consider the following graph:
+ *
+ * http://example.com rdfs:seeAlso http://slashdot.org .
+ * http://slashdot.org rdfs:label "Slashdot" .
+ *
+ * Allowing to edit both the URI (slashdot above) and it's label requires a construction like the following:
+ *
+ *  - GroupItem with property rdfs:seeAlso   (GroupBinding)
+ *     - TextItem without property           (GroupURIBinding)
+ *     - TextItem with property rdfs:label   (ValueBinding)
+ *
+ * @exports {rdforms/model/GroupURIBinding}
+ * @class
+ * @see rdforms/template/Text
+ */
+class GroupURIBinding extends ValueBinding {
+  /**
+   * @return {String} corresponding to the value, even if the nodetype is URI
+   * or datatype says for example date.
+   */
+  getValue() {
+    return this._parent.getValue();
+  }
+  setValue(value) {
+    return this._parent.setValue(value);
+  }
+  getGist() {
+    return this._parent.getGist();
+  }
+  setGist(value, silent) {
+    return this._parent.setGist(value, silent);
+  }
+  setSubject(uri) {}
+
+  /**
+   * @return {String} corresponding to a uri.
+   */
+  getPredicate() {
+    return this._parent.getPredicate();
+  }
+  remove() {
+    this._parent.removeChildBinding(this);
+    super.remove(arguments);
+  }
+  updateAssertions() {}
+  isValid() {
+    return true;
+  }
+}
+;// ./src/model/engine.js
+/* eslint-disable no-use-before-define */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// See public API at the bottom of this file.
+
+let _matchGroupItemChildren;
+let _clearDibbs;
+let _noDibbs;
+let _dibbs;
+let _createStatementsForConstraints;
+let _fuzzy = false;
+const match = (graph, uri, template) => {
+  const rootBinding = new GroupBinding({
+    item: template,
+    childrenRootUri: uri,
+    graph
+  });
+  _matchGroupItemChildren(rootBinding);
+  _clearDibbs(rootBinding);
+  return rootBinding;
+};
+const fuzzyMatch = (graph, uri, template) => {
+  const rootBinding = new GroupBinding({
+    item: template,
+    childrenRootUri: uri,
+    graph
+  });
+  _matchGroupItemChildren(rootBinding);
+  _fuzzy = true;
+  _matchGroupItemChildren(rootBinding);
+  _fuzzy = false;
+  _clearDibbs(rootBinding);
+  return rootBinding;
+};
+const constructTemplate = (graph, uri, itemStore, requiredItems) => {
+  const props = graph.findProperties(uri);
+  const items = [];
+  const fixedProps = {};
+  if (requiredItems != null) {
+    const addProperty = item => {
+      if (item.getProperty() != null) {
+        fixedProps[item.getProperty()] = true;
+      } else if (item instanceof Group) {
+        item.getChildren().forEach(addProperty);
+      }
+    };
+    const addItem = item => {
+      if (item != null) {
+        addProperty(item);
+        items.push(item);
+      }
+    };
+    requiredItems.forEach(id => {
+      let item = itemStore.getItem(id);
+      if (item != null) {
+        if (item instanceof Group && item.getProperty() == null) {
+          item.getChildren().forEach(addItem);
+        } else {
+          addItem(item);
+        }
+      } else {
+        item = itemStore.getItemByProperty(id);
+        if (item) {
+          addItem(item);
+        } else {
+          console.warn(`Warning, when autodetecting a template: Required item '${id}' is neither an id for a loaded item or a property for a loaded item, ignoring.`);
+        }
+      }
+    });
+  }
+  props.forEach(prop => {
+    if (fixedProps[prop]) {
+      return;
+    }
+    const item = itemStore.getItemByProperty(prop);
+    if (item != null) {
+      items.push(item);
+    }
+  }, undefined);
+  // TODO sort according to priority.
+  return itemStore.createTemplateFromChildren(items);
+};
+
+//= ==============================================
+// Core creation engine
+//= ==============================================
+const getFirstDataType = item => Array.isArray(item.getDatatype()) ? item.getDatatype()[0] : item.getDatatype();
+const _createTextItem = (parentBinding, item) => {
+  if (!item.getProperty()) {
+    const groupURIBinding = new GroupURIBinding({
+      item,
+      statement: null,
+      matchingCode: model_CODES.OK
+    });
+    parentBinding.addChildBinding(groupURIBinding);
+    return groupURIBinding;
+  }
+  const graph = parentBinding.getGraph();
+  const nt = item.getNodetype();
+  const obj = {
+    value: '',
+    type: 'literal'
+  };
+  if (nt === 'URI') {
+    obj.type = 'uri';
+  } else if (nt === 'DATATYPE_LITERAL') {
+    obj.datatype = getFirstDataType(item);
+  }
+  const defaultValue = item.getValue();
+  if (defaultValue != null && parentBinding.getChildBindingsFor(item).length === 0) {
+    obj.value = defaultValue;
+    const la = item.getLanguage();
+    if (la != null) {
+      obj.lang = la;
+    }
+  }
+  const stmt = graph.create(parentBinding.getChildrenRootUri(), item.getProperty(), obj, false);
+  const nbinding = new ValueBinding({
+    item,
+    statement: stmt
+  });
+  parentBinding.addChildBinding(nbinding);
+  return nbinding;
+};
+const _createChoiceItem = (parentBinding, item) => {
+  const graph = parentBinding.getGraph();
+  const nt = item.getNodetype();
+  const obj = {
+    type: 'literal',
+    value: ''
+  };
+  if (nt === 'DATATYPE_LITERAL') {
+    obj.datatype = getFirstDataType(item);
+  } else if (nt === 'RESOURCE' || nt === 'URI') {
+    obj.type = 'uri';
+  }
+  const stmt = graph.create(parentBinding.getChildrenRootUri(), item.getProperty(), obj, false);
+  const nbinding = new ChoiceBinding({
+    item,
+    statement: stmt
+  });
+  parentBinding.addChildBinding(nbinding);
+  const defaultValue = item.getValue();
+  const cardTracker = nbinding.getCardinalityTracker();
+  if (defaultValue != null && cardTracker.getCounter() === 1) {
+    nbinding.setChoice(_findChoice(item, defaultValue, graph), true);
+  }
+  return nbinding;
+};
+const _createGroupItem = (parentBinding, item, parentItems) => {
+  let stmt;
+  let constr;
+  if (item.getProperty() !== undefined) {
+    const graph = parentBinding.getGraph();
+    if (item.getNodetype() === 'URI') {
+      /*stmt = graph.create(parentBinding.getChildrenRootUri(), item.getProperty(), {
+        type: 'uri',
+        value: system.createURI(item, parentBinding),
+      }, false);*/
+      // Create as a blank, will not be asserted until changed into a uri.
+      stmt = graph.create(parentBinding.getChildrenRootUri(), item.getProperty(), null, false);
+    } else {
+      stmt = graph.create(parentBinding.getChildrenRootUri(), item.getProperty(), null, false);
+    }
+    constr = _createStatementsForConstraints(graph, stmt.getValue(), item);
+  }
+  const nBinding = new GroupBinding({
+    item,
+    statement: stmt,
+    constraints: constr
+  });
+  parentBinding.addChildBinding(nBinding);
+
+  // Only do loop detection for items that are stored in the itemStore and hence are
+  // used in more than one place.
+  const itemId = item._source['@id'];
+  if (itemId) {
+    // If loop stop.
+    if (parentItems[itemId]) {
+      return nBinding;
+    }
+    parentItems[itemId] = true;
+  }
+  // Do not create substructures directly, let the view model and user interaction decide
+  // when to create children.
+  /*
+  array.forEach(item.getChildren(), function(childItem) {
+       create(nBinding, childItem, parentItems);
+  }); */
+  return nBinding;
+};
+const _createPropertyGroupItem = (parentBinding, item) => {
+  let stmt;
+  let constr;
+  const oItem = item.getChildren()[1];
+  const graph = parentBinding.getGraph();
+  if (oItem instanceof Group) {
+    stmt = graph.create(parentBinding.getChildrenRootUri(), '', null, false);
+    constr = _createStatementsForConstraints(graph, stmt.getSubject(), oItem);
+  } else if (oItem instanceof Choice) {
+    stmt = graph.create(parentBinding.getChildrenRootUri(), '', {
+      type: 'uri',
+      value: ''
+    }, false);
+  } else {
+    stmt = graph.create(parentBinding.getChildrenRootUri(), '', {
+      type: 'literal',
+      value: ''
+    }, false);
+  }
+  const nBinding = new PropertyGroupBinding({
+    item,
+    statement: stmt,
+    constraints: constr
+  });
+  parentBinding.addChildBinding(nBinding);
+  if (oItem instanceof Group) {
+    oItem.getChildren().forEach(childItem => {
+      create(nBinding.getObjectBinding(), childItem);
+    });
+  }
+  return nBinding;
+};
+const create = (parentBinding, item, parentItems) => {
+  if (item instanceof Text) {
+    return _createTextItem(parentBinding, item);
+  } else if (item instanceof PropertyGroup) {
+    return _createPropertyGroupItem(parentBinding, item);
+  } else if (item instanceof Group) {
+    return _createGroupItem(parentBinding, item, parentItems || {});
+  } else if (item instanceof Choice) {
+    return _createChoiceItem(parentBinding, item);
+  }
+  return undefined;
+};
+
+// ===============================================
+// Core matching engine
+// ===============================================
+
+let _matchItem;
+let _isNodeTypeMatch;
+let _isDataTypeMatch;
+let _isPatternMatch;
+let _findChoice;
+let _findStatementsForConstraints;
+_matchGroupItemChildren = pb => {
+  if (_fuzzy) {
+    pb.getChildBindings().forEach(cb => {
+      if (cb.getItem().getType() === 'group') {
+        _matchGroupItemChildren(cb);
+      }
+    });
+  }
+  pb.getItem().getChildren().forEach(item => {
+    if (_fuzzy) {
+      if (item.getProperty() !== undefined) {
+        _matchItem(pb, item);
+      }
+    } else {
+      _matchItem(pb, item);
+    }
+  });
+};
+const _matchGroupItem = (pb, item) => {
+  let stmts;
+  let bindings;
+  let constStmts;
+  let groupBinding;
+  const graph = pb.getGraph();
+  // Case 1: there is a property in the item
+  if (item.getProperty() !== undefined) {
+    stmts = graph.find(pb.getChildrenRootUri(), item.getProperty());
+    if (stmts.length > 0) {
+      bindings = [];
+      stmts.forEach(stmt => {
+        if (_noDibbs(stmt)) {
+          const pMatch = _isPatternMatch(item, stmt);
+          const ntMatch = _isNodeTypeMatch(item, stmt);
+          if (pMatch && ntMatch || _fuzzy) {
+            constStmts = _findStatementsForConstraints(graph, stmt.getValue(), item);
+            if (constStmts !== undefined || _fuzzy) {
+              let matchingCode = !ntMatch ? model_CODES.WRONG_NODETYPE : model_CODES.OK;
+              if (!pMatch) {
+                matchingCode = model_CODES.WRONG_PATTERN;
+              } else if (constStmts === undefined) {
+                matchingCode = model_CODES.MISSING_CONSTRAINTS;
+              }
+              _dibbs(stmt);
+              groupBinding = new GroupBinding({
+                item,
+                statement: stmt,
+                constraints: constStmts,
+                matchingCode
+              });
+              bindings.push(groupBinding);
+              if (matchingCode === model_CODES.OK) {
+                _matchGroupItemChildren(groupBinding); // Recursive call
+              }
+            }
+          }
+        }
+      });
+      pb.addChildBindings(bindings);
+    }
+    // Case 2: there is no property in the item, i.e. a layout item.
+  } else {
+    groupBinding = new GroupBinding({
+      item
+    });
+    pb.addChildBindings([groupBinding]);
+    _matchGroupItemChildren(groupBinding); // Recursive call
+  }
+};
+const _matchPropertyGroupItem = (pb, item) => {
+  const pItem = item.getPropertyItem();
+  const oItem = item.getObjectItem();
+  const graph = pb.getGraph();
+  let constStmts;
+  let binding;
+  let pChoice;
+  let oChoice;
+  const bindings = [];
+  graph.find(pb.getChildrenRootUri()).forEach(stmt => {
+    if (_noDibbs(stmt) && _isNodeTypeMatch(oItem, stmt) && _isPatternMatch(oItem, stmt)) {
+      pChoice = _findChoice(pItem, stmt.getPredicate(), stmt.getGraph());
+      if (pChoice !== undefined) {
+        binding = null;
+        if (oItem instanceof Group) {
+          constStmts = _findStatementsForConstraints(graph, stmt.getValue(), oItem);
+          if (constStmts !== undefined) {
+            _dibbs(stmt);
+            binding = new PropertyGroupBinding({
+              item,
+              statement: stmt,
+              constraints: constStmts
+            });
+            _matchGroupItemChildren(binding.getObjectBinding()); // Recursive call
+          }
+        } else if (oItem instanceof Choice) {
+          oChoice = _findChoice(oItem, stmt.getValue(), stmt.getGraph());
+          if (oChoice !== undefined) {
+            _dibbs(stmt);
+            binding = new PropertyGroupBinding({
+              item,
+              statement: stmt
+            });
+            binding.getObjectBinding().setChoice(oChoice);
+          }
+        } else {
+          _dibbs(stmt);
+          binding = new PropertyGroupBinding({
+            item,
+            statement: stmt
+          });
+        }
+        if (binding !== null) {
+          binding.getPredicateBinding().setChoice(pChoice);
+          bindings.push(binding);
+        }
+      }
+    }
+  });
+  if (bindings.length > 0) {
+    pb.addChildBindings(bindings);
+  }
+};
+const _matchTextItem = (pb, item) => {
+  const bindings = [];
+  if (item.getProperty() == null) {
+    bindings.push(new GroupURIBinding({
+      item,
+      statement: null,
+      matchingCode: model_CODES.OK
+    }));
+  } else {
+    pb.getGraph().find(pb.getChildrenRootUri(), item.getProperty()).forEach(stmt => {
+      if (_noDibbs(stmt) && _isPatternMatch(item, stmt)) {
+        const ntMatch = _isNodeTypeMatch(item, stmt);
+        const dtMatch = _isDataTypeMatch(item, stmt);
+        if (ntMatch && (dtMatch || item.hasStyle('relaxedDatatypeMatch')) || _fuzzy) {
+          _dibbs(stmt);
+          let matchingCode = ntMatch ? model_CODES.OK : model_CODES.WRONG_NODETYPE;
+          if (!dtMatch) {
+            matchingCode = model_CODES.WRONG_DATATYPE;
+          }
+          bindings.push(new ValueBinding({
+            item,
+            statement: stmt,
+            matchingCode
+          }));
+        }
+      }
+    });
+  }
+  if (bindings.length > 0) {
+    pb.addChildBindings(bindings);
+  }
+};
+const _matchChoiceItem = (pb, item) => {
+  if (item.getProperty() == null) {
+    return;
+  }
+  const bindings = [];
+  pb.getGraph().find(pb.getChildrenRootUri(), item.getProperty()).forEach(stmt => {
+    if (_noDibbs(stmt)) {
+      const ntMatch = _isNodeTypeMatch(item, stmt);
+      const dtMatch = _isDataTypeMatch(item, stmt);
+      const pMatch = _isPatternMatch(item, stmt);
+      if (ntMatch && dtMatch && pMatch || _fuzzy) {
+        const choice = _findChoice(item, stmt.getValue(), stmt.getGraph());
+        if (choice !== undefined) {
+          _dibbs(stmt);
+          let matchingCode = !ntMatch ? model_CODES.WRONG_NODETYPE : model_CODES.OK;
+          if (!dtMatch) {
+            matchingCode = model_CODES.WRONG_DATATYPE;
+          } else if (!pMatch) {
+            matchingCode = model_CODES.WRONG_PATTERN;
+          } else if (choice.mismatch) {
+            matchingCode = model_CODES.WRONG_VALUE;
+          }
+          bindings.push(new ChoiceBinding({
+            item,
+            statement: stmt,
+            choice,
+            matchingCode
+          }));
+        }
+      }
+    }
+  });
+  if (bindings.length > 0) {
+    pb.addChildBindings(bindings);
+  }
+};
+_matchItem = (pb, item) => {
+  if (item instanceof Choice) {
+    _matchChoiceItem(pb, item);
+  } else if (item instanceof PropertyGroup) {
+    _matchPropertyGroupItem(pb, item);
+  } else if (item instanceof Group) {
+    _matchGroupItem(pb, item);
+  } else if (item instanceof Text) {
+    _matchTextItem(pb, item);
+  }
+};
+
+// ===============================================
+// Utility functions used for matching purposes
+// ===============================================
+
+/**
+ * Compares the the type specified in the item and the type of the statements object.
+ * @param {rdforms/template/Item} item
+ * @param {jsonrdf/Statement} stmt
+ */
+_isNodeTypeMatch = (item, stmt) => {
+  const objectType = stmt.getType();
+  // eslint-disable-next-line default-case
+  switch (item.getNodetype()) {
+    case 'LITERAL': // Any form of literal
+    case 'ONLY_LITERAL': // No language, no datatype
+    case 'PLAIN_LITERAL': // No datatype, perhaps a language
+    case 'LANGUAGE_LITERAL':
+      // Definitely a language
+      return objectType === 'literal';
+    case 'DATATYPE_LITERAL':
+      // Definitiely a datatype
+      return objectType === 'literal';
+    case 'RESOURCE':
+      return objectType === 'uri' || objectType === 'bnode';
+    case 'URI':
+      return objectType === 'uri';
+    case 'BLANK':
+      return objectType === 'bnode';
+  }
+  return false;
+};
+_isDataTypeMatch = (item, stmt) => {
+  const dt = item.getNodetype() === 'DATATYPE_LITERAL' ? item.getDatatype() || null : null;
+  if (dt != null) {
+    return Array.isArray(dt) ? dt.indexOf(stmt.getDatatype()) !== -1 : stmt.getDatatype() === dt;
+  }
+  return true;
+};
+_isPatternMatch = (item, stmt) => {
+  const pattern = item.getPattern();
+  const value = utils.extractGist(stmt.getValue(), item.getValueTemplate());
+  if (typeof pattern !== 'undefined') {
+    try {
+      return new RegExp(`^${pattern}$`).test(value);
+    } catch (e) {
+      return true;
+    }
+  }
+  return true;
+};
+
+/**
+ * Matches constraints in the item to statements in the graph with the given uri as subject.
+ *
+ * @param {rdfjson/Graph} graph containing all available statements to match against.
+ * @param {String} uri the subject to start matching from
+ * @param {rdforms/template/Item} item containing the constraints.
+ * @return an array of statements on success, undefined on failure.
+ *  If there are no constraints to match in the item an empty array is returned.
+ */
+_findStatementsForConstraints = (graph, uri, item) => {
+  let stmts;
+  const constr = item.getConstraints();
+  const results = [];
+  const f = (predicate, object) => {
+    stmts = graph.find(uri, predicate, {
+      type: 'uri',
+      value: object
+    });
+    if (stmts.length === 1) {
+      results.push(stmts[0]);
+      return undefined;
+    }
+    return false;
+  };
+  if (typeof constr === 'object' && constr !== null) {
+    const keys = Object.keys(constr);
+    for (let idx = 0; idx < keys.length; idx++) {
+      const key = keys[idx];
+      const obj = constr[key];
+      if (obj instanceof Array) {
+        let noMatch = true;
+        obj.forEach(o => {
+          if (f(key, o) !== false) {
+            noMatch = false;
+          }
+        });
+        if (noMatch) {
+          return undefined;
+        }
+      } else if (f(key, obj) === false) {
+        return undefined;
+      }
+    }
+    return results;
+  }
+  return [];
+};
+_createStatementsForConstraints = (graph, uri, item) => {
+  const results = [];
+  const constr = item.getConstraints();
+  if (typeof constr === 'object' && constr !== null) {
+    Object.keys(constr).forEach(key => {
+      const obj = constr[key];
+      if (Array.isArray(obj)) {
+        results.push(graph.create(uri, key, {
+          type: 'uri',
+          value: obj[0]
+        }, false));
+      } else {
+        results.push(graph.create(uri, key, {
+          type: 'uri',
+          value: obj
+        }, false));
+      }
+    });
+  }
+  return results;
+};
+_findChoice = (item, obj, graph) => {
+  let index;
+  let choices;
+  if (item.hasChoices()) {
+    choices = item.getChoices();
+    for (index = 0; index < choices.length; index++) {
+      if (choices[index].value === obj) {
+        return choices[index];
+      }
+    }
+    if (!item.hasStyle('strictmatch') || _fuzzy) {
+      return {
+        value: obj,
+        label: {
+          '': obj
+        },
+        mismatch: true
+      };
+    }
+  } else {
+    let label = utils.getLocalizedMap(graph, obj, item.getLabelProperties());
+    if (label == null && _fuzzy) {
+      label = {
+        '': obj,
+        mismatch: true
+      };
+    }
+    const sa = graph.findFirstValue(obj, ChoiceBinding.seeAlso);
+    if (label != null) {
+      const choice = {
+        label,
+        value: obj
+      };
+      if (sa) {
+        choice.seeAlso = sa;
+      }
+      return choice;
+    } else if (system.getChoice != null) {
+      return system.getChoice(item, obj, sa, graph);
+    }
+  }
+  return undefined;
+};
+_dibbs = stmt => {
+  stmt._dibbs = true;
+};
+_noDibbs = stmt => stmt._dibbs !== true;
+_clearDibbs = groupBinding => {
+  let i;
+  let j;
+  let arr;
+  const arrarr = groupBinding.getItemGroupedChildBindings() || [];
+  for (i = 0; i < arrarr.length; i++) {
+    arr = arrarr[i];
+    for (j = 0; j < arr.length; j++) {
+      const binding = arr[j];
+      if (binding._statement) {
+        delete binding._statement._dibbs;
+      }
+      if (binding instanceof GroupBinding || binding instanceof PropertyGroupBinding) {
+        _clearDibbs(binding);
+      }
+    }
+  }
+};
+const findFirstValueBinding = (binding, createIfMissing) => {
+  if (binding instanceof ValueBinding) {
+    return binding;
+  }
+  const cbs = binding.getItemGroupedChildBindings();
+  const loc = external_moment_default().locale();
+  for (let idx = 0; idx < cbs.length; idx++) {
+    const vbs = cbs[idx];
+    const childItem = binding.getItem().getChildren()[idx];
+    if (vbs.length !== 0) {
+      if (!(childItem instanceof Text)) {
+        return findFirstValueBinding(vbs[0]);
+      } else if (childItem.getNodetype() === 'LANGUAGE_LITERAL') {
+        const result = {
+          firstValue: vbs[0]
+        };
+        for (let i = 0; i < vbs.length; i++) {
+          const l = vbs[i].getLanguage();
+          if (l == null) {
+            result.emptyLanguageValue = vbs[i];
+          } else if (l === loc) {
+            result.perfectLocaleLanguageValue = vbs[i];
+          } else if (l.substring(0, 1) === loc.substring(0, 1)) {
+            result.localeLanguageValue = vbs[i];
+          } else if (l.indexOf('en') !== -1) {
+            result.defaultLanguageValue = vbs[i];
+          } else {
+            result.anyLanguageValue = vbs[i];
+          }
+        }
+        return result.perfectLocaleLanguageValue || result.localeLanguageValue || result.defaultLanguageValue || result.anyLanguageValue || result.firstValue;
+      }
+      return vbs[0];
+    } else if (createIfMissing) {
+      const b = create(binding, childItem, {});
+      if (b instanceof ValueBinding) {
+        b.setLanguage(loc);
+        return b;
+      }
+      return findFirstValueBinding(b, true);
+    }
+  }
+  return undefined;
+};
+const matchPathBelowBinding = (bindingTree, path) => {
+  const _path = path[0] === '/' ? path.slice(1) : path;
+  const gb = bindingTree.getItemGroupedChildBindings();
+  const pred = _path[0];
+  for (let i = 0; i < gb.length; i++) {
+    const bindings = gb[i];
+    let res;
+    for (let j = 0; j < bindings.length; j++) {
+      let b = bindings[j];
+      let item = b.getItem();
+      // Empty property choices.
+      if (item instanceof Choice && typeof item.getProperty() === 'undefined' && pred === item.getId() && _path.length === 2 && _path[1] === b.getValue()) {
+        return b;
+      }
+      if (!b.isValid()) {
+        // eslint-disable-next-line no-continue
+        continue;
+      }
+      if (item.getType() === 'propertygroup') {
+        b = b.getObjectBinding();
+        item = b.getItem();
+      } else if (typeof item.getProperty() === 'undefined') {
+        res = matchPathBelowBinding(b, _path);
+        if (res) {
+          return res;
+        }
+      }
+      if (pred === '*' || pred === b.getPredicate() || pred === item.getId()) {
+        if (item.getType() === 'group') {
+          res = matchPathBelowBinding(b, _path.slice(1));
+          if (res) {
+            return res;
+          }
+        } else if (_path.length === 1 || _path[1] === '*' || _path[1] === b.getValue()) {
+          return b;
+        }
+      }
+    }
+  }
+  return undefined;
+};
+const findBindingRelativeToParentBinding = (parentBinding, path) => {
+  const first = path[0];
+  let b = parentBinding;
+  if (first === '/') {
+    while (b.getParent()) {
+      b = b.getParent();
+    }
+    return b;
+  } else if (first === '..') {
+    for (let i = 0; i < path.length; i++) {
+      if (path[i] === '..' && b.getParent()) {
+        b = b.getParent();
+      } else {
+        return b;
+      }
+    }
+    return b;
+  }
+  return parentBinding;
+};
+const findPopularChoice = (choiceItem, rootBinding) => {
+  const id = choiceItem.getId();
+  const values = {};
+  const val2choice = {};
+  choiceItem.getChoices().forEach(choice => {
+    values[choice.value] = 0;
+    val2choice[choice.value] = choice;
+  });
+  const recurse = groupB => {
+    groupB.getChildBindings().forEach(cb => {
+      const deps = cb.getItem().getDeps();
+      if (deps && (deps[0] === id || deps[0] === '/' && deps[1] === id)) {
+        const val = deps[0] === '/' ? deps[2] : deps[1];
+        const counter = values[val];
+        if (typeof counter !== 'undefined') {
+          values[val] = counter + 1;
+        }
+      }
+    });
+  };
+  recurse(rootBinding);
+  let popularCount = 0;
+  let value;
+  Object.keys(values).forEach(val => {
+    if (!value || values[val] > popularCount) {
+      value = val;
+      popularCount = values[val];
+    }
+  });
+  return val2choice[value];
+};
+const _levelProfile = (profile, item, ignoreTopLevelGroup) => {
+  const card = item.getCardinality();
+  if (!ignoreTopLevelGroup || item.getType() !== 'group') {
+    if (card != null) {
+      if (card.min > 0) {
+        profile.mandatory += 1;
+      } else if (card.pref > 0) {
+        profile.recommended += 1;
+      } else {
+        profile.optional += 1;
+      }
+    } else {
+      profile.optional += 1;
+    }
+  }
+  if (item.getType() === 'group') {
+    item.getChildren().forEach(i => _levelProfile(profile, i));
+  }
+  return profile;
+};
+const levelProfile = item => {
+  const profile = _levelProfile({
+    mandatory: 0,
+    recommended: 0,
+    optional: 0
+  }, item, true);
+  profile.itemCount = profile.mandatory + profile.recommended + profile.optional;
+  return profile;
+};
+const detectLevel = profile => {
+  if (profile.mandatory > 0) {
+    if (profile.recommended === 0 && profile.optional === 0) {
+      return 'mandatory';
+    } else if (profile.optional === 0) {
+      return 'mixed_mandatory_recommended';
+    } else if (profile.recommended === 0) {
+      return 'mixed_mandatory_optional';
+    }
+  } else if (profile.recommended > 0) {
+    if (profile.optional === 0) {
+      return 'recommended';
+    }
+    return 'mixed_recommended_optional';
+  } else if (profile.recommended === 0 && profile.recommended > 0 && profile.optional === 0) {
+    return 'optional';
+  }
+  return 'mixed_all';
+};
+
+//= ==============================================
+// Public API for matching and creation engine
+//= ==============================================
+/**
+ * Matches a tree of statements with the uri as root
+ * according to the constraints of the given template.
+ * All the statements matched are found in the graph.
+ * All statements in the graph that could be matched into the tree
+ * are matched into the tree.
+ * The tree is represented as a binding tree.
+ *
+ * @param {rdfjson/Graph} graph
+ * @param {String} uri
+ * @param {rdforms/template/Item} template
+ * @return {rdforms/model/GroupBinding} which is the root of binding tree.
+ */
+
+
+
+
+
+/**
+ * Finds the choice in a choice item that are the most popular, i.e. the choice that most
+ * valid bindings hava a dependency to.
+ * @param {rdforms/template/Choice} choiceItem
+ * @param {rdforms/model/GroupBinding} rootBinding
+ */
+
+
+/**
+ * Constructs a template by finding an item per outgoing property for provided graph and
+ * resource starting point.
+ *
+ * @param {Object} graph
+ * @param {Object} uri
+ * @param {Object} itemStore
+ * @param {Array} requiredItems an array of required items specified by id or property that
+ * will be enforced independent of corresponding property exists in the graph or not.
+ * @return {rdforms/template/Item} the constructed template.
+ */
+
+
+/**
+ * Creates a new binding below the given parentBinding according to what the item specifies.
+ * New triples are created in the provided graph although not expressed if they have an
+ * empty predicate or object. The item must be a direct child of the item
+ * of the parentBinding.
+ *
+ * @param {rdforms/model/Binding} parentBinding
+ * @param {rdforms/template/Item} item
+ * @param {Object} parentItems is a hash of parent Items to use for loop detection.
+ */
+
+
+/**
+ * Finds the first value binding in a binding tree, depth first.
+ * If multiple value bindings are found with nodeType LANGUAGE_LITERAL
+ * on the same level, the binding with the most appropriate language is chosen.
+ * Most appropriate means checking for:
+ * 1) exact current language (e.g. en_US),
+ * 2) current language (e.g. matches en even if locale is en_US)
+ * 3) default language (currently set to en)
+ * 4) any literal with a language set found
+ * 5) the first literal found
+ *
+ * @return {rdforms/model/ValueBinding}
+ */
+
+
+/**
+ * Calculates the level profile, i.e. the amount of items on mandatory, recommended
+ * and optional level in a given template.
+ *
+ * @param {rdforms/template/Item} item
+ * @return {Object} with keys mandatory, recommended and optional, each pointing to an integer.
+ */
+
+
+/**
+ * Investigates a level profile and provides the following responses:
+ * * mandatory   - only mandatory items
+ * * recommended - only recommended items
+ * * optional    - only optional items
+ * * mixed_all   - a mix of all items
+ * * mixed_mandatory_recommended - only mandatory and recommended items
+ * * mixed_mandatory_optional    - only mandatory and optional items
+ * * mixed_recommended_optional  - only recommended and optional items
+ * @param {object} profile as provided by the levelProfile function.
+ * @return {string} one of the responses outlined
+ */
+
+
+/* harmony default export */ const engine = ({
+  // TODO @valentino anti-pattern. This is done because engine is used in EntryScape. It shouldn't really...
+  detectLevel,
+  levelProfile,
+  findFirstValueBinding,
+  create,
+  constructTemplate,
+  findPopularChoice,
+  match,
+  fuzzyMatch,
+  matchPathBelowBinding,
+  findBindingRelativeToParentBinding,
+  CODES: model_CODES
+});
+;// ./src/template/ItemStore.js
+
+
+
+
+
+
+
+
+const deepMerge = (source1, source2) => {
+  if (!source1 || !source2) {
+    return source2 === undefined ? source1 : source2;
+  }
+  if (Array.isArray(source1) && Array.isArray(source2)) {
+    return [].concat(origSource[key], extSource[key]);
+  }
+  if (typeof source1 === 'object' && typeof source2 === 'object') {
+    const obj = {};
+    Object.keys(source1).concat(Object.keys(source2)).forEach(key => {
+      obj[key] = deepMerge(source1[key], source2[key]);
+    });
+    return obj;
+  }
+  return source2;
+};
+class ItemStore {
+  /**
+   * Keeps a registry of templates and reusable items.
+   * Use the createTemplate method to create templates from a source
+   * json structure, if the structure contains reusable items they are
+   * created and stored separately as well.
+   */
+  constructor(ontologyStore) {
+    this.automaticSortAllowed = true;
+    /**
+     * Value may be console methods or 'throw'.
+     * @type {string}
+     */
+    this.handleErrorAs = 'throw';
+
+    //= =================================================;
+    // Private Attribute;
+    //= =================================================;
+    this._bundles = [];
+    this._registry = {};
+    this._registryByProperty = {};
+    this._ontologyStore = ontologyStore || new OntologyStore();
+  }
+
+  //= ==================================================
+  // Public API
+  //= ==================================================
+  getTemplate(id) {
+    return this.getItem(id);
+  }
+  getChildren(group, original) {
+    if (group == null) {
+      return [];
+    }
+    const origSource = group.getSource(true);
+    const origSourceContent = origSource.content || origSource.items || [];
+    if (original) {
+      return this._createItems(origSourceContent, group._forceChildrenClones, group.getBundle());
+    }
+    const ext = this.getItem(origSource.extends);
+    if (ext) {
+      const children = group.getChildren(true);
+      if (group.getEnhanced('items') || children.length === 0) {
+        return ext.getChildren().concat(children);
+      }
+      return children;
+    }
+    return group.getChildren(true);
+  }
+  getItem(id) {
+    if (id != null) {
+      return this._registry[id];
+    }
+    return undefined;
+  }
+  getItems() {
+    return Object.keys(this._registry).map(key => this._registry[key]);
+  }
+  renameItem(from, to) {
+    if (this._registry[to]) {
+      this._handleError(`Cannot rename to ${to} since an item with that id already exists.`);
+      return;
+    }
+    if (to === '' || to === null) {
+      this._handleError('Cannot give an item an empty string or null as id.');
+      return;
+    }
+    const item = this._registry[from];
+    if (item) {
+      delete this._registry[from];
+      this._registry[to] = item;
+      item.setId(to);
+    }
+    const renameInGroup = source => {
+      const children = source.content;
+      if (children) {
+        for (let j = 0; j < children.length; j++) {
+          const child = children[j];
+          if (child.id === from || child['@id'] === from) {
+            child.id = to;
+            delete child['@id']; // Clean up backward compatability.
+          }
+          if (child.content) {
+            renameInGroup(child);
+          }
+        }
+      }
+    };
+    const items = this.getItems();
+    for (let i = 0; i < items.length; i++) {
+      const childItem = items[i];
+      if (childItem instanceof Group) {
+        renameInGroup(childItem._source);
+      }
+    }
+  }
+  getItemIds() {
+    return Object.keys(this._registry);
+  }
+  getItemByProperty(property) {
+    return this._registryByProperty[property];
+  }
+  detectTemplate(graph, uri, requiredItems) {
+    return constructTemplate(graph, uri, this, requiredItems);
+  }
+
+  /**
+   * Bundle is an object containing:
+   * path - can be a relative or absolute path to where the templates are/will be loaded from, optional.
+   * source - a RDForms template object, mandatory.
+   *
+   * @param {Object} bundleSrc
+   * @return {Bundle} the created bundle.
+   */
+  registerBundle(bundle) {
+    bundle.itemStore = this;
+    const b = new Bundle(bundle);
+    this._bundles.push(b);
+    if (bundle.source && bundle.source.namespaces) {
+      rdfjson_namespaceObject.namespaces.add(bundle.source.namespaces);
+    }
+    const templates = bundle.source.templates || bundle.source.auxilliary;
+    if (templates instanceof Array) {
+      this._createItems(templates, false, b);
+    }
+    if (typeof bundle.source.cachedChoices === 'object') {
+      this._ontologyStore.importRegistry(bundle.source.cachedChoices);
+    }
+    return b;
+  }
+  getBundles() {
+    return this._bundles;
+  }
+
+  // Backward compatability
+  createTemplate(source) {
+    const b = this.registerBundle({
+      source
+    });
+    return b.getRoot();
+  }
+  createTemplateFromChildren(children) {
+    const childrenObj = (children || []).map(child => typeof child === 'string' ? this.getItem(child) : child);
+    return new Group({
+      source: {},
+      children: childrenObj,
+      itemStore: this
+    });
+  }
+  setPriorities(priorities) {
+    this.priorities = priorities;
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  createExtendedSource(origSource, extSource) {
+    const newSource = Object.assign({}, origSource, extSource);
+    if (extSource.id === undefined) {
+      // If no new id is provided in the original source,
+      // don't inherit the id of the extention as then
+      // it will be overwrite it in the ItemStore
+      delete newSource.id;
+    }
+    if (extSource.enhanced) {
+      let keys;
+      if (extSource.enhanced === true) {
+        keys = Object.keys(origSource).concat(Object.keys(extSource));
+      } else {
+        keys = Object.keys(extSource.enhanced);
+      }
+      keys.forEach(key => {
+        newSource[key] = deepMerge(origSource[key], extSource[key]);
+      });
+    }
+    newSource._extendedSource = extSource;
+    newSource.extends = null; // Avoid infinite recursion when creating the fleshed out item.
+    delete newSource.children;
+    return newSource;
+  }
+
+  /**
+   * At a minimum the source must contain a type, the rest can be changed later.
+   *
+   * @param source
+   * @returns {*}
+   */
+  createItem(source, forceClone, skipRegistration, bundle) {
+    let item;
+    const id = source.id || source['@id'];
+    const type = source.type || source['@type'];
+    if (source.extends) {
+      // Explicit extends given
+      const extItem = this._registry[source.extends];
+      if (extItem == null) {
+        this._handleError(`Cannot find item to extend with id: ${source.extends}`);
+      }
+      if (extItem) {
+        const newSource = this.createExtendedSource(extItem.getSource(), source);
+        return this.createItem(newSource, false, false, bundle);
+      }
+    }
+    if (type != null) {
+      // If there is a type in the source then it means that the object is a new item.
+      // eslint-disable-next-line default-case
+      switch (type) {
+        case 'text':
+          item = new Text({
+            source,
+            itemStore: this,
+            bundle
+          });
+          break;
+        case 'choice':
+          item = new Choice({
+            source,
+            itemStore: this,
+            ontologyStore: this._ontologyStore,
+            bundle
+          });
+          break;
+        case 'group':
+          item = new Group({
+            source,
+            children: null,
+            itemStore: this,
+            bundle
+          }); // Lazy loading of children.
+          break;
+        case 'propertygroup':
+          item = new PropertyGroup({
+            source,
+            children: null,
+            itemStore: this,
+            bundle
+          }); // Lazy loading of children.
+          break;
+      }
+      if (skipRegistration !== true) {
+        if (source.property != null) {
+          this._registryByProperty[source.property] = item;
+          if (this.priorities && this.priorities[source.property] != null) {
+            item.priority = this.priorities[source.property];
+          }
+        }
+        if (id != null) {
+          if (this._registry[id]) {
+            console.log(`RDForms conflict with item id ${id}, overwriting item from bundle "${this._registry[id].getBundle()?.getPath() || ''}" with item from bundle "${item.getBundle()?.getPath() || ''}".`);
+          }
+          this._registry[id] = item;
+          if (bundle != null) {
+            bundle.addItem(item);
+          }
+        }
+      }
+      return item;
+    }
+    // No type means it is a reference, check that the referred item (via id) exists
+    if (id == null) {
+      this._handleError('Cannot create subitem, `type` for creating new or `id` for referencing external are required.');
+      return;
+    }
+    if (this._registry[id] == null) {
+      this._handleError(`Cannot find referenced subitem using identifier: ${id}`);
+      return;
+    }
+
+    // Clone if forceClone set to true or if the source contains non-id properties.
+    if (forceClone === true || Object.keys(source).find(key => key !== 'id' && key !== '@id')) {
+      const newSource = Object.assign(Object.assign({}, this._registry[id]._source), source);
+      return this.createItem(newSource, false, true);
+    }
+    return this._registry[id];
+  }
+  removeItem(item, removereferences) {
+    const b = item.getBundle();
+    if (b != null) {
+      b.removeItem(item);
+    }
+    if (item.getId() != null) {
+      delete this._registry[item.getId()];
+    }
+    const prop = item.getProperty();
+    if (prop != null && this._registryByProperty[prop] === item) {
+      delete this._registryByProperty[prop];
+    }
+    if (removereferences) {
+      // TODO
+    }
+  }
+
+  //= ==================================================
+  // Private methods
+  //= ==================================================
+  _createItems(sourceArray, forceClone, bundle) {
+    return sourceArray.map((child, index) => {
+      // If child is not a object but a direct string reference,
+      const childToUse = typeof child === 'string' ? sourceArray[index] = {
+        id: child
+      } : child;
+      return this.createItem(childToUse, forceClone, false, bundle);
+    }).filter(item => item);
+  }
+  _handleError(message) {
+    if (this.handleErrorAs === 'throw') {
+      throw new Error(message);
+    }
+    console[this.handleErrorAs](message);
+  }
+}
+;// ./src/template/bundleLoader.js
+/* eslint-disable no-await-in-loop */
+/**
+ * Check if there's any iterations left in a hypothetical array with 'length' given.
+ *
+ * @param {number} iteration
+ * @param {number} length
+ * @param {string} templateId
+ * @throws
+ */
+const stopFetchingOrJustLog = (iteration, length, templateId) => {
+  const message = `Fetching template bundle ${templateId} failed.`;
+  if (iteration === length - 1) {
+    throw Error(`${message} Cannot recover from this, please fix.`);
+  } else {
+    console.log(`${message} Will try to fetch from a fallback option.`);
+  }
+};
+
+/**
+ * Return the first successfully fetched bundle from a list of urls or throw en error if none could be fetched
+ *
+ * @param {Array<String>} urls
+ * @returns {Promise<Response | never | void>}
+ */
+const fetchBundle = async urls => {
+  const totalUrls = urls.length;
+  let response;
+  let bundle;
+  let path;
+  for (let i = 0; i < totalUrls; i++) {
+    // try to fetch the bundle, fails only if there's some network error. A 404 is not an error
+    path = urls[i];
+    try {
+      response = await fetch(path);
+    } catch (e) {
+      throw Error(`A network error ocurred while trying to fetch bundle ${path}`);
+    }
+
+    // check if we got a 2xx
+    if (response && response.ok) {
+      // check if what we got back looks like json and try to parse
+      // if all good, then you're done
+      // if it cannot parse, then fail soft or hard depending on if there's a fallback left to check
+      try {
+        const contentType = response.headers.has('content-type') && response.headers.get('content-type');
+        if (contentType && contentType.includes('application/json')) {
+          bundle = await response.json();
+          break;
+        } else {
+          throw new Error(`Failed fetching template ${path}. Expected a JSON file and got ${contentType}`);
+        }
+      } catch (e) {
+        stopFetchingOrJustLog(i, totalUrls, path);
+      }
+      // got back something that's not a 2xx
+    } else {
+      stopFetchingOrJustLog(i, totalUrls, path);
+    }
+  }
+  return {
+    path,
+    source: bundle
+  };
+};
+
+/**
+ * Fetch or if loaded just wrap it in Promise.resolve
+ * @param bundles
+ * @returns {Promise<*>}
+ */
+const promisifyBundles = bundles => bundles.map(bundle => bundle instanceof Array ? fetchBundle(bundle) : Promise.resolve({
+  source: bundle
+}));
+
+/**
+ * Register bundle templates
+ *
+ * @param {ItemStore} itemStore
+ * @param {array} bundles
+ */
+const registerBundles = (itemStore, bundles = []) => bundles.map(bundle => itemStore.registerBundle(bundle));
+
+/**
+ *
+ * @param {ItemStore} itemStore
+ * @param bundlePaths {Array<Object|String>} an array of object (bundles) or paths
+ * @param callback
+ */
+/* harmony default export */ const bundleLoader = (async (itemStore, bundlePaths = [], callback = () => {}) => {
+  if (bundlePaths.length === 0 && callback) {
+    // nothing to load
+    callback([]);
+  }
+
+  // Fetch or if loaded just wrap it in Promise.resolve
+  const bundlePromises = promisifyBundles(bundlePaths);
+  const loadedBundles = await Promise.all(bundlePromises);
+  const registeredBundles = registerBundles(itemStore, loadedBundles);
+  callback(registeredBundles); // TODO remove; should be deprecated
+  return registeredBundles;
+});
+;// ./src/model/validate.js
+
+
+
+const _clearMatchingCodes = binding => {
+  binding.setMatchingCode(CODES.OK);
+  if (binding.getItem().getType() === 'group') {
+    binding.getChildBindings().forEach(childBinding => _clearMatchingCodes(childBinding));
+  }
+};
+
+/**
+ * Generates a report for the given binding. Below is an example of a report:
+ * {
+ *   errors: [{
+ *      parentBinding: parent_group_binding_instance
+ *      item: item_instance_where_error_is,
+ *      code: "many"
+ *   }, ...],
+ *   warnings: [{
+ *      parentBinding: parent_group_binding_instance
+ *      item: item_instance_where_warning_is,
+ *      code: "few"
+ *   }, ...],
+ *   deprecated: [binding_instance_of_deprecated_value, ...]
+ * }
+ *
+ * @type {Object}
+ */
+const bindingReport = (groupbinding, reportObj) => {
+  let _reportObj = reportObj;
+  if (_reportObj == null) {
+    _reportObj = {
+      errors: [],
+      warnings: [],
+      deprecated: []
+    };
+  } else {
+    _reportObj.errors = _reportObj.errors || [];
+    _reportObj.warnings = _reportObj.warnings || [];
+    _reportObj.deprecated = _reportObj.deprecated || [];
+  }
+  //  _clearMatchingCodes(groupbinding);
+  // eslint-disable-next-line no-use-before-define
+  return _createReport(groupbinding, _reportObj, true);
+};
+const _countValidBindings = bindings => {
+  let counter = 0;
+  for (let i = 0; i < bindings.length; i++) {
+    if (bindings[i].isValid()) {
+      counter += 1;
+    }
+  }
+  return counter;
+};
+const updateViaCardinalityTracker = (bindings, code) => {
+  if (bindings.length > 0) {
+    const cardTr = bindings[0].getCardinalityTracker();
+    cardTr.setCode(code);
+  }
+};
+const doNotProceedFurther = (groupBinding, childItem) => {
+  // Don't check further if the childItem is deprecated
+  if (childItem.hasStyle('deprecated')) {
+    return true;
+  }
+
+  // Don't check further if the binding is hidden due to missing dependencies
+  const childPath = childItem.getDeps();
+  if (childPath) {
+    const fromBinding = findBindingRelativeToParentBinding(groupBinding, childPath);
+    if (!matchPathBelowBinding(fromBinding, childPath)) {
+      return true;
+    }
+  }
+  return false;
+};
+const _createReport = (groupbinding, report, firstLevel) => {
+  if (groupbinding.getMatchingCode() !== model_CODES.OK) {
+    return undefined;
+  }
+  const groupitem = groupbinding.getItem();
+
+  // Abort check if the groupbinding is hidden due to a missing dependency.
+  // Check disabled since it is done for each child before recursive call
+  /* const path = groupitem.getDeps();
+   if (path && groupbinding.getParent() != null) {
+     const fromBinding = findBindingRelativeToParentBinding(groupbinding.getParent(), path);
+     if (!matchPathBelowBinding(fromBinding, path)) {
+       return undefined;
+     }
+   } */
+
+  if (firstLevel === true || groupbinding.isValid() || groupitem.getProperty() == null || groupitem.hasStyle('atLeastOneChild') || groupitem.hasStyle('exactlyOneChild')) {
+    const childrenItems = groupitem.getChildren();
+
+    // disjoint is deprecated in favour of atMostOneChild
+    if (groupitem.hasStyle('disjoint') || groupitem.hasStyle('atMostOneChild') || groupitem.hasStyle('atLeastOneChild') || groupitem.hasStyle('exactlyOneChild')) {
+      const bindings = groupbinding.getChildBindings();
+      const nrOfValid = _countValidBindings(bindings);
+      let code;
+      if (nrOfValid > 1 && (groupitem.hasStyle('disjoint') || groupitem.hasStyle('atMostOneChild'))) {
+        code = model_CODES.AT_MOST_ONE_CHILD;
+      } else if (nrOfValid !== 1 && groupitem.hasStyle('exactlyOneChild')) {
+        code = model_CODES.EXACTLY_ONE_CHILD;
+      } else if (nrOfValid === 0 && groupitem.hasStyle('atLeastOneChild')) {
+        code = model_CODES.AT_LEAST_ONE_CHILD;
+      }
+      if (code) {
+        updateViaCardinalityTracker([groupbinding], code);
+        //        groupbinding.setMatchingCode(code);
+        // Correct to set only on first child?
+        if (childrenItems.length > 0) {
+          report.errors.push({
+            parentBinding: groupbinding,
+            item: childrenItems[0],
+            code
+          });
+        }
+      }
+    } else {
+      groupbinding.getItemGroupedChildBindings().forEach((bindings, index) => {
+        const childItem = childrenItems[index];
+        if (doNotProceedFurther(groupbinding, childItem)) {
+          return;
+        }
+        if (childItem.getProperty() != null) {
+          const nrOfValid = _countValidBindings(bindings);
+          const card = childItem.getCardinality();
+          if (card.min != null && card.min > nrOfValid) {
+            report.errors.push({
+              parentBinding: groupbinding,
+              item: childItem,
+              code: model_CODES.TOO_FEW_VALUES_MIN
+            });
+            updateViaCardinalityTracker(bindings, model_CODES.TOO_FEW_VALUES_MIN);
+            /*            let counter = 0;
+                        bindings.forEach((binding) => {
+                          if (!binding.isValid()) {
+                            if (counter < card.min) {
+                              counter += 1;
+                              binding.setMatchingCode(CODES.TOO_FEW_VALUES_MIN);
+                            }
+                          }
+                        }); */
+          } else if (card.pref != null && card.pref > nrOfValid) {
+            report.warnings.push({
+              parentBinding: groupbinding,
+              item: childItem,
+              code: model_CODES.TOO_FEW_VALUES_PREF
+            });
+            //            updateViaCardinalityTracker(bindings, CODES.TOO_FEW_VALUES_PREF);
+          }
+          if (card.max != null && card.max < nrOfValid) {
+            report.errors.push({
+              parentBinding: groupbinding,
+              item: childItem,
+              code: model_CODES.TOO_MANY_VALUES
+            });
+            updateViaCardinalityTracker(bindings, model_CODES.TOO_MANY_VALUES);
+            /*            let counter = 0;
+                        bindings.forEach((binding) => {
+                          if (binding.isValid()) {
+                            counter += 1;
+                            if (counter > card.max) {
+                              binding.setMatchingCode(CODES.TOO_MANY_VALUES);
+                            }
+                          }
+                        }); */
+          }
+        }
+      }, undefined);
+    }
+    groupbinding.getChildBindings().forEach(binding => {
+      const item = binding.getItem();
+      if (binding.getMatchingCode() !== model_CODES.OK) {
+        report.errors.push({
+          parentBinding: binding,
+          item,
+          code: binding.getMatchingCode()
+        });
+      }
+      if (item.hasStyle('deprecated')) {
+        report.deprecated.push(binding);
+      }
+      if (!doNotProceedFurther(groupbinding, item)) {
+        // Recursive step
+        if (item.getType() === 'group') {
+          _createReport(binding, report);
+        }
+      }
+    });
+  }
+  return report;
+};
+
+/**
+ * Generates a report for all resources identified. Resources are identified
+ * according to their type. If a resource is present in the graph but its type is not
+ * in the type2template map it will not be in the report.
+ * Each resource will be validated according to the template for its type.
+ * Below is an example of a report:
+ * {
+ *    errors: 5,
+ *    warnings: 10,
+ *    deprecated: 1,
+ *    mandatoryError: ["dcat:Dataset"]
+ *    resources: [
+ *       {
+ *         uri: "http://example.com",
+ *         type: "vcard:Kind",
+ *         template: "vc:Kind",
+ *         errors: [{
+ *           path: "vcard:hasAddress > vcard:hasStreetAddress",
+ *           code: "few"
+ *         }],
+ *         warnings: [{
+ *           path: "vcard:hasFN",
+ *           code: "few"
+ *         }],
+ *         deprecated: [https://challengesgov.se/challenge-sthlm/
+ *           "vcard:fn"
+ *         ]
+ *       },
+ *       ...
+ *    ]
+ * }
+ *
+ * @param {rdfjson/Graph} graph an rdf graph against which all validation is done
+ * @param {Object} type2template a map between each type to check for and the template to use for validation
+ * (the type may be given with namespace abbreviations)
+ * @param {Array} mandatoryTypes an array of types to check that there are instances for
+ * @return {Object} a report of the validity of the graph
+ */
+const graphReport = (graph, type2template, mandatoryTypes = []) => {
+  const type2resources = {};
+  const allResources = {};
+  let template;
+  let rr;
+  const report = {
+    errors: 0,
+    warnings: 0,
+    deprecated: 0,
+    resources: []
+  };
+  Object.keys(type2template).forEach(type => {
+    // eslint-disable-next-line no-use-before-define
+    const resources = _findResources(graph, type);
+    type2resources[type] = resources;
+    resources.forEach(resource => {
+      allResources[resource] = true;
+    });
+  });
+  Object.keys(type2resources).forEach(type => {
+    template = type2template[type];
+    type2resources[type].forEach(resource => {
+      // eslint-disable-next-line no-use-before-define
+      rr = _resourceReport(resource, graph, template, allResources);
+      rr.uri = resource;
+      rr.type = type;
+      rr.template = template.getId();
+      report.resources.push(rr);
+      report.errors += rr.errors.length;
+      report.warnings += rr.warnings.length;
+      report.deprecated += rr.deprecated.length;
+    });
+  });
+  const mandatoryError = [];
+  mandatoryTypes.forEach(mt => {
+    if (type2resources[mt].length === 0) {
+      mandatoryError.push(mt);
+    }
+  });
+  if (mandatoryError.length > 0) {
+    report.mandatoryError = mandatoryError;
+    report.errors += mandatoryError.length;
+  }
+  return report;
+};
+const _findResources = (graph, cls) => graph.find(null, 'rdf:type', cls).map(stmt => stmt.getSubject());
+const _includeIssue = (binding, resource, otherResources) => {
+  let pb = binding;
+  while (true) {
+    const uri = pb.getChildrenRootUri ? pb.getChildrenRootUri() : pb.getParent().getChildrenRootUri();
+    if (uri === resource) {
+      return true;
+    } else if (otherResources[uri]) {
+      return false;
+    }
+    pb = pb.getParent();
+  }
+};
+const _createPath = (binding, item) => {
+  let _binding = binding;
+  const path = [];
+  if (item.getProperty() != null && _binding.getItem() !== item) {
+    path.push(rdfjson_namespaceObject.namespaces.shorten(item.getProperty()));
+  }
+  while (true) {
+    if (_binding.getItem().getProperty() != null) {
+      path.push(rdfjson_namespaceObject.namespaces.shorten(_binding.getItem().getProperty()));
+    }
+    if (_binding.getParent() == null) {
+      break;
+    } else {
+      _binding = _binding.getParent();
+    }
+  }
+  path.reverse();
+  return path.join(' > ');
+};
+const _filterReport = (report, resource, otherResources) => {
+  const {
+    errors,
+    warnings,
+    deprecated
+  } = report;
+  report.errors = errors.filter(err => _includeIssue(err.parentBinding, resource, otherResources));
+  report.warnings = warnings.filter(warn => _includeIssue(warn.parentBinding, resource, otherResources));
+  report.deprecated = deprecated.filter(depr => _includeIssue(depr, resource, otherResources));
+};
+const _createDepPath = dep => `${_createPath(dep.getParent(), dep.getItem())} > ${dep.getValue()}`;
+const _simplifyReport = report => {
+  const {
+    errors,
+    warnings,
+    deprecated
+  } = report;
+  report.errors = errors.map(err => ({
+    path: _createPath(err.parentBinding, err.item),
+    code: err.code
+  }));
+  report.warnings = warnings.map(warn => ({
+    path: _createPath(warn.parentBinding, warn.item),
+    code: warn.code
+  }));
+  report.deprecated = deprecated.map(dep => _createDepPath(dep));
+};
+const _resourceReport = (resource, graph, template, ignoreResources) => {
+  const binding = fuzzyMatch(graph, resource, template);
+  const report = bindingReport(binding);
+  _filterReport(report, resource, ignoreResources || {});
+  _simplifyReport(report);
+  return report;
+};
+
+/* harmony default export */ const validate = ({
+  // TODO @valentino don't export default. Used in EntryScape
+  graphReport,
+  bindingReport
+});
+;// ./main.node.js
+// import 'node-fetch';
+
+global.fetch = (__webpack_require__(229)["default"]);
+
+
+
+
+
+
+module.exports = __webpack_exports__;
+/******/ })()
+;