{"version":3,"sources":["webpack:///./src/main/web/api/module-loader/ComponentsLoader.ts","webpack:///./src/main/web/api/module-loader/ExtensionPoint.ts","webpack:///./src/main/web/api/components/PlatformComponent.ts","webpack:///./src/main/web/api/events/BuiltInEvents.ts","webpack:///./src/main/web/api/events/EventsStore.ts","webpack:///./src/main/web/api/navigation/components/NavigationConfirmationDialog.tsx","webpack:///./src/main/web/api/services/ldp-set/ldp-set.ts","webpack:///./src/main/web/api/navigation/components/NavigateToIri.tsx","webpack:///./src/main/web/api/services/ldp.ts","webpack:///./src/main/web/api/module-loader/index.ts","webpack:///./src/main/web/api/services/security.ts","webpack:///./src/main/web/api/services/file-manager.ts","webpack:///./src/main/web/api/services/ldp-set/index.ts","webpack:///./src/main/web/api/services/ldp-query.ts","webpack:///./src/main/web/api/services/repository.ts","webpack:///./src/main/web/api/rdf/formats/JsonLd.ts","webpack:///./src/main/web/api/services/resource-thumbnail.ts","webpack:///./src/main/web/api/services/ldp-field.ts","webpack:///./src/main/web/api/services/rdf-graph-store.ts","webpack:///./src/main/web/api/services/file-upload.ts","webpack:///./src/main/web/api/services/cache.ts","webpack:///./src/main/web/api/services/ldp-query-template.ts","webpack:///./src/main/web/api/services/WorkflowService.ts","webpack:///./src/main/web/api/services/resource-label.ts","webpack:///./src/main/web/api/services/config-holder.ts","webpack:///./src/main/web/api/services/template/index.ts","webpack:///./src/main/web/api/services/url-minifier.ts","webpack:///./src/main/web/api/services/generic-rest.ts","webpack:///./src/main/web/api/events/index.ts","webpack:///./src/main/web/api/json/JsonCore.ts","webpack:///./src/main/web/api/sparql/TypeGuards.ts","webpack:///./src/main/web/api/rdf/vocabularies/index.ts","webpack:///./src/main/web/api/rdf/vocabularies/vocabularies.ts","webpack:///./src/main/web/api/navigation/components/ResourceLinkComponent.ts","webpack:///./src/main/web/api/services/namespace.ts","webpack:///./src/main/web/api/sparql/SparqlUtil.ts","webpack:///./src/main/web/api/json/index.ts","webpack:///./src/main/web/api/navigation/components/ResourceLink.ts","webpack:///./src/main/web/api/rdf/index.ts","webpack:///./src/main/web/api/rdf/formats/turtle.ts","webpack:///./src/main/web/api/sparql/QueryVisitor.ts","webpack:///./src/main/web/api/services/template/TemplateCache.ts","webpack:///./src/main/web/api/module-loader/ComponentsStore.ts","webpack:///./src/main/web/api/rdf/core/Rdf.ts","webpack:///./src/main/web/api/components/SemanticContext.ts","webpack:///./src/main/web/api/navigation/NavigationUtils.ts","webpack:///./src/main/web/api/navigation/Navigation.ts","webpack:///./src/main/web/api/navigation/components/ResourceLinkContainer.ts","webpack:///./src/main/web/api/services/language.ts","webpack:///./src/main/web/api/services/page.ts","webpack:///./src/main/web/api/sparql/SparqlClient.ts","webpack:///./src/main/web/api/async/index.ts","webpack:///./src/main/web/api/rdf/vocabularies/xsd.ts","webpack:///./src/main/web/api/persistence/index.ts","webpack:///./src/main/web/api/http/index.ts","webpack:///./src/main/web/api/json/3rd-party/immutable.ts","webpack:///./src/main/web/api/rdf/vocabularies/rdf.ts","webpack:///./src/main/web/api/navigation/CurrentResource.ts","webpack:///./src/main/web/api/sparql/QueryBinder.ts","webpack:///./src/main/web/api/services/template/RemoteTemplateFetcher.ts","webpack:///./src/main/web/api/services/template/TemplateParser.ts","webpack:///./src/main/web/api/persistence/BrowserPersistence.ts","webpack:///./src/main/web/api/services/template/functions/index.ts","webpack:///./src/main/web/api/services/template/functions/DataContextFunctions.ts","webpack:///./src/main/web/api/module-loader/ReactErrorCatcher.ts","webpack:///./src/main/web/api/components/index.ts","webpack:///./src/main/web/api/components/TemplateContext.ts","webpack:///./src/main/web/api/events/Utils.ts","webpack:///./src/main/web/api/services/BaseResourceService.ts","webpack:///./src/main/web/api/navigation/components/Link.ts","webpack:///./src/main/web/api/sparql/index.ts","webpack:///./src/main/web/api/navigation/index.ts","webpack:///./src/main/web/api/navigation/components/index.ts","webpack:///./src/main/web/api/async/Cancellation.ts","webpack:///./src/main/web/api/services/ldp-set/SetManagementEvents.ts","webpack:///./src/main/web/api/services/config.ts","webpack:///./src/main/web/api/persistence/ComponentPersistence.ts","webpack:///./src/main/web/api/navigation/PersistentHistory.ts","webpack:///./src/main/web/api/module-loader/Registry.ts","webpack:///./src/main/web/api/json/3rd-party/data.maybe.ts","webpack:///./src/main/web/api/json/3rd-party/moment.ts","webpack:///./src/main/web/api/rdf/vocabularies/rdfs.ts","webpack:///./src/main/web/api/rdf/vocabularies/dc.ts","webpack:///./src/main/web/api/rdf/vocabularies/dct.ts","webpack:///./src/main/web/api/rdf/vocabularies/sp.ts","webpack:///./src/main/web/api/rdf/vocabularies/spl.ts","webpack:///./src/main/web/api/rdf/vocabularies/spin.ts","webpack:///./src/main/web/api/rdf/vocabularies/ldp.ts","webpack:///./src/main/web/api/rdf/vocabularies/oa.ts","webpack:///./src/main/web/api/rdf/vocabularies/field.ts","webpack:///./src/main/web/api/rdf/vocabularies/prov.ts","webpack:///./src/main/web/api/rdf/vocabularies/persist.ts","webpack:///./src/main/web/api/rdf/vocabularies/platform.ts","webpack:///./src/main/web/api/rdf/vocabularies/workflow.ts","webpack:///./src/main/web/api/rdf/formats/JsObjectGraph.ts","webpack:///./src/main/web/api/rdf/core/XsdDatatypeValidation.ts","webpack:///./src/main/web/api/async/WrappingError.ts","webpack:///./src/main/web/api/async/BatchedPool.ts","webpack:///./src/main/web/api/services/template/functions/GenericFunctions.ts","webpack:///./src/main/web/api/services/template/functions/DateTimeFunctions.ts","webpack:///./src/main/web/api/services/template/functions/RdfFunctions.ts","webpack:///./src/main/web/api/services/template/functions/UriComponentFunctions.ts","webpack:///./src/main/web/api/services/template/functions/NumbersFunctions.ts","webpack:///./src/main/web/api/services/template/TemplateScope.ts"],"names":["props","state","component","maybe","Nothing","componentDidMount","loadComponent","this","componentTagName","then","setState","Just","render","map","createElement","componentProps","children","getOrElse","Component","ComponentLoader","factory","createFactory","loaded","loader","Kefir","later","undefined","isLoading","get","Error","error","value","load","never","loadingExtension","flatMap","newValue","constant","mapErrors","console","loadAndUpdate","cancellation","updateWhenLoaded","forceUpdate","observe","chainLoader","previousValue","previousLoader","ExtensionPoint","ContextTypes","SemanticContextTypes","TemplateContextTypes","ComponentPropTypes","markupTemplateScope","PropTypes","object","context","cancel","Cancellation","templateScope","TemplateService","TemplateScope","default","componentWillUnmount","cancelAll","getChildContext","propTypes","childContextTypes","contextTypes","PlatformComponent","event","EventMaker","ComponentRefresh","ComponentLoading","ComponentLoaded","ComponentTemplateUpdate","EventSourceStore","_subscribers","listen","eventFilter","stream","emitter","key","uuid","v4","currentValue","getCurrentValue","emit","trigger","_","forEach","subscriber","eventType","source","target","includes","targets","updateCurrentValue","registerEventSource","eventSource","addEventSource","unregisterEventSource","deleteEventSource","sources","Immutable","Map","eventSourceKey","EventSourceKey","set","has","remove","_source","_eventType","equals","other","hashCode","hash","Rdf","hashString","smi","onHide","message","onConfirm","Modal","show","Header","Title","Body","Footer","ButtonGroup","Button","bsStyle","onClick","e","React","NavigationConfirmationDialog","rdf","rdfs","VocabPlatform","ldp","xsd","createSet","name","slug","generatedIri","iri","graph","triple","label","literal","type","Container","Set","addResource","addToExistingSet","setIri","itemIris","addSetItem","LdpService","createSetAndAddItems","listOfItemIris","setLocation","newSet","zip","index","toJS","toProperty","reorderItems","holders","holder","item","createItemHolderGraph","update","toArray","holderIri","itemIri","getLabel","triples","setItem","SetItem","push","setItemIndex","toString","integer","getUserSetRootContainerIri","username","Promise","resolve","reject","request","query","accept","end","err","res","text","getUserDefaultSetIri","SetService","addToDefaultSet","resource","sourceId","combine","getSetServiceForUser","fromPromise","service","defaultSetIri","SetManagementEvents","ItemAdded","UserSetContainer","getOrCreateSetContainer","setContainerIri","setService","flatMapErrors","getUser","user","createSetContainerForUser","containerName","principal","SetContainer","setContainerOfCurrentUser","container","ContainerOfUserSetContainers","onValueChange","trim","isExploreDisabled","isEmpty","preventDefault","navigateToResource","onValue","v","onError","Form","horizontal","onSubmit","FormGroup","validationState","InputGroup","FormControl","placeholder","onChange","disabled","buttonCaption","HelpBlock","defaultProps","NavigateToIRI","getContainerIRI","BASE_CONTAINER","turtle","serialize","serializeGraph","createResourceRequest","data","format","location","containerIri","req","post","getServiceUrl","uri","send","fromNodeCallback","cb","header","isDefault","repository","urlSuffix","queryParams","endpoint","urlQuery","URI","buildQuery","assign","setVisibility","visibilityEnum","groups","visibilityItem","visibility","group","visibleToGroups","VisibilityContainer","getContainer","fetchResource","resourceIri","sendUpdateResourceRequest","options","status","ok","deleteResource","del","renameResource","newName","put","abort","copyResource","targetContainer","resourceUrl","getResourceTriples","getResourceRequest","deserialize","turtleToGraph","bind","getExportURL","iris","getImportURL","importGetTextFromURL","url","importFromText","containerIRI","force","File","importFromDelayedId","delayedId","ldpc","baseUrl","slugFromName","toLowerCase","replace","ModuleRegistry","ReactErrorCatcher","ComponentsLoader","ComponentClassMetadata","Permissions","templateSave","queryEditorSelectEndpoint","sparqlQueryEditor","pageToolbarExplore","sparqlSelect","qaasInfo","toLdp","base","action","ownership","trueProto","prototype","__proto__","NotEnoughPermissionsError","pool","BatchedPool","fetch","perms","fetchPermitted","isUndefined","window","JSON","parse","isPermitted","permissionString","permissionStrings","body","batch","isAnonymous","userObject","getSessionInfo","touchSession","getAllAccounts","getDocumentationForAllPermissions","requestAsProperty","createAccount","account","response","updateAccount","deleteAccount","getRoleDefinitions","isPermissionValid","permission","updateRoleDefinitions","roles","SecurityUtil","Util","FILE_UPLOAD_SERVICE_URL","FILE_LDP_CONTAINER_ID","FILE_URL","ADMIN_URL","TEMPORARY_STORAGE_URL","MOVE_URL","RESOURCE_QUERY","fileName","mediaType","fileContext","TemporaryFileSchema","uploadFileAsResource","storage","constantError","attach","file","field","size","resourceQuery","generateIriQuery","contextUri","fileNameHack","on","onProgress","percent","uploadFileDirectlyToStorage","folder","uploadFileTemporary","encodeAsIri","createResourceFromTemporaryFile","temporaryStorage","deleteFileResource","getFileResource","removeTemporaryResource","getFileResourceGraph","isEncodedIri","namePredicateIri","mediaTypePredicateIri","find","tripple","p","o","getFileUrl","mode","addQuery","isTemporaryResource","FileManager","startsWith","encodedMediaType","encodeURIComponent","encodedName","decodeFromIri","encoded","substring","length","decodeURIComponent","sp","addItem","createGraph","updateItem","queryType","queryClass","Update","Query","getType","structure","vocabularies","searchState","Ask","Select","Describe","Construct","getQuery","parseGraphToQuery","queryTypes","qt","t","s","sTypeIRI","extractTypeFromIri","toUpperCase","exec","QueryServiceClass","QueryService","QueryContainer","repositories","ENDPOINT","validateDefault","fromRequest","valid","getRepositoryStatus","SparqlRepositoryType","NeptuneRepositoryType","Rdf4jRepositoryType","EphedraRepositoryType","getRepositoryConfig","id","deleteRepositoryConfig","delete","getRepositoryInfo","getRepositoryConfigTemplate","updateOrAddRepositoryConfig","validate","getRepositoryConfigTemplates","guessResourceRepository","rs","r","executeGuessQuery","SparqlClient","ask","setBindings","GUESS_QUERY","__value__","resp","responses","Maybe","fromNullable","repo","SparqlUtil","Sparql","getValue","composeErrorMessage","init","keySeq","isValid","isValidDefault","DefaultRepositoryInfo","DefaultRepositoryInfoClass","registerTtlParser","JsonLd","registerRDFParser","input","callback","quads","N3","Parser","quad","createJsonLdQuad","subject","getTerm","predicate","termType","isLiteral","getLiteralTerm","getLiteralValue","language","getLiteralLanguage","datatype","getLiteralType","isBlank","registerGraphParser","term","isBnode","isIri","NODE_DOCUMENT_LOADER","documentLoaders","node","makeDocumentLoader","overrideContexts","contextUrl","document","documentUrl","fetchRemoteContexts","compact","ctx","frame","fromRdf","dataset","fromRDF","BaseResourceService","getThumbnail","getResource","getThumbnails","getResources","getFieldDefinitionProp","fieldIri","FieldDefinitionContainer","predicates","description","comment","xsdDatatype","xsd_datatype","minOccurs","min_occurs","maxOccurs","max_occurs","order","selectPattern","select_pattern","deletePattern","delete_pattern","askPattern","ask_pattern","valueSetPattern","valueset_pattern","autosuggestionPattern","autosuggestion_pattern","testSubject","testsubject","insertPattern","insert_pattern","pg","partialField","mapValues","propertyPath","getValueFromPropertyPath","n","getValuesFromPropertyPath","domain","range","defaultValues","default_value","categories","category","treePatterns","tree_patterns","chain","config","SyntheticJsonDatatype","getFieldDefinition","normalizeFieldDefinition","getGeneratedFieldDefinitions","fields","getLabels","filter","f","labels","GRAPH_STORE_SERVICEURL","targetGraph","graphData","turtleString","createGraphRequest","updateGraph","updateGraphRequest","createGraphFromFile","keepSourceGraphs","contentType","updateGraphFromFile","getGraph","errorToString","deleteGraph","downloadGraph","acceptHeader","download","filename","blob","Blob","fileSaver","saveAs","RDFGraphStoreService","GraphStoreService","FILEUPLOAD_SERVICEURL","uploadFile","createResourceQuery","generateIdQuery","metadataExtractor","getMimeType","split","pop","FileUploadService","FileUpload","sendRequest","invalidateAllCaches","invalidateCacheForResource","POST_INVALIDATE_ALL","spl","spin","dct","CATEGORIES_PREDICATE","template","queryIri","namespace","identifier","args","argsTriples","arg","argIri","constraintProp","Argument","predicateProp","variable","valueTypeProp","valueType","defaultValue","optional","optionalProp","boolean","mergedArgsTriples","concat","apply","Template","templateType","bodyProp","getQueryTemplate","parseGraphToQueryTemplate","templateTypes","AskTemplate","SelectTemplate","ConstructTemplate","UpdateTemplate","extractValueFromIri","QueryTemplateServiceClass","QueryTemplateService","QueryTemplateContainer","WorkflowState","empty","step","assignee","isEqual","a","b","ldpService","WorkflowContainer","queryWorkflowInstantiation","workflow","queryWorkflowSteps","definition","currentStep","ldpAssetsService","definitionIri","g","steps","nextStep","hasStep","assigneeQuery","queryWorkflowAssignees","newStep","values","workflowInstantiations","prepareQuery","parsedQuery","select","assignees","results","bindings","binding","generateSubjectByTemplate","match","createWorkflowInstantiation","workflowData","firstStep","newWorkflowIriTemplate","workflowStateIri","hasState","metadata","timeLiteral","moment","toISOString","dateTime","WorkflowInstantiation","currentState","startTime","createMetadata","metadataQuery","metadataGraph","workflowGraph","metadataIri","parseQuerySync","construct","updateWorkflowInstantiation","workflowIri","originalGraph","workflowState","endTime","advancedBy","userURI","deserializeWorkflowState","isWorkflowExist","WorkflowService","createRequest","resources","preferredLanguage","getPreferredUserLanguage","getEnvironmentConfig","environmentConfig","getUIConfig","uiConfig","getGlobalConfig","globalConfig","fetchConfig","environment","ConfigService","getConfigsInGroup","ui","global","initializeConfig","rawConfig","setEnvironmentConfig","setUIConfig","setGlobalConfig","resourceUrlMapping","preferredLanguages","preferredLabels","preferredThumbnails","templateIncludeQuery","enableUiComponentBasedSecurity","labelPaths","thumbnailPaths","labelPropertyPattern","makePropertyPattern","labelPropertyPath","makePropertyPath","thumbnailPropertyPattern","thumbnailPropertyPath","Boolean","paths","keepOnlyPropertyPaths","join","alternatives","path","alternative","parsePropertyPath","warn","pathType","items","endsWith","ConfigHolderClass","ConfigHolder","parseTemplate","getHeader","TEMPLATE_SERVICE_URL","getFooter","getNoPermissionsPage","ContextCapturer","CapturedContext","TemplateParser","URLMinifierService","makeShortURL","fullUrl","getShortKey","origin","getShortURLForResource","constructUrlForResource","absoluteTo","valueOf","GenericRestService","getJson","EventsApi","Event","EventType","BuiltInEvents","deserializers","serializers","isNull","isNumber","isString","isArray","Iterable","isPlainObject","serializerObj","serializer","addTypeDiscriminator","originalFn","serializedObjectType","obj","json","transform","val","deserializer","descriptor","constructor","serializerFor","deserializerFor","deserializerObj","isInsertDeleteOperation","updateType","isManagementOperation","isQuery","isSelectQuery","isConstructQuery","isAskQuery","isDescribeQuery","isStarProjection","variables","Array","isPattern","isGroupPattern","pattern","isBlockPattern","isExpression","isQuads","isTerm","isVariable","first","isUpdateOperation","getIri","renderLink","clone","title","params","extractParams","className","style","fragment","getChildren","isJust","fetchLabel","getlabel","getRepository","guessRepository","ResourceLinkComponent","running","toKeyedSeq","toObject","findKey","semanticContext","checkDeprecated","componentWillReceiveProps","nextProps","ErrorNotification","errorMessage","GET_REGISTERED_PREFIXES","getPrefixedIris","resolveIri","I","mapEntries","entry","toMap","getFullIris","getPrefixedUri","getFullIri","prefixedIri","getRegisteredPrefixes","getNamespaceRecords","setPrefix","prefix","ns","targetAppId","PUT_PREFIX","deletePrefix","DELETE_PREFIX","isSystemNamespacePrefix","SparqlJs","registeredPrefixes","RegisteredPrefixes","Generator","parseQuery","encodeLegacyVars","replaceQueryParams","serializeQuery","decodeLegacyVars","stringify","getCurrentResource","contextResource","substr","guessFileEnding","resultFormat","getFileEnding","fileEnding","addOrChangeLimit","limit","parseQueryAsync","validateSelectQuery","strings","raw","randomVariableName","Math","random","LUCENE_ESCAPE_REGEX","makeLuceneQuery","inputText","escape","tokenize","words","w","parsePatterns","patterns","prefixes","wrappedPattern","where","iriOrPath","isSelectResultEmpty","result","resolveIris","row","IRI_LOCAL_PART","compactIriUsingPrefix","iriValue","hasOwnProperty","expandedPrefix","localPart","test","recordSerializer","ResourceLinkAction","isSimpleClick","stopPropagation","isLinkActive","urlParams","currentUrlParms","getCurrentUrl","search","construcUrlForResourceSync","activeClassName","draggable","href","classNames","D","Draggable","button","ctrlKey","metaKey","ResourceLink","ObjectGraph","XsdDataTypeValidation","N3Util","tripleToN3","nTriple","nodeToN3","DEFAULT_GRAPH","cata","literalToN3","bnode","Format","Turtle","NTriples","Trig","NQuads","writer","Writer","addTriple","turtleToTriples","initN3Parser","scan","acc","x","last","n3TripleToRdf","n3ValueToRdf","isIRI","n3LiteralToRdf","langString","langLiteral","parser","nodeMember","visitMember","member","visit","memberName","call","sparqlQuery","throwUnexpected","expected","transformed","describe","walkArray","updates","updateOperation","insertDelete","managementOperation","operation","insert","valuesRows","rows","transforms","walkValuesVariables","resultVariable","transformedVariable","valueResult","coerce","List","reduce","vars","add","variableTerm","walkBaseQuery","walkProjectionVariables","from","walkOnlyIri","named","grouping","having","expression","ordering","bgp","block","valuesPattern","graphQuads","tuple","expr","functionCall","aggregate","walkPatternLikeExpression","variableName","blank","collectionName","nodes","walk","walkItem","names","coerced","QueryVisitor","cloneQuery","cloneDeep","Object","getPrototypeOf","create","purgeRemoteTemplateCache","remoteTemplateCache","clear","defaultContextCache","purgeTemplateCache","components","hasComponent","tagName","_value","onIri","onLiteral","onBnode","Node","Iri","Literal","BNode","toJSON","fromJSON","Pick","fullIri","slice","BASE_IRI","RDF_LANG_STRING","XSD_STRING","XSD_BOOLEAN","datatypeOrLanguage","_datatype","_lang","dataType","lang","_s","_p","_o","_g","Triple","_triples","Graph","union","graphs","flatten","pointer","_pointer","_graph","string","ii","charCodeAt","i32","ss","uniqBy","PointedGraph","EMPTY_GRAPH","getLocalName","indexOf","lastIndexOf","parentContext","deserializeContext","hasAnyBinding","defaultGraphs","namedGraphs","mergeIfDefined","Children","only","SemanticContextProvider","second","BaseSemanticContextProvider","QUERY_PARAM_PREFIX","paramPrefix","camelCase","h","__unsafe__setCurrentResource","currentLocation","listeners","history","createBrowserHistory","uniqueId","mUrl","notifyAll","navigationConfirmation","navigate","showNavigationConfirmationDialog","getOverlaySystem","hide","getCurrentRepository","inFrameNavigationHandler","inFrame","navigateToUrl","setFrameNavigation","enable","handler","openResourceInNewWindow","open","openExternalLink","confirmAll","c","START_PAGE","homePage","newUrl","persistRecentPages","mUri","baseQuery","setQuery","resolveResourceIri","pathname","maybeIri","listener","isNavigationListener","responsess","isBeforeNavigationListener","fromCallback","every","hasSearch","iriStr","prefixedIriStr","refresh","NavigationUtils","cloneElement","ResourceLinkContainer","computedPreferences","LanguagePreferences","BrowserPersistence","adapter","getOrComputePreferences","readPreferredUserLanguage","preferences","userLanguageTag","languageRanks","computeLanguageRanks","languageToRank","nextRank","setPreferredUserLanguage","bcp47LanguageTag","selectPreferredLabel","selectedLanguage","bestObserved","bestObservedRank","Number","MAX_SAFE_INTEGER","rank","resolveLabelWithFallback","labelIfDefined","REVISION_INFO_KEYS","keys","appId","revision","cleanRevisionInfo","info","pick","PageService","loadTemplateSource","loadPageTemplateHtml","loadRenderedTemplate","contextIri","rawResponse","save","sourceAppId","sourceRevision","rawContent","getAllTemplateInfos","statusText","deleteTemplateRevisions","selected","exportTemplateRevisions","re","xhr","responseType","getStorageStatus","SparqlQueryForm","SparqlOperationType","stringToSparqlQueryForm","SELECT","CONSTRUCT","ASK","DESCRIBE","SPARQL_RESULT_ACCEPT_HEADERS","TURTLE","DefaultResultHeaders","prepareParsedQuery","parameters","serializeParameters","k","queryCopy","unshift","VariableBinder","sparqlJsonToSelectResult","selectJson","sparqlSelectBindingValueToRdf","head","distinct","ordered","graphQuery","isConstruct","form","sendSparqlQuery","sparqlQueryRequest","headers","Accept","parametrizedEndpoint","prettyPrint","queryWithContext","preparedQuery","sparqlSelectBindingLiteralToRdf","setTextBindings","replacements","TextBinder","executeSparqlUpdate","updateRequest","WrappingError","_NAMESPACE","_DATATYPES_NAMESPACE","_string","float","double","date","time","decimal","anyURI","positiveInteger","negativeInteger","nonPositiveInteger","nonNegativeInteger","LIST_TYPES","NUMERIC_TYPES","SuperAgentRequest","Response","getAbsoluteUrl","getBaseUrl","patch","registerSerializersAndDeserializers","Seq","Indexed","OrderedSet","OrderedMap","Keyed","constructorFn","record","rest","nil","currentResource","tryReplace","termValue","replacement","currentMember","PropertyPathBinder","normalize","filterPlaceholder","placeholderFound","newIndex","splice","PatternBinder","fromVariable","toVariable","VariableRenameBinder","fetchRemoteTemplate","promise","toPromise","escapeRemoteTemplateHtml","templateHtml","catch","nameLookup","parent","isRemoteReference","resolveTemplateIri","ref","Handlebars","JavaScriptCompiler","partialName","IRIResolvingCompiler","compiler","localReferences","remoteReferences","PartialStatement","partial","addReference","PartialBlockStatement","getPartialName","parts","original","Visitor","ast","scanner","RemoteTemplateScanner","references","expanded","prefixed","remoteReference","createHandlebarsWithIRILookup","handlebars","isTemplate","escapeTemplateBody","newAttributes","attribs","escaped","escapePartialReferences","override","escapeChild","child","isEmptyTextNode","start","content","extractTemplates","missingID","templateNodes","hasId","templateNode","extractTemplate","getInnerHtml","html","renderTemplate","parseWithInstructions","shouldProcessNode","processNode","root","Basil","storages","check","anyAdapter","createAdapter","getRawItem","newState","partialState","removeItem","getItem","fromJS","BrowserPersistenceClass","DefaultHelpers","DataContextFunctions","GenericFunctions","DateTimeFunctions","RdfFunctions","UriComponentFunctions","NumbersFunctions","contexts","generateUniqueContextKey","lastContextKey","captureContext","dataContext","cloneContextData","getResult","DATA_KEY","getContext","contextKey","inheritAndCapture","inheritedContexts","CAPTURED_DATA_KEYS","_parent","mergeDataContext","outer","inner","isPlainObjectOrNothing","hasAnyOwnKey","overrideContextData","capture","capturedContext","fn","expose","boundContext","ERROR","METHODS_TO_WRAP","wrap","method","unsafe","safe","arguments","wrapComponent","comp","componentDidCatch","defaultComponentDidCatch","unsafeRender","unstable_handleError","getError","componentStack","componentInstance","safeReactCreateElement","safeReactCreateFactory","initReactErrorCatcher","ComponentProps","ComponentContext","ComponentChildContext","TemplateContext","templateDataContext","serviceUrl","pools","getPool","getRepositoryFromContext","fetchResources","batchSize","withMutations","constructUrl","setSearch","active","LinkComponent","SparqlTypeGuards","QueryContext","isCancelled","cancelHandlers","observable","subscribe","subscription","disposed","dispose","unsubscribe","onCancel","mapped","derive","derived","deriveAndCancel","previous","offCancel","findIndex","cancelled","SetAdded","SetRenamed","SetRemoved","ItemRemoved","ItemSelected","ItemsReordered","ItemsFiltered","ItemsFetched","REST_CONFIG_GROUP_URL","setConfig","deleteConfig","configValueToArray","isCustomElementTag","componentToGraph","componentRoot","parentTemplateScope","htmlTag","__htmlTag","componentNamespace","persist","COMPONENT_TYPE_PREFIX","appliedScope","propsGraph","otherProps","PersistedComponent","componentType","count","serializedChildren","childrenGraph","serializeArray","componentChildren","rawContext","templateProps","exportProps","contextGraph","componentContext","graphToComponent","componentTypeTriple","componentPropsTriple","componentChildrenRoot","componentContextRoot","deserializeArray","recentPages","MemoryHistory","createMemoryHistory","initialEntries","initialIndex","clearPersistedRecentPages","entries","pages","resetMemoryHistory","processNodeDefinitions","ProcessNodeDefinitions","NativeRegistry","asMutable","registerElement","customElements","define","renderWebComponent","componentTag","scopeTrace","componentId","isComponentPermited","componentName","right","SecurityService","isAlwaysPermitted","createElementWithTemplateScope","scopeProps","processDefaultNode","isCode","isCodeExample","isCodeBlock","isCodeChild","isStyle","isStyleChild","isReactComponent","isNativeComponent","isValidNode","processNativeComponent","div","dangerouslySetInnerHTML","__html","processCode","codeComponent","innerCode","he","decode","attributes","htmlAttributesToReactProps","codeToHighlight","codeText","skipNode","processStyle","styleNode","processReactComponent","msg","computedKey","nestedProps","attributeName","extractTemplateScope","el","Reparentable","uid","templates","builder","registerPartial","build","RAW_STYLE_ATTRIBUTE","parseHtmlToReact","processingInstructions","recognizeCDATA","isWebComponent","parseReactStyleFromCss","attributeValue","attributeNameToPropertyName","chr","decoded","isNaN","parseAttributeValue","valueWithoutLineBreaks","jsonMatches","isEnclosedInDoubleCurlyBraces","cssStyle","jsonStyles","styleEntry","separatorIndex","isNothing","isMoment","ISO_8601","subClassOf","Resource","dc","contributor","RDF","coverage","creator","publisher","relation","rights","NAMESPACE","Ascending","BasicContainer","constrainedBy","contains","Descending","DirectContainer","hasMemberRelation","IndirectContainer","insertedContentRelation","isMemberOfRelation","membershipResource","MemberSubject","NonRDFSource","Page","pageSequence","pageSortCollation","pageSortCriteria","PageSortCriterion","pageSortOrder","pageSortPredicate","PreferContainment","PreferEmptyContainer","PreferMembership","PreferMinimalContainer","RDFSource","oa","Annotation","SpecificResource","TextualBody","RangeSelector","XPathSelector","TextPositionSelector","hasBody","hasEndSelector","hasRole","hasSelector","hasSource","hasStartSelector","hasTarget","refinedBy","Field","prov","actedOnBehalfOf","Activity","activity","ActivityInfluence","agent","Agent","AgentInfluence","alternateOf","aq","Association","atLocation","atTime","Attribution","Bundle","Collection","Communication","constraints","Delegation","Derivation","dm","editorialNote","editorsDefinition","EmptyCollection","End","endedAtTime","Entity","entity","EntityInfluence","generated","generatedAtTime","Generation","hadActivity","hadGeneration","hadMember","hadPlan","hadPrimarySource","hadRole","hadUsage","Influence","influenced","influencer","InstantaneousEvent","invalidated","invalidatedAtTime","Invalidation","inverse","Location","Organization","Person","Plan","PrimarySource","qualifiedAssociation","qualifiedAttribution","qualifiedCommunication","qualifiedDelegation","qualifiedDerivation","qualifiedEnd","qualifiedForm","qualifiedGeneration","qualifiedInfluence","qualifiedInvalidation","qualifiedPrimarySource","qualifiedQuotation","qualifiedRevision","qualifiedStart","qualifiedUsage","Quotation","Revision","Role","sharesDefinitionWith","SoftwareAgent","specializationOf","Start","startedAtTime","todo","unqualifiedForm","Usage","used","wasAssociatedWith","wasAttributedTo","wasDerivedFrom","wasEndedBy","wasGeneratedBy","wasInfluencedBy","wasInformedBy","wasInvalidatedBy","wasQuotedFrom","wasRevisionOf","wasStartedBy","JsonNull","JsonUndefined","platform","FormContainer","OntodiaDiagramContainer","PersistedComponentContainer","WorkflowDefinitionContainer","containerType","clipboardItem","publicVisibility","privateVisibility","sharedVisibility","groupVisibility","searchResultCategory","WorkflowDefinition","propertyKeyToIriDefault","keyOrIndex","propertyNamespace","encodedKey","iriToPropertyKeyDefault","array","mapper","i","deserializeObjectHelper","iriToPropertyKey","some","parseFloat","parseInt","propertyKeyToIri","round","nestedNamespace","Whitespace","languageRegExp","RegExp","normalizedStringRegExp","tokenRegExp","year","month","timeZone","dateRegExp","dateTimeRegExp","durationRegExp","gDayRegExp","gMonthRegExp","gMonthDayRegExp","gYearRegExp","gYearMonthRegExp","timeRegExp","integerRegExp","decimalRegExp","b64","b64S","base64BinaryRegExp","booleanRegExp","doubleRegExp","hexBinaryRegExp","failure","errorPart","success","parseXsdDatatype","datatypeIri","localName","datatypeToString","datatypeEqual","whitespace","COLLAPSE","patternValue","PRESERVE","str","defaultWhitespace","wsParam","param","REPLACE","checkIntegerRange","min","max","checkInteger","checkRegExp","intValue","checkParams","checkRegExpAndParams","regExp","enumeration","paramName","paramValue","checkParam","checkEnumeration","escapeRegExp","number","fractionDigits","replaceDatatypeAliases","sameXsdDatatype","datatype1","datatype2","type1","type2","datatypeAllows","equal","innerError","formatMessage","setPrototypeOf","captureStackTrace","stack","innerMessage","delayIntervalMs","bufferedStream","bufferWithTimeOrCount","inputs","inputArray","onEnd","take","takeErrors","ifCond","v1","operator","v2","checkCondition","and","eq","not","or","switch","switchValue","switchBreak","case","break","objectLength","getValueByKey","noMatch","hasKey","uuidLib","dateTimeFormat","sourceFormat","currentDateTime","encodeUriComponent","decodeUriComponent","ceil","floor","toFixed","digits","plus","n1","n2","minus","EMPTY_TEMPLATE","helpers","partials","cache","helperId","loadByReference","reference","_fetchRemoteTemplate","compiledCache","registerHelper","clearCache","getPartial","TemplateScopeBuilder","compile","fromCache","resolved","withParentContext","local","capturer","compileWithoutRemote","compiled","templateBody","parsed","dependencies","recursiveResolve","parsedTemplate","referencesToLoad","fetchedDependencies","all","fetched","dependency","createScope","partialText"],"mappings":"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","file":"api-ecb32f6c2108f6134e6b.js","sourcesContent":["/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { Component, createElement, createFactory, ReactType, Props as ReactProps } from 'react';\nimport * as maybe from 'data.maybe';\n\nimport { loadComponent } from './ComponentsStore';\n\nexport interface Props extends ReactProps<ComponentLoader> {\n  componentTagName: string;\n  componentProps: any;\n}\n\ninterface State {\n  component: Data.Maybe<ReactType>;\n}\n\n/**\n * Asynchronously load React component implementation and\n * renders it as soon as it becomes available.\n */\nclass ComponentLoader extends Component<Props, State> {\n  constructor(props) {\n    super(props);\n    this.state = {\n      component: maybe.Nothing<ReactType>(),\n    };\n  }\n\n  componentDidMount() {\n    loadComponent(this.props.componentTagName).then((component) =>\n      this.setState({\n        component: maybe.Just(component),\n      })\n    );\n  }\n\n  render() {\n    return this.state.component\n      .map((component) => createElement(component as any, this.props.componentProps, this.props.children))\n      .getOrElse(null);\n  }\n}\n\nexport type component = ComponentLoader;\nexport const component = ComponentLoader;\nexport const factory = createFactory(component);\nexport default component;\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as Kefir from 'kefir';\n\nimport { Cancellation } from 'platform/api/async';\n\nexport class ExtensionPoint<T> {\n  private loaded = false;\n  private value: T | undefined;\n  private error: any;\n  // intialize with no-op loader\n  private loader: () => Kefir.Stream<T> = () => Kefir.later(0, undefined);\n  private loadingExtension: Kefir.Stream<T>;\n\n  constructor() {}\n\n  isLoading(): boolean {\n    return !this.loaded;\n  }\n\n  get(): T | undefined {\n    if (!this.loaded) {\n      throw new Error('Extension must be loaded before calling ExtensionPoint.get()');\n    } else if (this.error) {\n      throw this.error;\n    }\n    return this.value;\n  }\n\n  load(): Kefir.Stream<T> {\n    if (this.value) {\n      return Kefir.never();\n    }\n    if (this.loadingExtension) {\n      return this.loadingExtension;\n    } else {\n      const { loader } = this;\n      this.loadingExtension = loader()\n        .flatMap((newValue) => {\n          if (this.loader === loader) {\n            this.loaded = true;\n            this.value = newValue;\n            return Kefir.constant(newValue);\n          } else {\n            // load again if loader was changed in the middle of loading\n            return this.load();\n          }\n        })\n        .mapErrors((error) => {\n          this.loaded = true;\n          this.error = error;\n          console.error(error);\n          return error;\n        });\n      return this.loadingExtension;\n    }\n  }\n\n  loadAndUpdate(component: { forceUpdate(): void }, cancellation: Cancellation) {\n    const updateWhenLoaded = () => component.forceUpdate();\n    cancellation.map(this.load()).observe({\n      value: updateWhenLoaded,\n      error: updateWhenLoaded,\n    });\n  }\n\n  chainLoader(loader: (previous: T | undefined) => Kefir.Stream<T>) {\n    const previousValue = this.value;\n    const previousLoader = this.loader;\n    this.loader = () => {\n      return previousValue ? loader(previousValue) : previousLoader().flatMap(loader);\n    };\n    this.loaded = false;\n    this.value = undefined;\n    this.error = undefined;\n    this.loadingExtension = undefined;\n  }\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { Component, ValidationMap } from 'react';\nimport * as PropTypes from 'prop-types';\n\nimport * as TemplateService from 'platform/api/services/template';\nimport { Cancellation } from 'platform/api/async';\n\nimport { SemanticContext, SemanticContextTypes } from './SemanticContext';\nimport { TemplateContext, TemplateContextTypes } from './TemplateContext';\n\nexport type ComponentContext = SemanticContext & TemplateContext;\nexport const ContextTypes: ValidationMap<any> = {\n  ...SemanticContextTypes,\n  ...TemplateContextTypes,\n};\n\nexport type ComponentChildContext = TemplateContext;\n\nexport interface ComponentProps {\n  /**\n   * Scope with templates explicitely specified in the markup.\n   *\n   * If present then it means the component had been created from markup;\n   * otherwise it has been created as part of another component.\n   *\n   * This property should be used only as implementation detail to template-related\n   * components (like `SemanticIf`).\n   */\n  readonly markupTemplateScope?: TemplateService.TemplateScope;\n}\n\nconst ComponentPropTypes: { [K in keyof ComponentProps]?: any } = {\n  markupTemplateScope: PropTypes.object,\n};\n\n/**\n * @author Alexey Morozov\n */\nexport abstract class PlatformComponent<P, S = {}> extends Component<P, S> {\n  static propTypes: any = ComponentPropTypes;\n\n  static childContextTypes: any = TemplateContextTypes;\n\n  static readonly contextTypes: any = ContextTypes;\n  readonly context: ComponentContext;\n\n  readonly cancel = new Cancellation();\n\n  get appliedTemplateScope(): TemplateService.TemplateScope {\n    const { markupTemplateScope } = this.props as ComponentProps;\n    if (markupTemplateScope) {\n      return markupTemplateScope;\n    }\n    const inheritedScope = this.context.templateScope;\n    return inheritedScope || TemplateService.TemplateScope.default;\n  }\n\n  constructor(props: P, context: any) {\n    super(props, context);\n  }\n\n  componentWillUnmount() {\n    this.cancel.cancelAll();\n  }\n\n  getChildContext(): ComponentChildContext {\n    const { markupTemplateScope } = this.props as ComponentProps;\n    // resets template scope to explicitely provided one if\n    // component have been created from markup\n    return {\n      templateScope: markupTemplateScope || this.context.templateScope,\n    };\n  }\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as Kefir from 'kefir';\n\nimport { EventType } from './EventsApi';\nimport { EventMaker } from './Utils';\n\nexport interface BuiltInEventData {\n  /**\n   * Event which should be triggered when something should be refreshed.\n   */\n  'Component.Refresh': object;\n  /**\n   * Event which should be triggered when data has been loaded.\n   */\n  'Component.Loaded': object;\n  /**\n   * Event which should be triggered when a template should be updated with new properties.\n   */\n  'Component.TemplateUpdate': object;\n}\nconst event: EventMaker<BuiltInEventData> = EventMaker;\n\nexport const ComponentRefresh = event('Component.Refresh');\n/**\n * Event which should be triggered when component starts loading data.\n */\nexport const ComponentLoading: EventType<Kefir.Property<any>> = 'Component.Loading';\nexport const ComponentLoaded = event('Component.Loaded');\nexport const ComponentTemplateUpdate = event('Component.TemplateUpdate');\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as _ from 'lodash';\nimport * as uuid from 'uuid';\nimport * as Kefir from 'kefir';\nimport * as Immutable from 'immutable';\n\nimport { Rdf } from 'platform/api/rdf';\n\nimport { Event, EventFilter, EventType } from './EventsApi';\n\ninterface Subscriber {\n  eventFilter: EventFilter<any>;\n  emitter: Kefir.Emitter<Event<any>>;\n}\n\n/**\n * exposed only for testing purpose\n */\nexport const _subscribers: { [key: string]: Subscriber } = {};\n\n/**\n * Listen to all events that satisfies given 'eventFilter'.\n */\nexport function listen<Data>(eventFilter: EventFilter<Data>): Kefir.Stream<Event<Data>> {\n  return Kefir.stream((emitter) => {\n    const key = uuid.v4();\n    _subscribers[key] = { eventFilter, emitter };\n\n    // Emits the event if it has the current value\n    const currentValue = EventSourceStore.getCurrentValue(eventFilter);\n    if (currentValue) {\n      emitter.emit(currentValue);\n    }\n\n    return () => {\n      delete _subscribers[key]\n    };\n  });\n}\n\n/**\n * Trigger event.\n */\nexport function trigger<Data>(event: Event<Data>) {\n  _.forEach(_subscribers, subscriber => {\n    // in some browsers subscriber can be undefined because\n    // `delete _subscriber[key]` keeps the key and makes value undefined\n    if (subscriber) {\n      const { eventFilter, emitter } = subscriber;\n      if (\n        (eventFilter.eventType ? eventFilter.eventType === event.eventType : true) &&\n          (eventFilter.source ? eventFilter.source === event.source : true) &&\n          (eventFilter.target ? _.includes(event.targets || [], eventFilter.target) : true)\n      ) {\n        emitter.emit(event);\n      }\n    }\n  });\n  EventSourceStore.updateCurrentValue(event);\n}\n\nexport function registerEventSource(eventSource: EventSource) {\n  EventSourceStore.addEventSource(eventSource);\n}\n\nexport function unregisterEventSource(eventSource: EventSource) {\n  EventSourceStore.deleteEventSource(eventSource);\n}\n\ninterface EventSource {\n  source: string;\n  eventType: EventType<any>;\n  currentValue?: Event<any>;\n}\nnamespace EventSourceStore {\n  let sources: Immutable.Map<EventSourceKey, EventSource> = Immutable.Map();\n\n  export function getCurrentValue<Data>(eventFilter: EventFilter<Data>): Event<Data> | undefined {\n    const key = eventSourceKey(eventFilter.source, eventFilter.eventType);\n    const eventSource = sources.get(key);\n    if (eventSource) {\n      return eventSource.currentValue;\n    }\n    return undefined;\n  }\n\n  export function updateCurrentValue<Data>(event: Event<Data>) {\n    const key = eventSourceKey(event.source, event.eventType);\n    const eventSource = sources.get(key);\n    if (eventSource) {\n      sources = sources.set(key, { ...eventSource, currentValue: event });\n    }\n  }\n\n  export function addEventSource(eventSource: EventSource) {\n    const key = eventSourceKey(eventSource.source, eventSource.eventType);\n    if (!sources.has(key)) {\n      sources = sources.set(key, eventSource);\n    }\n  }\n\n  export function deleteEventSource(eventSource: EventSource) {\n    const key = eventSourceKey(eventSource.source, eventSource.eventType);\n    sources = sources.remove(key);\n  }\n\n  function eventSourceKey<Data>(source: string, eventType: EventType<Data>): EventSourceKey {\n    return new EventSourceKey(source, eventType);\n  }\n}\n\nclass EventSourceKey {\n  constructor(private _source: string, private _eventType: EventType<any>) {}\n\n  get source() {\n    return this._source;\n  }\n\n  get eventType() {\n    return this._eventType;\n  }\n\n  public equals(other: EventSourceKey) {\n    return this.source === other.source && this.eventType === other.eventType;\n  }\n\n  public hashCode() {\n    let hash = 0;\n    hash = 31 * hash + Rdf.hashString(this.source);\n    hash = 31 * hash + Rdf.hashString(this.eventType);\n    return Rdf.smi(hash);\n  }\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\nimport * as React from 'react';\nimport { Modal, Button, ButtonGroup } from 'react-bootstrap';\n\nexport interface Props {\n  message: string;\n  onHide: () => void;\n  onConfirm: (confirm: boolean) => void;\n}\n\n/**\n * Dialog that is shown when user need to confirm navigation from the current page.\n */\nexport class NavigationConfirmationDialog extends React.Component<Props, {}> {\n  render() {\n    const { onHide, message, onConfirm } = this.props;\n    const dialog = (\n      <Modal onHide={onHide} show={true}>\n        <Modal.Header>\n          <Modal.Title>Do you want to leave the page?</Modal.Title>\n        </Modal.Header>\n        <Modal.Body>\n          <p>{message}</p>\n        </Modal.Body>\n        <Modal.Footer>\n          <ButtonGroup>\n            <Button bsStyle=\"primary\" onClick={(e) => onConfirm(false)}>\n              Stay\n            </Button>\n            <Button bsStyle=\"danger\" onClick={(e) => onConfirm(true)}>\n              Leave\n            </Button>\n          </ButtonGroup>\n        </Modal.Footer>\n      </Modal>\n    );\n    return dialog;\n  }\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as Kefir from 'kefir';\nimport * as maybe from 'data.maybe';\nimport * as Immutable from 'immutable';\nimport * as request from 'platform/api/http';\n\nimport { Rdf, vocabularies } from 'platform/api/rdf';\nimport { trigger } from 'platform/api/events';\nimport { getLabel } from 'platform/api/services/resource-label';\nimport { LdpService, LdpServiceContext } from '../ldp';\nimport { Util as SecurityUtil, UserI } from '../security';\nimport { SetManagementEvents } from './SetManagementEvents';\n\nconst { rdf, rdfs, VocabPlatform, ldp, xsd } = vocabularies;\n\nexport class SetService extends LdpService {\n  createSet(name: string, slug = maybe.Nothing<string>()): Kefir.Property<Rdf.Iri> {\n    const generatedIri = Rdf.iri('');\n    const set = Rdf.graph([\n      Rdf.triple(generatedIri, rdfs.label, Rdf.literal(name)),\n      Rdf.triple(generatedIri, rdf.type, ldp.Container),\n      Rdf.triple(generatedIri, rdf.type, VocabPlatform.Set),\n    ]);\n    return this.addResource(set, slug);\n  }\n\n  addToExistingSet(setIri: Rdf.Iri, itemIris: Rdf.Iri): Kefir.Property<HolderWithItem> {\n    const existingSet = new LdpService(setIri.value, this.context);\n    return addSetItem(existingSet, itemIris);\n  }\n\n  createSetAndAddItems(name: string, listOfItemIris: Immutable.List<Rdf.Iri>): Kefir.Property<any[]> {\n    return this.createSet(name)\n      .flatMap((setLocation: Rdf.Iri) => {\n        const newSet = new LdpService(setLocation.value, this.context);\n        return Kefir.zip(listOfItemIris.map((iri, index) => addSetItem(newSet, iri, index)).toJS());\n      })\n      .toProperty();\n  }\n\n  reorderItems(setIri: Rdf.Iri, holders: Immutable.List<HolderWithItem>): Kefir.Property<void> {\n    const set = new LdpService(setIri.value, this.context);\n    return Kefir.zip(\n      holders\n        .map(({ holder, item }, index) =>\n          createItemHolderGraph(holder, item, index).flatMap((graph) => set.update(holder, graph))\n        )\n        .toArray()\n    )\n      .map(() => {\n        /* nothing */\n      })\n      .toProperty();\n  }\n}\n\nfunction addSetItem(set: LdpService, item: Rdf.Iri, index?: number): Kefir.Property<HolderWithItem> {\n  return createItemHolderGraph(Rdf.iri(''), item, index)\n    .flatMap((graph) => set.addResource(graph))\n    .map((holder) => ({ holder, item }))\n    .toProperty();\n}\n\nfunction createItemHolderGraph(holderIri: Rdf.Iri, itemIri: Rdf.Iri, index?: number): Kefir.Property<Rdf.Graph> {\n  return getLabel(itemIri).map((label) => {\n    const triples: Rdf.Triple[] = [\n      Rdf.triple(holderIri, VocabPlatform.setItem, itemIri),\n      Rdf.triple(holderIri, rdf.type, VocabPlatform.SetItem),\n    ];\n    triples.push(Rdf.triple(holderIri, rdfs.label, Rdf.literal(label)));\n    if (typeof index === 'number') {\n      triples.push(Rdf.triple(holderIri, VocabPlatform.setItemIndex, Rdf.literal(index.toString(), xsd.integer)));\n    }\n    return Rdf.graph(triples);\n  });\n}\n\ninterface HolderWithItem {\n  holder: Rdf.Iri;\n  item: Rdf.Iri;\n}\n\nexport function addToDefaultSet(resource: Rdf.Iri, sourceId: string): Kefir.Property<Rdf.Iri> {\n  return Kefir.combine([getSetServiceForUser(), Kefir.fromPromise(getUserDefaultSetIri())])\n    .flatMap(([service, defaultSetIri]) =>\n      service.addToExistingSet(defaultSetIri, resource).map(() => {\n        trigger({ eventType: SetManagementEvents.ItemAdded, source: sourceId });\n        return resource;\n      })\n    )\n    .toProperty();\n}\n\nexport function getUserSetRootContainerIri(username?: string): Promise<Rdf.Iri> {\n  return new Promise<Rdf.Iri>((resolve, reject) => {\n    request\n      .get('/rest/sets/getUserSetRootContainerIri')\n      .query({ username })\n      .type('application/json')\n      .accept('text/plain')\n      .end((err, res) => {\n        if (err) {\n          reject(err);\n        }\n        const iri = res.text;\n        if (typeof iri !== 'string') {\n          throw new Error(`Invalid user set root container IRI: ${iri}`);\n        }\n        resolve(Rdf.iri(iri));\n      });\n  });\n}\n\nexport function getUserDefaultSetIri(username?: string): Promise<Rdf.Iri> {\n  return new Promise<Rdf.Iri>((resolve, reject) => {\n    request\n      .get('/rest/sets/getUserDefaultSetIri')\n      .query({ username })\n      .type('application/json')\n      .accept('text/plain')\n      .end((err, res) => {\n        if (err) {\n          reject(err);\n        }\n        const iri = res.text;\n        if (typeof iri !== 'string') {\n          throw new Error(`Invalid user default set IRI: ${iri}`);\n        }\n        resolve(Rdf.iri(iri));\n      });\n  });\n}\n\nclass ContainerOfUserSetContainers extends LdpService {\n  constructor(context: LdpServiceContext | undefined) {\n    super(VocabPlatform.UserSetContainer.value, context);\n  }\n\n  getOrCreateSetContainer(setContainerIri: Rdf.Iri): Kefir.Property<SetService> {\n    const setService = new SetService(setContainerIri.value, this.context);\n    return this.get(setContainerIri)\n      .map((graph) => setService)\n      .flatMapErrors(() =>\n        Kefir.combine([\n          Kefir.fromPromise(SecurityUtil.getUser()),\n          Kefir.fromPromise(getUserDefaultSetIri()),\n        ]).flatMap(([user, defaultSetIri]) =>\n          this.createSetContainerForUser(user, setContainerIri).flatMap(() =>\n            setService\n              .createSet('Uncategorized', maybe.Just(defaultSetIri.value))\n              .flatMapErrors(() => Kefir.constant({}))\n          )\n        )\n      )\n      .map(() => setService)\n      .toProperty();\n  }\n\n  createSetContainerForUser(user: UserI, setContainerIri: Rdf.Iri): Kefir.Property<void> {\n    const generatedIri = Rdf.iri('');\n    const containerName = `Set container of user '${user.principal}'`;\n    return this.addResource(\n      Rdf.graph([\n        Rdf.triple(generatedIri, rdfs.label, Rdf.literal(containerName)),\n        Rdf.triple(generatedIri, rdf.type, ldp.Container),\n        Rdf.triple(generatedIri, rdf.type, VocabPlatform.SetContainer),\n      ]),\n      maybe.Just(setContainerIri.value)\n    ).map(() => {\n      /* nothing */\n    });\n  }\n}\n\nlet setContainerOfCurrentUser: Kefir.Property<SetService> = undefined;\n\nexport function getSetServiceForUser(context?: LdpServiceContext): Kefir.Property<SetService> {\n  if (setContainerOfCurrentUser) {\n    return setContainerOfCurrentUser;\n  }\n\n  const container = new ContainerOfUserSetContainers(context);\n  setContainerOfCurrentUser = Kefir.fromPromise(getUserSetRootContainerIri())\n    .flatMap<SetService>((setContainerIri) => container.getOrCreateSetContainer(setContainerIri))\n    .toProperty();\n  return setContainerOfCurrentUser;\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\nimport * as React from 'react';\nimport { isEmpty, trim } from 'lodash';\nimport { FormControl, FormGroup, InputGroup, Button, Form, HelpBlock } from 'react-bootstrap';\n\nimport { Rdf } from 'platform/api/rdf';\nimport { navigateToResource } from 'platform/api/navigation';\n\nexport interface NavigateToIRIProps {\n  placeholder?: string;\n  buttonCaption?: string;\n}\n\ninterface State {\n  value: string;\n  error?: boolean;\n}\n\n/**\n * Component that can be used to navigate to the specified IRI resource page.\n */\nexport class NavigateToIRI extends React.Component<NavigateToIRIProps, State> {\n  constructor(props, context) {\n    super(props, context);\n    this.state = {\n      value: '',\n    };\n  }\n\n  static defaultProps = {\n    placeholder: 'Enter the full IRI to navigate to the resource page, e.g http://example.org/bob#me',\n    buttonCaption: 'Navigate',\n  };\n\n  render() {\n    return (\n      <Form horizontal onSubmit={this.onClick}>\n        <FormGroup validationState={this.state.error ? 'error' : null}>\n          <InputGroup>\n            <FormControl\n              type=\"text\"\n              placeholder={this.props.placeholder}\n              value={this.state.value}\n              onChange={this.onValueChange}\n            />\n            <InputGroup.Button>\n              <Button bsStyle=\"success\" disabled={this.isExploreDisabled()} onClick={this.onClick}>\n                {this.props.buttonCaption}\n              </Button>\n            </InputGroup.Button>\n          </InputGroup>\n          {this.state.error ? (\n            <HelpBlock>Can't navigate to the resource? The value is not a valid IRI.</HelpBlock>\n          ) : null}\n        </FormGroup>\n      </Form>\n    );\n  }\n\n  private onValueChange = (event: React.ChangeEvent<any>) => this.setState({ value: trim(event.target.value) });\n\n  private isExploreDisabled = () => isEmpty(this.state.value);\n\n  private onClick = (event: React.SyntheticEvent<any>) => {\n    event.preventDefault();\n    navigateToResource(Rdf.iri(this.state.value))\n      .onValue((v) => {})\n      .onError((e) => this.setState({ error: true }));\n  };\n}\n\nexport default NavigateToIRI;\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as Kefir from 'kefir';\nimport * as maybe from 'data.maybe';\nimport * as request from 'platform/api/http';\n\nimport { Rdf, turtle, vocabularies } from 'platform/api/rdf';\nimport * as URI from 'urijs';\nimport * as _ from 'lodash';\n\nconst { VocabPlatform } = vocabularies;\n\ninterface SerializedResource {\n  data: string;\n  format: string;\n}\n\nexport interface LdpServiceContext {\n  readonly repository?: string;\n  readonly isDefault?: boolean;\n}\n\nexport class LdpService {\n  protected readonly BASE_CONTAINER: string;\n  protected readonly context: LdpServiceContext;\n\n  constructor(container: string, context?: LdpServiceContext) {\n    if (!context || context.isDefault) {\n      this.context = { repository: 'assets' };\n    } else {\n      this.context = context;\n    }\n\n    if (typeof container !== 'string') {\n      throw new Error('Container IRI cannot be null or undefined');\n    }\n    this.BASE_CONTAINER = container;\n  }\n\n  protected getServiceUrl(urlSuffix = '', queryParams: { [param: string]: string | string[] } = {}) {\n    const endpoint = `/container${urlSuffix}`;\n    const urlQuery = URI.buildQuery(_.assign({ repository: this.context.repository }, queryParams));\n    return urlQuery ? `${endpoint}?${urlQuery}` : endpoint;\n  }\n\n  /**\n   * TODO move to different place\n   * @param  {Rdf.Iri}      setIri\n   * @param  {Rdf.Iri}      visibilityEnum\n   * @return {Kefir.Stream}\n   */\n  public static setVisibility(setIri: Rdf.Iri, visibilityEnum: Rdf.Iri, groups: Rdf.Iri[]): Kefir.Property<{}> {\n    const resource = Rdf.graph([\n      Rdf.triple(Rdf.iri(''), VocabPlatform.visibilityItem, setIri),\n      Rdf.triple(setIri, VocabPlatform.visibility, visibilityEnum),\n      ..._.map(groups, (group) => Rdf.triple(setIri, VocabPlatform.visibleToGroups, group)),\n    ]);\n\n    return new LdpService(VocabPlatform.VisibilityContainer.value).addResource(resource, maybe.Nothing<string>());\n  }\n\n  public getContainerIRI = (): Rdf.Iri => {\n    return Rdf.iri(this.BASE_CONTAINER);\n  };\n\n  public getContainer(): Kefir.Property<Rdf.Graph> {\n    return this.fetchResource(Rdf.iri(this.BASE_CONTAINER));\n  }\n\n  public get(resourceIri: Rdf.Iri): Kefir.Property<Rdf.Graph> {\n    return this.fetchResource(resourceIri);\n  }\n\n  public update(resourceIri: Rdf.Iri, resource: Rdf.Graph): Kefir.Property<Rdf.Iri> {\n    return turtle.serialize\n      .serializeGraph(resource)\n      .flatMap((turtle) => this.sendUpdateResourceRequest(resourceIri, { data: turtle, format: 'text/turtle' }))\n      .toProperty();\n  }\n\n  public options(resourceIri: Rdf.Iri): Kefir.Property<{}> {\n    const req = request.options(this.getServiceUrl()).query({ uri: resourceIri.value });\n    return Kefir.fromNodeCallback((cb) =>\n      req.end((err, res) => cb(err != null ? err.status : null, res.ok ? res.text : null))\n    ).toProperty();\n  }\n\n  public deleteResource(resourceIri: Rdf.Iri) {\n    const req = request.del(this.getServiceUrl()).query({ uri: resourceIri.value });\n    return Kefir.fromNodeCallback((cb) => req.end((err, res) => cb(err, res ? res.text : null))).toProperty();\n  }\n\n  public addResource = (resource: Rdf.Graph, name = maybe.Nothing<string>()): Kefir.Property<Rdf.Iri> => {\n    return turtle.serialize\n      .serializeGraph(resource)\n      .flatMap((turtle) =>\n        this.createResourceRequest(this.getContainerIRI(), { data: turtle, format: 'text/turtle' }, name)\n      )\n      .map((location) => Rdf.iri(location))\n      .toProperty();\n  };\n\n  renameResource(resourceIri: Rdf.Iri, newName: string): Kefir.Property<void> {\n    const req = request.put(this.getServiceUrl('/rename')).query({ uri: resourceIri.value, newName });\n    return Kefir.stream<void>((emitter) => {\n      req.end((err, res) => {\n        if (err) {\n          emitter.error(err);\n        } else {\n          emitter.emit(undefined);\n        }\n        emitter.end();\n      });\n      return () => req.abort();\n    }).toProperty();\n  }\n\n  /**\n   * Returns created resource URI.\n   */\n  public createResourceRequest = (\n    containerIri: Rdf.Iri,\n    resource: SerializedResource,\n    name = maybe.Nothing<string>()\n  ): Kefir.Property<string> => {\n    let req = request\n      .post(this.getServiceUrl())\n      .query({ uri: containerIri.value })\n      .send(resource.data)\n      .type(resource.format);\n    req = name.map((slug) => req.set('Slug', slug)).getOrElse(req);\n    return Kefir.fromNodeCallback<string>((cb) =>\n      req.end((err, res) => cb(err, res ? res.header['location'] : null))\n    ).toProperty();\n  };\n\n  /**\n   * Copy resource into same or specified container and returns new resource URI\n   */\n  public copyResource(\n    resource: Rdf.Iri,\n    targetContainer: Data.Maybe<Rdf.Iri>,\n    name = maybe.Nothing<string>()\n  ): Kefir.Property<string> {\n    let req = request.get(this.getServiceUrl('/copyResource'));\n    req = targetContainer\n      .map((target) => req.query({ source: resource.value, target: target.value }))\n      .getOrElse(req.query({ source: resource.value }));\n    req = name.map((slug) => req.set('Slug', slug)).getOrElse(req);\n    return Kefir.fromNodeCallback<string>((cb) =>\n      req.end((err, res) => cb(err, res ? res.header['location'] : null))\n    ).toProperty();\n  }\n\n  public sendUpdateResourceRequest(resourceUrl: Rdf.Iri, resource: SerializedResource): Kefir.Property<Rdf.Iri> {\n    const req = request\n      .put(this.getServiceUrl())\n      .query({ uri: resourceUrl.value })\n      .send(resource.data)\n      .type(resource.format);\n    return Kefir.fromNodeCallback<Rdf.Iri>((cb) =>\n      req.end((err, res) => {\n        cb(err, res ? Rdf.iri(res.header['location']) : null);\n      })\n    ).toProperty();\n  }\n\n  protected fetchResource(iri: Rdf.Iri): Kefir.Property<Rdf.Graph> {\n    return this.getResourceTriples(iri.value, 'text/turtle');\n  }\n\n  protected getResourceTriples(resourceUrl: string, format: string): Kefir.Property<Rdf.Graph> {\n    return this.getResourceRequest(resourceUrl, format)\n      .flatMap((res) => {\n        return turtle.deserialize.turtleToGraph(res);\n      })\n      .toProperty();\n  }\n\n  public getResourceRequest(resourceUrl: string, format: string): Kefir.Property<string> {\n    const req = request.get(this.getServiceUrl()).query({ uri: resourceUrl }).accept(format);\n    return Kefir.fromNodeCallback<request.Response>(req.end.bind(req))\n      .toProperty()\n      .map((res) => res.text);\n  }\n\n  public getExportURL(iris: string[]): string {\n    return this.getServiceUrl('/exportResource', { iris: iris });\n  }\n\n  public getImportURL(): string {\n    return this.getServiceUrl('/importResource');\n  }\n\n  public importGetTextFromURL(url: string): Kefir.Property<string> {\n    const req = request.get(url);\n    return Kefir.fromNodeCallback<string>((cb) =>\n      req.end((err, res) => {\n        cb(err, res && res.ok ? res.text : null);\n      })\n    ).toProperty();\n  }\n\n  public importFromText(text: string, containerIRI?: string, force?: boolean): Kefir.Property<request.Response> {\n    let req = request.post(this.getImportURL()).send(new File([text], 'import.ttl'));\n    if (force) {\n      req = req.query({ force });\n    }\n    if (containerIRI) {\n      req = req.query({ containerIRI });\n    }\n    return Kefir.fromNodeCallback<request.Response>((cb) =>\n      req.end((err, res) => {\n        cb(err, res);\n      })\n    ).toProperty();\n  }\n\n  public importFromDelayedId(delayedId: string, containerIRI: string): Kefir.Property<request.Response> {\n    const req = request\n      .post(this.getImportURL())\n      // .type('form')\n      .query({ force: true, delayedId, containerIRI });\n    return Kefir.fromNodeCallback<request.Response>((cb) =>\n      req.end((err, res) => {\n        cb(err, res);\n      })\n    ).toProperty();\n  }\n}\n\nexport function ldpc(baseUrl: string) {\n  return new LdpService(baseUrl);\n}\n\nexport function slugFromName(name: String) {\n  return name\n    .toLowerCase()\n    .trim()\n    .replace(/[^a-zA-Z0-9~_-]+/g, '-');\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as ModuleRegistry from './Registry';\nimport * as ReactErrorCatcher from './ReactErrorCatcher';\nimport * as ComponentsLoader from './ComponentsLoader';\n\nexport { ComponentClassMetadata } from './ComponentsStore';\nexport { ModuleRegistry, ReactErrorCatcher, ComponentsLoader };\n\nexport { ExtensionPoint } from './ExtensionPoint';\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as request from 'platform/api/http';\nimport * as _ from 'lodash';\nimport * as Kefir from 'kefir';\nimport * as Immutable from 'immutable';\n\nimport { BatchedPool, requestAsProperty } from 'platform/api/async';\nimport { Rdf } from 'platform/api/rdf';\n\nexport interface SecurityUtilI {\n  isPermitted(permissionString: string): Kefir.Property<boolean>;\n  getUser(callback?: (user: UserI) => void): Promise<UserI>;\n  isAnonymous(callback: (whetherIsAnonymous: boolean) => void): void;\n}\n\nexport namespace Permissions {\n  export const templateSave = 'pages:edit:save';\n\n  const sparqlQueryEditor = 'ui:component:view:mp:sparql:query:editor';\n  /** Dropdown to select other endpoints for debugging purpose. */\n  export const queryEditorSelectEndpoint = `${sparqlQueryEditor}:select:repository`;\n\n  /**\n   * Permission for page explore actions - Ontodia, Graph View, Table View.\n   */\n  export const pageToolbarExplore = 'ui:page:view:toolbar:explore';\n\n  export const sparqlSelect = 'sparql:query:select';\n  export const qaasInfo = 'qaas:info';\n\n  /**\n   * Constructs permission string to perform specified action on an LDP resource.\n   * (Based on Permissions.java)\n   */\n  export function toLdp(\n    base: 'container' | 'type',\n    resource: Rdf.Iri,\n    action: 'read' | 'create' | 'update' | 'delete' | 'export' | 'import',\n    ownership: 'any' | 'owner'\n  ) {\n    return `api:ldp:${base}:<${resource.value}>:${action}:${ownership}`;\n  }\n}\n\nexport interface PermissionDocumentation {\n  readonly acl: string;\n  readonly description: string;\n  readonly example: string;\n}\n\nexport interface UserI {\n  principal?: string;\n  isAuthenticated: boolean;\n  isAnonymous: boolean;\n  userURI: string;\n}\n\nexport interface SessionInfoI {\n  lastAccessTimestamp: number;\n  timout: number;\n  idleTime: number;\n}\n\nexport interface Account {\n  principal: string;\n  password: string;\n  roles: string;\n  permissions?: string;\n}\n\nexport interface RoleDefinition {\n  roleName: string;\n  permissions: Array<string>;\n}\n\nexport class NotEnoughPermissionsError extends Error {\n  __proto__: Error;\n  constructor(message) {\n    const trueProto = new.target.prototype;\n    super(message);\n    this.__proto__ = trueProto;\n  }\n}\n\nexport class SecurityUtil implements SecurityUtilI {\n  private pool = new BatchedPool<string, boolean>({ fetch: (perms) => this.fetchPermitted(perms.toArray()) });\n\n  public getUser(cb?: (user: UserI) => void): Promise<UserI> {\n    if (cb) {\n      this.getUser().then(cb);\n      return;\n    }\n\n    // TODO cache\n    const WINDOW_user = 'cache_user';\n    if (!_.isUndefined(window[WINDOW_user])) {\n      return Promise.resolve(window[WINDOW_user]);\n    }\n\n    return new Promise((resolve, reject) => {\n      request\n        .get('/rest/security/user')\n        .type('application/json')\n        .accept('application/json')\n        .end((err, res) => {\n          if (err) {\n            reject(err);\n          } else {\n            const user = <UserI>JSON.parse(res.text);\n            window[WINDOW_user] = user;\n            resolve(user);\n          }\n        });\n    });\n  }\n\n  public isPermitted(permissionString: string): Kefir.Property<boolean> {\n    return this.pool.query(permissionString);\n  }\n\n  private fetchPermitted(permissionStrings: string[]): Kefir.Property<Immutable.Map<string, boolean>> {\n    const req = request\n      .post('/rest/security/permissions')\n      .send(permissionStrings)\n      .type('application/json')\n      .accept('application/json');\n    return Kefir.fromNodeCallback<{ [permission: string]: boolean }>((cb) => req.end((err, res) => cb(err, res.body)))\n      .toProperty()\n      .map((batch) => Immutable.Map(batch));\n  }\n\n  /**\n   * Checks with backend whether the current logged-in subject is a anonymous user.\n   * Value is cached in current window scope i.e. will be refreshed only if\n   * user opens new tab or tab is reloaded e.g. due to login/logout.\n   * @param {Function} cb callback\n   */\n  public isAnonymous(cb): void {\n    // TODO cache\n    const WINDOW_isAnonymousUser = 'cache_isAnonymousUser';\n    if (!_.isUndefined(window[WINDOW_isAnonymousUser])) {\n      cb(window[WINDOW_isAnonymousUser]);\n      return;\n    }\n    this.getUser((userObject) => {\n      window[WINDOW_isAnonymousUser] = (<UserI>userObject).isAnonymous;\n      cb((<UserI>userObject).isAnonymous);\n    });\n  }\n\n  public getSessionInfo(cb) {\n    return request\n      .get('/rest/security/getSessionInfo')\n      .type('application/json')\n      .accept('application/json')\n      .end((err, res) => {\n        cb(<SessionInfoI>JSON.parse(res.text));\n      });\n  }\n\n  public touchSession(cb) {\n    return request.post('/rest/security/touchSession').end((err, res: request.Response) => {\n      cb(res.status);\n    });\n  }\n\n  public getAllAccounts(): Kefir.Property<Account[]> {\n    const req = request.get('/rest/security/getAllAccounts').type('application/json').accept('application/json');\n\n    return Kefir.fromNodeCallback<Account[]>((cb) =>\n      req.end((err, res: request.Response) => {\n        cb(err != null ? err.message : null, res.ok ? <Account[]>JSON.parse(res.text) : null);\n      })\n    ).toProperty();\n  }\n\n  getDocumentationForAllPermissions(): Kefir.Property<PermissionDocumentation[]> {\n    const req = request.get('/rest/security/getAllPermissionsDoc').type('application/json').accept('application/json');\n    return requestAsProperty(req).map((res) => res.body);\n  }\n\n  public createAccount(account: Account): Kefir.Property<boolean> {\n    const req = request.post('/rest/security/createAccount').send(account).type('application/json');\n\n    return Kefir.fromNodeCallback<boolean>((cb) =>\n      req.end((err, res: request.Response) => {\n        cb(err != null ? err.response.text : null, res.ok ? true : null);\n      })\n    ).toProperty();\n  }\n\n  public updateAccount(account: Account): Kefir.Property<boolean> {\n    const req = request.put('/rest/security/updateAccount').send(account).type('application/json');\n\n    return Kefir.fromNodeCallback<boolean>((cb) =>\n      req.end((err, res: request.Response) => {\n        cb(err != null ? err.response.text : null, res.ok ? true : null);\n      })\n    ).toProperty();\n  }\n\n  public deleteAccount(account: Account): Kefir.Property<boolean> {\n    const req = request.del('/rest/security/deleteAccount/' + account.principal);\n\n    return Kefir.fromNodeCallback<boolean>((cb) =>\n      req.end((err, res: request.Response) => {\n        cb(err != null ? err.response.text : null, res.ok ? true : null);\n      })\n    ).toProperty();\n  }\n\n  public getRoleDefinitions(): Kefir.Property<RoleDefinition[]> {\n    const req = request.get('/rest/security/getAllRoleDefinitions').type('application/json').accept('application/json');\n\n    return Kefir.fromNodeCallback<RoleDefinition[]>((cb) =>\n      req.end((err, res: request.Response) => {\n        cb(err != null ? err : null, res.ok ? <RoleDefinition[]>JSON.parse(res.text) : null);\n      })\n    ).toProperty();\n  }\n\n  isPermissionValid(permission: string): Kefir.Property<boolean> {\n    const req = request\n      .put('/rest/security/isPermissionValid')\n      .send(permission)\n      .type('application/json')\n      .accept('application/json');\n\n    return requestAsProperty(req).map((res) => res.body);\n  }\n\n  updateRoleDefinitions(roles: RoleDefinition[]): Kefir.Property<boolean> {\n    const req = request.put('/rest/security/updateRoleDefinitions').send(roles).type('application/json');\n\n    return requestAsProperty(req).map((res) => res.ok);\n  }\n}\n\nexport const Util = new SecurityUtil();\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { post, del, Response } from 'superagent';\nimport * as Kefir from 'kefir';\nimport * as URI from 'urijs';\n\nimport { LdpService } from 'platform/api/services/ldp';\nimport { Rdf, vocabularies } from 'platform/api/rdf';\nimport { requestAsProperty } from 'platform/api/async';\nimport { modeLabel } from 'platform/components/documentation/CodeBlock.scss';\n\nexport const FILE_UPLOAD_SERVICE_URL = '/file';\nexport const FILE_LDP_CONTAINER_ID = 'http://www.researchspace.org/resource/system/fileContainer';\n\nexport const FILE_URL = '';\nexport const ADMIN_URL = '/direct';\nexport const TEMPORARY_STORAGE_URL = '/temporary';\nexport const MOVE_URL = '/move';\n\nconst { VocabPlatform } = vocabularies;\n\nexport const RESOURCE_QUERY = `\n  CONSTRUCT {\n    ?__resourceIri__ a <${VocabPlatform.File.value}>.\n    ?__resourceIri__ <${VocabPlatform.fileName.value}> ?__fileName__.\n    ?__resourceIri__ <${VocabPlatform.mediaType.value}> ?__mediaType__.\n    ?__resourceIri__ <${VocabPlatform.fileContext.value}> ?__contextUri__.\n  } WHERE {}\n`;\n\nexport interface FileResource {\n  iri: Rdf.Iri;\n  fileName: string;\n  mediaType: string;\n}\n\nexport class FileManager {\n  private readonly repository: string;\n  private readonly ldp: LdpService;\n\n  constructor(options: { repository: string }) {\n    const { repository } = options;\n    this.repository = repository;\n    this.ldp = new LdpService(FILE_LDP_CONTAINER_ID, { repository });\n  }\n\n  /**\n   * @returns file resource IRI\n   */\n  uploadFileAsResource(options: {\n    file: File;\n    storage: string;\n    contextUri?: string;\n    generateIriQuery?: string;\n    resourceQuery?: string;\n    onProgress?: (percent: number) => void;\n    fileNameHack?: boolean;\n  }): Kefir.Property<Rdf.Iri> {\n    if (!options.storage) {\n      return Kefir.constantError<any>(new Error('Storage is undefined!'));\n    }\n\n    const request = post(FILE_UPLOAD_SERVICE_URL + FILE_URL)\n      .attach('file', options.file as any)\n      .field('fileSize', `${options.file.size}`)\n      .field('storage', options.storage)\n      .field('repository', this.repository)\n      .field('createResourceQuery', options.resourceQuery || RESOURCE_QUERY)\n      .field('generateIriQuery', options.generateIriQuery || '')\n      .field('contextUri', options.contextUri || '')\n      .field('fileNameHack', options.fileNameHack ? 'true' : '')\n      .on('progress', (e) => {\n        if (options.onProgress) {\n          options.onProgress(e.percent as number);\n        }\n      });\n\n    return requestAsProperty(request).map((response) => {\n      const fileIri = Rdf.iri(response.header.location);\n      return fileIri;\n    });\n  }\n\n  /**\n   * @returns object ID of the uploaded file, including object kind prefix \"file/\"\n   */\n  uploadFileDirectlyToStorage(options: {\n    file: File;\n    storage: string;\n    folder: string;\n    fileName?: string;\n    onProgress?: (percent: number) => void;\n  }): Kefir.Property<string> {\n    if (!options.storage) {\n      return Kefir.constantError<any>(new Error('Storage is undefined!'));\n    }\n    if (!options.folder) {\n      return Kefir.constantError<any>(new Error('Path is undefined!'));\n    }\n\n    const request = post(FILE_UPLOAD_SERVICE_URL + ADMIN_URL)\n      .attach('file', options.file as any)\n      .field('fileSize', `${options.file.size}`)\n      .field('storage', options.storage)\n      .field('folder', options.folder)\n      .field('fileName', options.fileName || '')\n      .on('progress', (e) => {\n        if (options.onProgress) {\n          options.onProgress(<number>e.percent);\n        }\n      });\n\n    return requestAsProperty(request).map((response) => {\n      return response.ok ? response.text : null;\n    });\n  }\n\n  /**\n   * Uploads file to temporary storage and returns its description.\n   *\n   * @returns file resource IRI\n   */\n  public uploadFileTemporary(options: {\n    file: File;\n    storage: string;\n    onProgress?: (percent: number) => void;\n  }): Kefir.Property<Rdf.Iri> {\n    if (!options.storage) {\n      return Kefir.constantError<any>(new Error('Storage is undefined!'));\n    }\n\n    const request = post(FILE_UPLOAD_SERVICE_URL + TEMPORARY_STORAGE_URL)\n      .attach('file', options.file as any)\n      .field('fileSize', `${options.file.size}`)\n      .field('storage', options.storage)\n      .on('progress', (e) => {\n        if (options.onProgress) {\n          options.onProgress(<number>e.percent);\n        }\n      });\n\n    return requestAsProperty(request).map((response) =>\n      TemporaryFileSchema.encodeAsIri(response.text, options.file.type)\n    );\n  }\n\n  /**\n   * @returns file resource IRI\n   */\n  createResourceFromTemporaryFile(options: {\n    fileName: string;\n    storage: string;\n    temporaryStorage: string;\n    contextUri?: string;\n    mediaType: string;\n    generateIriQuery?: string;\n    resourceQuery?: string;\n    onProgress?: (percent: number) => void;\n  }): Kefir.Property<Rdf.Iri> {\n    const request = post(FILE_UPLOAD_SERVICE_URL + MOVE_URL)\n      .field('fileName', options.fileName)\n      .field('storage', options.storage)\n      .field('temporaryStorage', options.temporaryStorage)\n      .field('repository', this.repository)\n      .field('createResourceQuery', options.resourceQuery || RESOURCE_QUERY)\n      .field('mediaType', options.mediaType)\n      .field('generateIriQuery', options.generateIriQuery || '')\n      .field('contextUri', options.contextUri || '')\n      .on('progress', (e) => {\n        if (options.onProgress) {\n          options.onProgress(<number>e.percent);\n        }\n      });\n\n    return requestAsProperty(request).map((response) => {\n      const fileIri = Rdf.iri(response.header.location);\n      return fileIri;\n    });\n  }\n\n  deleteFileResource(\n    resourceIri: Rdf.Iri,\n    storage: string,\n    options?: {\n      namePredicateIri?: string;\n      mediaTypePredicateIri?: string;\n    },\n  ): Kefir.Property<Response> {\n    return this.getFileResource(resourceIri, options)\n      .flatMap((resource) => {\n        const request = del(FILE_UPLOAD_SERVICE_URL + FILE_URL)\n          .field('fileName', resource.fileName)\n          .field('storage', storage)\n          .field('repository', this.repository)\n          .field('resourceIri', resource.iri.value);\n\n        return requestAsProperty(request);\n      })\n      .toProperty();\n  }\n\n  removeTemporaryResource(resourceIri: Rdf.Iri, storage: string): Kefir.Property<Response> {\n    const { fileName } = TemporaryFileSchema.decodeFromIri(resourceIri);\n    const request = del(FILE_UPLOAD_SERVICE_URL + TEMPORARY_STORAGE_URL)\n      .field('fileName', fileName)\n      .field('storage', storage);\n\n    return requestAsProperty(request);\n  }\n\n  getFileResourceGraph(resourceIri: Rdf.Iri): Kefir.Property<Rdf.Graph> {\n    return this.ldp.get(resourceIri);\n  }\n\n  getFileResource(\n    resourceIri: Rdf.Iri,\n    options?: {\n      namePredicateIri?: string;\n      mediaTypePredicateIri?: string;\n    }\n  ): Kefir.Property<FileResource> {\n    if (TemporaryFileSchema.isEncodedIri(resourceIri)) {\n      const { fileName, mediaType } = TemporaryFileSchema.decodeFromIri(resourceIri);\n      return Kefir.constant({ iri: resourceIri, fileName, mediaType });\n    } else {\n      options = options || {};\n      const namePredicateIri = options.namePredicateIri || VocabPlatform.fileName.value;\n      const mediaTypePredicateIri = options.mediaTypePredicateIri || VocabPlatform.mediaType.value;\n      \n      return this.getFileResourceGraph(resourceIri)\n        .flatMap((graph) => {\n          const triples = graph.triples;\n          const resource: FileResource = {\n            iri: resourceIri,\n            fileName: triples.find((tripple) => {\n              return tripple.p.value === namePredicateIri;\n            }).o.value,\n            mediaType: triples.find((tripple) => {\n              return tripple.p.value === mediaTypePredicateIri;\n            }).o.value,\n          };\n\n          if (resource.fileName && resource.mediaType) {\n            return Kefir.constant<FileResource>(resource);\n          } else {\n            return Kefir.constantError<any>(\n              new Error(`Either 'fileName' or 'mediaType' properties not found in the file resource graph`)\n            );\n          }\n        })\n        .toProperty();\n    }\n  }\n\n  static getFileUrl(fileName: string, storage: string, mode?: string, mediaType?:string): string {\n    return new URI(FILE_UPLOAD_SERVICE_URL)\n      .addQuery({\n        fileName: fileName,\n        storage: storage,\n        mode: mode,\n        mediaType: mediaType,\n      })\n      .toString();\n  }\n\n  static isTemporaryResource(resourceIri: Rdf.Iri): boolean {\n    return TemporaryFileSchema.isEncodedIri(resourceIri);\n  }\n}\n\n// These functions are used by FileInput and FileVisualizer component\n// to store and visualize temporary state of FileInput component\nfunction createTemporaryResource(fileName: string, mediaType: string): FileResource {\n  return {\n    iri: TemporaryFileSchema.encodeAsIri(fileName, mediaType),\n    fileName,\n    mediaType,\n  };\n}\n\n/**\n * Represents temporary file description into an IRI with custom schema.\n * This IRIs are natively supported by FileInput and FileVizualizer components,\n * but should not be persisted anywhere and only stored in-memory.\n */\nnamespace TemporaryFileSchema {\n  const SCHEMA_PREFIX = 'mp-temporary-file:';\n\n  export function isEncodedIri(iri: Rdf.Iri): boolean {\n    return iri.value.startsWith(SCHEMA_PREFIX);\n  }\n\n  export function encodeAsIri(fileName: string, mediaType: string): Rdf.Iri {\n    const encodedMediaType = encodeURIComponent(mediaType);\n    const encodedName = encodeURIComponent(fileName);\n    return Rdf.iri(`${SCHEMA_PREFIX}${encodedMediaType}/${encodedName}`);\n  }\n\n  export function decodeFromIri(encoded: Rdf.Iri): { mediaType: string; fileName: string } {\n    if (!isEncodedIri(encoded)) {\n      throw new Error(`IRI is not an encoded temporary file: ${encoded}`);\n    }\n    const bufferString = encoded.value.substring(SCHEMA_PREFIX.length);\n    const [encodedMediaType, encodedName] = bufferString.split('/');\n    if (!(encodedMediaType && encodedName)) {\n      throw new Error(`Failed to decode temporary file IRI: ${encoded}`);\n    }\n    return {\n      mediaType: decodeURIComponent(encodedMediaType),\n      fileName: decodeURIComponent(encodedName),\n    };\n  }\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nexport * from './ldp-set';\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as maybe from 'data.maybe';\nimport * as Kefir from 'kefir';\nimport { includes } from 'lodash';\nimport * as SparqlJs from 'sparqljs';\n\nimport { Rdf, vocabularies } from 'platform/api/rdf';\nimport { LdpService, LdpServiceContext } from './ldp';\n\nconst { VocabPlatform, rdf, rdfs, sp } = vocabularies;\n\nexport type OperationType = SparqlJs.Query['queryType'] | 'UPDATE';\n\nexport interface Query {\n  label: string;\n  value: string;\n  type: SparqlJs.SparqlQuery['type'] | '';\n  queryType: OperationType | '';\n  structure?: string;\n}\n\nexport class QueryServiceClass extends LdpService {\n  public addItem(query: Query): Kefir.Property<Rdf.Iri> {\n    const graph = this.createGraph(query);\n    const label = query.label;\n\n    return this.addResource(graph, maybe.Just(label));\n  }\n\n  public updateItem(iri: Rdf.Iri, query: Query): Kefir.Property<{}> {\n    const graph = this.createGraph(query);\n\n    return this.update(iri, graph);\n  }\n\n  private createGraph(query: Query): Rdf.Graph {\n    const { label, value, type, queryType } = query;\n    const queryClass = type === 'update' ? sp.Update : sp.Query;\n    const triples = [\n      Rdf.triple(Rdf.iri(''), rdf.type, queryClass),\n      Rdf.triple(Rdf.iri(''), rdf.type, this.getType(type, queryType)),\n      Rdf.triple(Rdf.iri(''), rdfs.label, Rdf.literal(label)),\n      Rdf.triple(Rdf.iri(''), sp.text, value !== undefined ? Rdf.literal(value) : Rdf.literal('')),\n    ];\n\n    if (query.structure) {\n      triples.push(Rdf.triple(Rdf.iri(''), vocabularies.VocabPlatform.searchState, Rdf.literal(query.structure)));\n    }\n\n    return Rdf.graph(triples);\n  }\n\n  private getType(type: string, queryType: string): Rdf.Iri {\n    if (type !== 'update') {\n      switch (queryType) {\n        case 'ASK':\n          return sp.Ask;\n        case 'SELECT':\n          return sp.Select;\n        case 'DESCRIBE':\n          return sp.Describe;\n        case 'CONSTRUCT':\n          return sp.Construct;\n        default:\n          return sp.Select;\n      }\n    } else {\n      return sp.Update;\n    }\n  }\n\n  public getQuery(iri: Rdf.Iri): Kefir.Property<Query> {\n    return this.get(iri).map((graph) => this.parseGraphToQuery(iri, graph));\n  }\n\n  private parseGraphToQuery(iri: Rdf.Iri, graph: Rdf.Graph): Query {\n    const queryTypes = [sp.Ask, sp.Select, sp.Describe, sp.Construct, sp.Update].map((qt) => qt.value);\n    const label = graph.triples.find((t) => t.s.equals(iri) && t.p.equals(rdfs.label)).o.value;\n    const value = graph.triples.find((t) => t.s.equals(iri) && t.p.equals(sp.text)).o.value;\n    const structure = graph.triples.find((t) => t.s.equals(iri) && t.p.equals(vocabularies.VocabPlatform.searchState));\n    const sTypeIRI = graph.triples.find(\n      // there are several types, filter only those which are relevant\n      (t) => t.s.equals(iri) && t.p.equals(rdf.type) && includes(queryTypes, t.o.value)\n    ).o.value;\n\n    const queryType = this.extractTypeFromIri(sTypeIRI).toUpperCase() as OperationType;\n\n    return {\n      label,\n      value,\n      type: queryType === 'UPDATE' ? 'update' : 'query',\n      queryType: queryType,\n      structure: structure ? structure.o.value : undefined,\n    };\n  }\n\n  /**\n   * Return substring after last '#'\n   */\n  private extractTypeFromIri(sTypeIRI: string): string {\n    return /[^#]*$/.exec(sTypeIRI)[0];\n  }\n}\n\nexport const QueryService = function (context?: LdpServiceContext) {\n  return new QueryServiceClass(VocabPlatform.QueryContainer.value, context);\n};\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as Kefir from 'kefir';\nimport * as request from 'platform/api/http';\nimport * as Immutable from 'immutable';\nimport * as Maybe from 'data.maybe';\nimport * as _ from 'lodash';\n\nimport { Rdf } from 'platform/api/rdf';\nimport { SparqlClient, SparqlUtil } from 'platform/api/sparql';\nimport { requestAsProperty } from 'platform/api/async';\n\nconst ENDPOINT = '/rest/repositories';\n\nfunction composeErrorMessage(err): string {\n  return err.message + '. ' + err.response.text;\n}\n\nexport const SparqlRepositoryType = 'researchspace:SPARQLRepository';\nexport const NeptuneRepositoryType = 'researchspace:NeptuneSPARQLRepository';\nexport const Rdf4jRepositoryType = 'openrdf:SailRepository';\nexport const EphedraRepositoryType = 'researchspace:FederationSailRepository';\nexport type RepositoryType =\n  | typeof SparqlRepositoryType\n  | typeof NeptuneRepositoryType\n  | typeof Rdf4jRepositoryType\n  | typeof EphedraRepositoryType;\n\nexport interface RepositoryInfo {\n  id: string;\n  description: string;\n  type: RepositoryType;\n}\n\nexport function getRepositoryConfig(id: string): Kefir.Property<string> {\n  const req = request.get(`${ENDPOINT}/config/${id}`).accept('text/turtle');\n  return fromRequest(req, (err, res) => res.text);\n}\n\nexport function deleteRepositoryConfig(id: string): Kefir.Property<string> {\n  const req = request.delete(`${ENDPOINT}/config/${id}`);\n  return fromRequest(req, (err, res) => res.text);\n}\n\nexport function getRepositoryInfo(id: string): Kefir.Property<RepositoryInfo> {\n  const req = request.get(`${ENDPOINT}/info/${id}`).accept('application/json');\n  return fromRequest(req, (err, res) => res.body);\n}\n\nexport function validateDefault(): Kefir.Property<boolean> {\n  const req = request.get(`${ENDPOINT}/validatedefault`).accept('application/json');\n  return fromRequest(req, (err, res) => (err ? false : res.body.valid));\n}\n\nexport function getRepositoryConfigTemplate(id: string): Kefir.Property<string> {\n  const req = request.get(`${ENDPOINT}/templates/${id}`).accept('text/turtle');\n  return fromRequest(req, (err, res) => res.text);\n}\n\nexport function updateOrAddRepositoryConfig(id: string, turtle: string, validate = false): Kefir.Property<string> {\n  const req = request.post(`${ENDPOINT}/config/${id}`).send(turtle).query({ validate }).type('text/turtle');\n  return fromRequest(req, (err, res) => res.text);\n}\n\nexport function getRepositoryConfigTemplates(): Kefir.Property<string[]> {\n  const req = request.get(`${ENDPOINT}/templates`).type('application/json').accept('application/json');\n  return fromRequest(req, (err, res) => res.body);\n}\n\nexport function getRepositoryStatus(): Kefir.Property<Immutable.Map<string, boolean>> {\n  const req = request.get(ENDPOINT).type('application/json').accept('application/json');\n  return fromRequest(req, (err, res) => res.body).map((status) => Immutable.Map(status));\n}\n\nlet repositories: Kefir.Property<Array<string>>;\nexport function guessResourceRepository(resource: Rdf.Iri): Kefir.Property<Data.Maybe<string>> {\n  return repositories\n    .flatMap((rs) =>\n      Kefir.combine(rs.map((r) => executeGuessQuery(r, resource).map((resp) => [r, resp] as [string, boolean])))\n    )\n    .map((responses) => Maybe.fromNullable(_.find(responses, ([_, resp]) => resp)).map(([repo, _]) => repo))\n    .toProperty();\n}\n\nconst GUESS_QUERY = SparqlUtil.Sparql`ASK { ?__value__ a ?type }`;\nfunction executeGuessQuery(repository: string, resource: Rdf.Iri): Kefir.Property<boolean> {\n  return SparqlClient.ask(SparqlClient.setBindings(GUESS_QUERY, { __value__: resource }), {\n    context: { repository: repository },\n  });\n}\n\nfunction fromRequest<T>(\n  request: request.SuperAgentRequest,\n  getValue: (err: any, res: request.Response) => T\n): Kefir.Property<T> {\n  return Kefir.fromNodeCallback<T>((cb) =>\n    request.end((err, res) => {\n      cb(err ? composeErrorMessage(err) : null, getValue(err, res));\n    })\n  ).toProperty();\n}\n\nclass DefaultRepositoryInfoClass {\n  private isValid: boolean;\n\n  public init = () => {\n    repositories = getRepositoryStatus().map((rs) => rs.keySeq().toArray());\n    return validateDefault().onValue((v) => (this.isValid = v));\n  };\n\n  public isValidDefault = () => {\n    return this.isValid;\n  };\n}\n\nexport const DefaultRepositoryInfo = new DefaultRepositoryInfoClass();\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as JsonLd from 'jsonld';\nimport * as Kefir from 'kefir';\nimport * as N3 from 'n3';\n\nimport * as Rdf from '../core/Rdf';\n\nregisterTtlParser();\nregisterGraphParser();\n\nexport interface LoaderOptions {\n  /** @default false */\n  fetchRemoteContexts?: boolean;\n  overrideContexts?: {\n    [contextIri: string]: object;\n  };\n}\n\nconst NODE_DOCUMENT_LOADER = JsonLd.documentLoaders.node();\n\nexport function makeDocumentLoader(options: LoaderOptions): JsonLd.DocumentLoader {\n  return (url, callback) => {\n    if (options.overrideContexts && url in options.overrideContexts) {\n      return callback(null, {\n        // this is for a context via a link header\n        contextUrl: null,\n        // this is the actual document that was loaded\n        document: options.overrideContexts[url],\n        // this is the actual context URL after redirects\n        documentUrl: url,\n      });\n    }\n\n    if (options.fetchRemoteContexts) {\n      return NODE_DOCUMENT_LOADER(url, callback);\n    } else {\n      callback(new Error(`Fetching remote JSON-LD contexts is not allowed`), null);\n    }\n  };\n}\n\nexport function compact(\n  input: object,\n  ctx: object | string,\n  options: JsonLd.CompactOptions & { documentLoader: JsonLd.DocumentLoader }\n): Kefir.Property<any> {\n  return Kefir.fromNodeCallback((callback) => JsonLd.compact(input, ctx, options, callback)).toProperty();\n}\n\nexport function frame(\n  input: object | string,\n  frame: object,\n  options: JsonLd.FrameOptions & { documentLoader: JsonLd.DocumentLoader }\n): Kefir.Property<any> {\n  return Kefir.fromNodeCallback((callback) => JsonLd.frame(input, frame, options, callback)).toProperty();\n}\n\nexport function fromRdf(\n  dataset: object | string,\n  options: JsonLd.FromRdfOptions & { documentLoader: JsonLd.DocumentLoader }\n): Kefir.Property<any> {\n  return Kefir.fromNodeCallback((callback) => JsonLd.fromRDF(dataset, options, callback)).toProperty();\n}\n\nfunction registerTtlParser() {\n  JsonLd.registerRDFParser('text/turtle', (input, callback) => {\n    const quads: JsonLd.Quad[] = [];\n    N3.Parser().parse(input, (error, triple, hash) => {\n      if (error) {\n        callback(error, quads);\n      } else if (triple) {\n        const quad = createJsonLdQuad(triple);\n        quads.push(quad);\n      } else if (callback) {\n        callback(undefined, quads);\n      }\n    });\n  });\n}\n\n/**\n * Registers parser from Rdf.Graph to json-ld with 'mph/graph' MIME-type.\n */\nfunction registerGraphParser() {\n  JsonLd.registerRDFParser('mph/graph', (input, callback) => {\n    const inputGraph = input as Rdf.Graph;\n    const quads = inputGraph.triples.forEach((triple) => ({\n      subject: getTerm(triple.s),\n      predicate: getTerm(triple.p),\n      object: getTerm(triple.o),\n      graph: {\n        termType: 'DefaultGraph',\n        value: '',\n      },\n    }));\n    function getTerm(term: Rdf.Node): JsonLd.Term {\n      if (term.isLiteral()) {\n        return {\n          termType: 'Literal',\n          value: term.value,\n          language: term.language,\n          datatype: {\n            termType: 'NamedNode',\n            value: term.datatype.value,\n          },\n        };\n      } else if (term.isBnode()) {\n        return {\n          termType: 'BlankNode',\n          value: term.value,\n        };\n      } else if (term.isIri()) {\n        return {\n          termType: 'NamedNode',\n          value: term.value,\n        };\n      }\n    }\n    return quads;\n  });\n}\n\nfunction createJsonLdQuad(triple: N3.Triple): JsonLd.Quad {\n  return {\n    subject: getTerm(triple.subject),\n    predicate: getTerm(triple.predicate),\n    object: getTerm(triple.object),\n    graph: {\n      termType: 'DefaultGraph',\n      value: '',\n    },\n  };\n\n  function getTerm(value: string): JsonLd.Term {\n    if (N3.Util.isLiteral(value)) {\n      return getLiteralTerm(value);\n    } else if (N3.Util.isBlank(value)) {\n      return {\n        termType: 'BlankNode',\n        value: value,\n      };\n    } else {\n      return {\n        termType: 'NamedNode',\n        value: value,\n      };\n    }\n  }\n\n  function getLiteralTerm(literal: string): JsonLd.Term {\n    return {\n      termType: 'Literal',\n      value: N3.Util.getLiteralValue(literal),\n      language: N3.Util.getLiteralLanguage(literal),\n      datatype: {\n        termType: 'NamedNode',\n        value: N3.Util.getLiteralType(literal),\n      },\n    };\n  }\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { Rdf } from 'platform/api/rdf';\nimport { QueryContext } from 'platform/api/sparql';\n\nimport { BaseResourceService } from './BaseResourceService';\n\nconst THUMBNAIL_SERVICE_URL = `/rest/data/rdf/utils/thumbnails/default`;\nconst service = new BaseResourceService(THUMBNAIL_SERVICE_URL);\n\nexport function getThumbnail(iri: Rdf.Iri, options?: { context?: QueryContext }) {\n  return service.getResource(iri, options ? options.context : undefined);\n}\n\nexport function getThumbnails(iris: ReadonlyArray<Rdf.Iri>, options?: { context?: QueryContext }) {\n  return service.getResources(iris, options ? options.context : undefined);\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as _ from 'lodash';\nimport { Just, Nothing } from 'data.maybe';\nimport * as Kefir from 'kefir';\n\nimport { requestAsProperty } from 'platform/api/async';\nimport * as request from 'platform/api/http';\nimport { Rdf, vocabularies } from 'platform/api/rdf';\n\nimport { LdpService } from 'platform/api/services/ldp';\nimport { getLabels } from 'platform/api/services/resource-label';\n\nconst { sp, field, rdfs, VocabPlatform } = vocabularies;\n\nimport {\n  FieldDefinition,\n  FieldDefinitionProp,\n  normalizeFieldDefinition,\n} from 'platform/components/forms/FieldDefinition';\n\nexport function getFieldDefinitionProp(fieldIri: Rdf.Iri): Kefir.Property<FieldDefinitionProp> {\n  const ldp = new LdpService(vocabularies.VocabPlatform.FieldDefinitionContainer.value);\n  return ldp.get(fieldIri).map((graph) => deserialize(fieldIri, graph));\n}\n\nexport function getFieldDefinition(fieldIri: Rdf.Iri): Kefir.Property<FieldDefinition> {\n  return getFieldDefinitionProp(fieldIri).map(normalizeFieldDefinition);\n}\n\nfunction deserialize(fieldIri: Rdf.Iri, graph: Rdf.Graph): FieldDefinitionProp {\n  const predicates = {\n    description: [rdfs.comment],\n    xsdDatatype: [field.xsd_datatype],\n    minOccurs: [field.min_occurs],\n    maxOccurs: [field.max_occurs],\n    order: [field.order],\n    selectPattern: [field.select_pattern, sp.text],\n    deletePattern: [field.delete_pattern, sp.text],\n    askPattern: [field.ask_pattern, sp.text],\n    valueSetPattern: [field.valueset_pattern, sp.text],\n    autosuggestionPattern: [field.autosuggestion_pattern, sp.text],\n    testSubject: [field.testsubject],\n    insertPattern: [field.insert_pattern, sp.text],\n  };\n\n  const pg = Rdf.pg(fieldIri, graph);\n  // TODO can we iterate over object values and don't loose type information for keys here?\n  // after this transformation we get {[key: string]: string} which is not perfect\n  const partialField = _.mapValues(predicates, (propertyPath) =>\n    Rdf.getValueFromPropertyPath(propertyPath, pg)\n      .map((n) => n.value)\n      .getOrElse(undefined)\n  );\n\n  const label = Rdf.getValuesFromPropertyPath([rdfs.label], pg).map((v) => v as Rdf.Literal);\n  const domain = Rdf.getValuesFromPropertyPath([field.domain], pg).map((v) => v.value);\n  const range = Rdf.getValuesFromPropertyPath([field.range], pg).map((v) => v.value);\n  const defaultValues = Rdf.getValuesFromPropertyPath([field.default_value], pg).map((v) => v.value);\n  const categories = Rdf.getValuesFromPropertyPath<Rdf.Iri>([field.category], pg);\n  const treePatterns = Rdf.getValueFromPropertyPath([field.tree_patterns], pg)\n    .chain((config) => {\n      if (!(config.isLiteral() && config.datatype.equals(VocabPlatform.SyntheticJsonDatatype))) {\n        return Nothing();\n      }\n      try {\n        return Just(JSON.parse(config.value));\n      } catch (e) {\n        return Nothing();\n      }\n    })\n    .getOrElse(undefined);\n\n  return {\n    id: fieldIri.value,\n    label,\n    ...partialField,\n    categories,\n    domain,\n    range,\n    defaultValues,\n    treePatterns,\n  } as FieldDefinitionProp;\n}\n\nconst FIELDS_REST_PATH = '/rest/fields/definitions';\n\nexport function getGeneratedFieldDefinitions(iris: ReadonlyArray<Rdf.Iri>): Kefir.Property<FieldDefinitionProp[]> {\n  if (iris.length === 0) {\n    return Kefir.constant([]);\n  }\n  const req = request\n    .post(FIELDS_REST_PATH)\n    .send({\n      fields: iris.map((iri) => iri.value),\n    })\n    .type('application/json')\n    .accept('application/json');\n\n  return requestAsProperty(req)\n    .map((res) => JSON.parse(res.text) as FieldDefinitionProp[])\n    .flatMap((fields) => {\n      return getLabels(\n        fields.filter((f) => f.label === undefined || f.label === null).map((f) => Rdf.iri(f.iri)),\n        { context: {} }\n      ).map((labels) => {\n        return fields.map((f) => ({\n          ...f,\n          label: labels.get(Rdf.iri(f.iri)),\n        }));\n      });\n    })\n    .toProperty();\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as request from 'platform/api/http';\nimport * as Kefir from 'kefir';\nimport * as fileSaver from 'file-saver';\n\nimport { Rdf, turtle } from 'platform/api/rdf';\nimport { SparqlUtil } from 'platform/api/sparql';\n\nexport const GRAPH_STORE_SERVICEURL = '/rdf-graph-store';\n\nclass GraphStoreService {\n  public createGraph({\n    targetGraph,\n    graphData,\n    repository,\n  }: {\n    targetGraph: Rdf.Iri;\n    graphData: Rdf.Graph;\n    repository?: string;\n  }): Kefir.Property<Rdf.Iri> {\n    return turtle.serialize\n      .serializeGraph(graphData)\n      .flatMap((turtleString: string) => this.createGraphRequest({ targetGraph, turtleString, repository }))\n      .map((location) => Rdf.iri(<string>location))\n      .toProperty();\n  }\n\n  private createGraphRequest({\n    targetGraph,\n    turtleString,\n    repository,\n  }: {\n    targetGraph: Rdf.Iri;\n    turtleString: string;\n    repository?: string;\n  }): Kefir.Property<string> {\n    const req = request\n      .post(GRAPH_STORE_SERVICEURL)\n      .query({ graph: targetGraph.value, repository: repository })\n      .send(turtleString)\n      .type('text/turtle');\n\n    return Kefir.fromNodeCallback<string>((cb) =>\n      req.end((err, res) => cb(err, res ? res.header['location'] : null))\n    ).toProperty();\n  }\n\n  public updateGraph({\n    targetGraph,\n    graphData,\n    repository,\n  }: {\n    targetGraph: Rdf.Iri;\n    graphData: Rdf.Graph;\n    repository?: string;\n  }): Kefir.Property<Rdf.Iri> {\n    return turtle.serialize\n      .serializeGraph(graphData)\n      .flatMap((turtleString: string) => this.createGraphRequest({ targetGraph, turtleString, repository }))\n      .map((location) => Rdf.iri(<string>location))\n      .toProperty();\n  }\n\n  public updateGraphRequest({\n    targetGraph,\n    turtleString,\n    repository,\n  }: {\n    targetGraph: Rdf.Iri;\n    turtleString: string;\n    repository?: string;\n  }): Kefir.Property<string> {\n    const req = request\n      .put(GRAPH_STORE_SERVICEURL)\n      .query({ uri: targetGraph.value, repository: repository })\n      .send(turtleString)\n      .type('text/turtle');\n\n    return Kefir.fromNodeCallback<string>((cb) =>\n      req.end((err, res) => cb(err, res ? res.header['location'] : null))\n    ).toProperty();\n  }\n\n  public createGraphFromFile({\n    targetGraph,\n    keepSourceGraphs,\n    file,\n    contentType,\n    onProgress,\n    repository,\n  }: {\n    targetGraph: Rdf.Iri;\n    keepSourceGraphs: boolean;\n    file: File;\n    contentType: string;\n    onProgress: (percent: number) => void;\n    repository?: string;\n  }): Kefir.Property<boolean> {\n    const req = request\n      .post(GRAPH_STORE_SERVICEURL)\n      .query({\n        graph: targetGraph.value,\n        keepSourceGraphs: keepSourceGraphs,\n        repository: repository,\n      })\n      .type(contentType)\n      .send(file)\n      .on('progress', (e) => onProgress(<number>e.percent));\n\n    return Kefir.fromNodeCallback<boolean>((cb) =>\n      req.end((err, res: request.Response) => {\n        cb(err, res.ok ? true : null);\n      })\n    ).toProperty();\n  }\n\n  public updateGraphFromFile({\n    targetGraph,\n    file,\n    contentType,\n    onProgress,\n    repository,\n  }: {\n    targetGraph: Rdf.Iri;\n    file: File;\n    contentType: string;\n    onProgress: (percent: number) => void;\n    repository?: string;\n  }): Kefir.Property<boolean> {\n    const req = request\n      .put(GRAPH_STORE_SERVICEURL)\n      .query({ graph: targetGraph.value, repository: repository })\n      .type(contentType)\n      .send(file)\n      .on('progress', (e) => onProgress(<number>e.percent));\n\n    return Kefir.fromNodeCallback<boolean>((cb) =>\n      req.end((err, res: request.Response) => {\n        cb(err, res.ok ? true : null);\n      })\n    ).toProperty();\n  }\n\n  getGraph({ targetGraph, repository }: { targetGraph: Rdf.Iri; repository?: string }): Kefir.Property<Rdf.Graph> {\n    const req = request\n      .get(GRAPH_STORE_SERVICEURL)\n      .query({ graph: targetGraph.value, repository: repository })\n      .accept('text/turtle');\n\n    return Kefir.fromNodeCallback<Rdf.Graph>((cb) =>\n      req.end((err, res: request.Response) => {\n        cb(this.errorToString(err), res.ok ? turtle.deserialize.turtleToGraph(res.text) : null);\n      })\n    ).toProperty();\n  }\n\n  public deleteGraph({\n    targetGraph,\n    repository,\n  }: {\n    targetGraph: Rdf.Iri;\n    repository?: string;\n  }): Kefir.Property<boolean> {\n    const req = request.del(GRAPH_STORE_SERVICEURL).query({ graph: targetGraph.value, repository: repository });\n\n    return Kefir.fromNodeCallback<boolean>((cb) =>\n      req.end((err, res: request.Response) => {\n        cb(this.errorToString(err), res.ok ? true : null);\n      })\n    ).toProperty();\n  }\n\n  public downloadGraph({\n    targetGraph,\n    acceptHeader,\n    fileName,\n    repository,\n  }: {\n    targetGraph: Rdf.Iri;\n    acceptHeader: SparqlUtil.ResultFormat;\n    fileName: string;\n    repository?: string;\n  }): Kefir.Property<boolean> {\n    const req = request\n      .get(GRAPH_STORE_SERVICEURL)\n      .query({ graph: targetGraph.value, repository: repository })\n      .accept(acceptHeader);\n\n    return Kefir.fromNodeCallback<boolean>((cb) =>\n      req.end((err, res: request.Response) => {\n        cb(this.errorToString(err), res.ok ? this.download(res.text, acceptHeader, fileName) : false);\n      })\n    ).toProperty();\n  }\n\n  private download(response, header, filename): boolean {\n    let blob = new Blob([response], { type: header });\n    fileSaver.saveAs(blob, filename);\n    return true;\n  }\n\n  private errorToString(err: any): string {\n    if (err !== null) {\n      const status = err['status'];\n      if (413 === status) {\n        return 'File too large. Please contact your administrator.';\n      } else {\n        return err.response.text;\n      }\n    }\n\n    return null;\n  }\n}\n\nexport const RDFGraphStoreService = new GraphStoreService();\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as request from 'platform/api/http';\nimport * as Kefir from 'kefir';\n\nimport { Rdf } from 'platform/api/rdf';\n\nexport const FILEUPLOAD_SERVICEURL = '/file-upload';\n\nclass FileUpload {\n  public uploadFile(options: {\n    createResourceQuery: string;\n    generateIdQuery: string;\n    storage: string;\n    metadataExtractor: string;\n    contextUri: string;\n    file: File;\n    contentType: string;\n    onProgress: (percent: number) => void;\n  }): Kefir.Property<Rdf.Iri> {\n    const req = request\n      .post(FILEUPLOAD_SERVICEURL)\n      .field('createResourceQuery', options.createResourceQuery)\n      .field('generateIdQuery', options.generateIdQuery)\n      .field('storage', options.storage)\n      .field('metadataExtractor', options.metadataExtractor || '')\n      .field('contextUri', options.contextUri)\n      // .type(options.contentType)\n      .attach('image', options.file as any)\n      .on('progress', (e) => options.onProgress(<number>e.percent));\n    return Kefir.fromNodeCallback<Rdf.Iri>((cb) =>\n      req.end((err, res: request.Response) => {\n        cb(err != null ? err.message : null, res.ok ? Rdf.iri(res.header['location']) : null);\n      })\n    ).toProperty();\n  }\n\n  public getMimeType(file: File): string {\n    const fileEnding = file.name.split('.').pop().toLowerCase().trim();\n    switch (fileEnding) {\n      case 'jpg':\n        return 'image/jpeg';\n      default:\n        return 'application/octet-stream';\n    }\n  }\n}\n\nexport const FileUploadService = new FileUpload();\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as request from 'platform/api/http';\nimport * as Kefir from 'kefir';\n\nimport { Rdf } from 'platform/api/rdf';\n\nconst POST_INVALIDATE_ALL = '/rest/cache/all/invalidate';\n\n/**\n * Invalidate all caches.\n */\nexport function invalidateAllCaches() {\n  return sendRequest(POST_INVALIDATE_ALL);\n}\n\n/**\n * Invalidate all caches for the specific resource.\n */\nexport function invalidateCacheForResource(resource: Rdf.Iri) {\n  const url = POST_INVALIDATE_ALL + '/' + encodeURIComponent(resource.value);\n  return sendRequest(url);\n}\n\nfunction sendRequest(url: string): Kefir.Property<string> {\n  const req = request.post(url);\n  return Kefir.fromNodeCallback<string>((cb) => req.end((err, res) => cb(err, res.text))).toProperty();\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as maybe from 'data.maybe';\nimport * as Kefir from 'kefir';\n\nimport { Rdf, vocabularies } from 'platform/api/rdf';\nimport { Template, Argument } from 'platform/components/query-editor';\nimport { LdpService, LdpServiceContext } from './ldp';\nimport { includes } from 'lodash';\n\nconst { VocabPlatform, xsd, rdf, rdfs, spl, spin, dct } = vocabularies;\n\nconst DEFAULT_NAMESPACE = 'http://www.researchspace.org/query/';\nconst CATEGORIES_PREDICATE = dct.subject;\n\nexport class QueryTemplateServiceClass extends LdpService {\n  public addItem(template: Template, queryIri: string, namespace: string): Kefir.Property<{}> {\n    const graph = this.createGraph(template, queryIri, namespace);\n    return this.addResource(graph, maybe.Just(template.identifier));\n  }\n\n  public updateItem(iri: Rdf.Iri, template: Template, queryIri: string, namespace: string): Kefir.Property<{}> {\n    const graph = this.createGraph(template, queryIri, namespace);\n\n    return this.update(iri, graph);\n  }\n\n  private createGraph(template: Template, queryIri: string, namespace = DEFAULT_NAMESPACE): Rdf.Graph {\n    const { identifier, label, description, args } = template;\n    const subject = Rdf.iri('');\n\n    const argsTriples = args.map((arg, index) => {\n      const argIri = Rdf.iri(namespace + identifier + '/arg/' + index);\n\n      const triples = [\n        Rdf.triple(subject, spin.constraintProp, argIri),\n        Rdf.triple(argIri, rdf.type, spl.Argument),\n        Rdf.triple(argIri, rdfs.label, Rdf.literal(arg.label)),\n        Rdf.triple(argIri, spl.predicateProp, Rdf.iri(namespace + identifier + '/predicate/' + arg.variable)),\n        Rdf.triple(argIri, spl.valueTypeProp, Rdf.iri(arg.valueType)),\n      ];\n\n      if (arg.defaultValue) {\n        triples.push(Rdf.triple(argIri, spl.defaultValue, arg.defaultValue));\n      }\n\n      // serialize default to false i.e. by default values should not be optional\n      const optional = arg.optional !== undefined ? arg.optional : false;\n      triples.push(Rdf.triple(argIri, spl.optionalProp, Rdf.literal(optional, xsd.boolean)));\n\n      if (arg.comment !== undefined) {\n        triples.push(Rdf.triple(argIri, rdfs.comment, Rdf.literal(arg.comment)));\n      }\n      return triples;\n    });\n\n    const mergedArgsTriples: Rdf.Triple[] = [].concat.apply([], argsTriples);\n    const categories = template.categories.map((category) => Rdf.triple(subject, CATEGORIES_PREDICATE, category));\n\n    return Rdf.graph([\n      Rdf.triple(subject, rdf.type, spin.Template),\n      Rdf.triple(subject, rdf.type, template.templateType),\n      Rdf.triple(subject, rdfs.label, Rdf.literal(label)),\n      Rdf.triple(subject, rdfs.comment, Rdf.literal(description)),\n      Rdf.triple(subject, spin.bodyProp, Rdf.iri(queryIri)),\n      ...mergedArgsTriples,\n      ...categories,\n    ]);\n  }\n\n  public getQueryTemplate(iri: Rdf.Iri): Kefir.Property<{ template: Template; queryIri: string }> {\n    return this.get(iri).map((graph) => this.parseGraphToQueryTemplate(iri, graph));\n  }\n\n  private parseGraphToQueryTemplate(iri: Rdf.Iri, graph: Rdf.Graph): { template: Template; queryIri: string } {\n    const templateTypes = [spin.AskTemplate, spin.SelectTemplate, spin.ConstructTemplate, spin.UpdateTemplate].map(\n      (qt) => qt.value\n    );\n    const templateType = graph.triples.find((t) => t.p.equals(rdf.type) && includes(templateTypes, t.o.value))\n      .o as Rdf.Iri;\n\n    const argsIris = graph.triples\n      .filter((t) => t.s.equals(iri) && t.p.equals(spin.constraintProp))\n      .toArray()\n      .map((item) => item.o);\n\n    const args = argsIris.map(\n      (item): Argument => {\n        const label = graph.triples.find((t) => t.s.equals(item) && t.p.equals(rdfs.label)).o.value;\n        const variable = graph.triples.find((t) => t.s.equals(item) && t.p.equals(spl.predicateProp)).o.value;\n        const comment = graph.triples.find((t) => t.s.equals(item) && t.p.equals(rdfs.comment)).o.value;\n        const optional = graph.triples.find((t) => t.s.equals(item) && t.p.equals(spl.optionalProp));\n        const valueType = graph.triples.find((t) => t.s.equals(item) && t.p.equals(spl.valueTypeProp)).o.value;\n        const defaultValue = graph.triples.find((t) => t.s.equals(item) && t.p.equals(spl.defaultValue));\n\n        return {\n          label: label,\n          variable: this.extractValueFromIri(variable),\n          comment: comment,\n          valueType: valueType,\n          defaultValue: defaultValue ? defaultValue.o : undefined,\n          optional: optional ? optional.o.value === 'true' : false,\n        };\n      }\n    );\n\n    const template: Template = {\n      templateType: templateType,\n      identifier: this.extractValueFromIri(iri.value),\n      label: graph.triples.find((t) => t.s.equals(iri) && t.p.equals(rdfs.label)).o.value,\n      description: graph.triples.find((t) => t.s.equals(iri) && t.p.equals(rdfs.comment)).o.value,\n      categories: graph.triples\n        .filter((t) => t.s.equals(iri) && t.p.equals(CATEGORIES_PREDICATE) && t.o.isIri())\n        .map((t) => t.o as Rdf.Iri)\n        .toArray(),\n      args: args,\n    };\n\n    const queryIri = graph.triples.find((t) => t.s.equals(iri) && t.p.equals(spin.bodyProp)).o.value;\n\n    return { template, queryIri };\n  }\n\n  /**\n   * Return substring after last '/'\n   */\n  private extractValueFromIri(iri: string): string {\n    return /[^/]*$/.exec(iri)[0];\n  }\n}\n\nexport const QueryTemplateService = function (context: LdpServiceContext) {\n  return new QueryTemplateServiceClass(VocabPlatform.QueryTemplateContainer.value, context);\n};\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as Kefir from 'kefir';\nimport * as uuid from 'uuid';\nimport * as Maybe from 'data.maybe';\nimport * as moment from 'moment';\n\nimport { Rdf } from 'platform/api/rdf';\nimport { VocabPlatform, workflow as VocabWorkflow, rdf, xsd, sp } from 'platform/api/rdf/vocabularies';\nimport { LdpService } from 'platform/api/services/ldp';\nimport { SparqlClient } from 'platform/api/sparql';\nimport { getLabels } from 'platform/api/services/resource-label';\nimport { Util as SecurityUtil } from 'platform/api/services/security';\nimport { parseQuerySync } from 'platform/api/sparql/SparqlUtil';\n\nconst ASSIGNEE_VARIABLE = 'assignee';\nconst NEW_STEP_VARIABLE = '__newStep__';\nconst WORKFLOW_INSTANTIATION_VARIABLE = '__workflowInstantiation__';\n\nexport interface WorkflowState {\n  step: Rdf.Iri | undefined;\n  assignee: Rdf.Iri | undefined;\n}\nexport namespace WorkflowState {\n  export const empty: WorkflowState = { step: undefined, assignee: undefined };\n\n  export function isEqual(a: WorkflowState, b: WorkflowState): boolean {\n    return (\n      ((a.step && a.step.equals(b.step)) || (!a.step && !b.step)) &&\n      ((a.assignee && a.assignee.equals(b.assignee)) || (!a.assignee && !b.assignee))\n    );\n  }\n}\n\nexport interface WorkflowStep {\n  iri: Rdf.Iri;\n  label: string;\n  /**\n   * SPARQL Select query returns possible assignees.\n   * Expected projection variables:\n   *    * '?assignee' - possible assignees\n   * Injected variables:\n   *    * '?__newStep__' - new step IRI\n   *    * '?__workflowInstantiation__' - workflow instantiation IRI\n   */\n  assigneeQuery?: string;\n}\n\nexport interface WorkflowAssignee {\n  iri: Rdf.Iri;\n  label: string;\n}\n\nexport interface WorkflowData {\n  subject: Rdf.Iri;\n  definition: Rdf.Iri;\n  firstStep: Rdf.Iri;\n  metadataQuery?: string;\n  assignee?: Rdf.Iri;\n  newWorkflowIriTemplate?: string;\n}\n\nexport class WorkflowService {\n  private ldpService: LdpService;\n  constructor() {\n    this.ldpService = new LdpService(VocabPlatform.WorkflowContainer.value, { repository: 'default' });\n  }\n\n  queryWorkflowInstantiation(workflow: string): Kefir.Property<Rdf.Graph> {\n    return this.ldpService.get(Rdf.iri(workflow));\n  }\n\n  queryWorkflowSteps({\n    definition,\n    currentStep,\n  }: {\n    definition: string;\n    currentStep?: Rdf.Iri;\n  }): Kefir.Property<Array<WorkflowStep>> {\n    const ldpAssetsService = new LdpService(VocabPlatform.WorkflowContainer.value, { repository: 'assets' });\n    const definitionIri = Rdf.iri(definition);\n    return ldpAssetsService\n      .get(definitionIri)\n      .flatMap((g) => {\n        let steps: Array<Rdf.Iri>;\n        if (currentStep) {\n          steps = Rdf.getValuesFromPropertyPath<Rdf.Iri>([VocabWorkflow.nextStep], Rdf.pg(currentStep, g));\n          steps.push(currentStep);\n        } else {\n          steps = Rdf.getValuesFromPropertyPath<Rdf.Iri>([VocabWorkflow.hasStep], Rdf.pg(definitionIri, g));\n        }\n\n        return getLabels(steps, { context: { repository: 'assets' } }).map((labels) =>\n          steps.map((step) => {\n            const label = labels.get(step);\n            const assigneeQuery = Rdf.getValueFromPropertyPath<Rdf.Iri>(\n              [VocabWorkflow.assigneeQuery, sp.text],\n              Rdf.pg(step, g)\n            )\n              .map((v) => v.value)\n              .getOrElse(undefined);\n            return { iri: step, assigneeQuery, label } as WorkflowStep;\n          })\n        );\n      })\n      .toProperty();\n  }\n\n  queryWorkflowAssignees({\n    query,\n    newStep,\n    workflowInstantiations,\n  }: {\n    query: string;\n    newStep: Rdf.Iri;\n    workflowInstantiations: Array<Rdf.Iri>;\n  }): Kefir.Property<Array<WorkflowAssignee>> {\n    const values = workflowInstantiations.map((iri) => ({\n      [WORKFLOW_INSTANTIATION_VARIABLE]: iri,\n    }));\n    return SparqlClient.prepareQuery(query, values)\n      .map((parsedQuery) => SparqlClient.setBindings(parsedQuery, { [NEW_STEP_VARIABLE]: newStep }))\n      .flatMap((parsedQuery) => SparqlClient.select(parsedQuery))\n      .flatMap(({ results }) => {\n        const assignees = results.bindings.map((binding) => {\n          return binding[ASSIGNEE_VARIABLE] as Rdf.Iri;\n        });\n        return getLabels(assignees);\n      })\n      .map((labels) => {\n        const assignees: Array<WorkflowAssignee> = [];\n        labels.forEach((label, iri) => assignees.push({ iri, label } as WorkflowAssignee));\n        return assignees;\n      })\n      .toProperty();\n  }\n\n  private generateSubjectByTemplate(template: string | undefined): string {\n    const iriTemplate = template || '{{UUID}}';\n    const subject = iriTemplate.replace(/{{([^{}]+)}}/g, (match, placeholder) => {\n      if (placeholder === 'UUID') {\n        return uuid.v4();\n      } else {\n        return '';\n      }\n    });\n    return subject;\n  }\n\n  createWorkflowInstantiation(workflowData: WorkflowData): Kefir.Property<Rdf.Iri> {\n    const ldpAssetsService = new LdpService(VocabPlatform.WorkflowContainer.value, { repository: 'assets' });\n    return ldpAssetsService\n      .get(workflowData.definition)\n      .flatMap((graph) => {\n        try {\n          const steps = Rdf.getValuesFromPropertyPath<Rdf.Iri>(\n            [VocabWorkflow.hasStep],\n            Rdf.pg(workflowData.definition, graph)\n          );\n          const firstStep = steps.find((step) => step.value === workflowData.firstStep.value);\n          if (!firstStep) {\n            throw new Error(`Unknown step ${workflowData.firstStep}, no equals with definition's steps`);\n          }\n          const subjectIri = this.generateSubjectByTemplate(workflowData.newWorkflowIriTemplate);\n          const subject = Rdf.iri('');\n          const workflowStateIri = Rdf.iri(`${VocabWorkflow.hasState.value}-${uuid.v4()}`);\n          const workflowMetadataIri = Rdf.iri(`${VocabWorkflow.metadata.value}-${uuid.v4()}`);\n          const timeLiteral = Rdf.literal(moment().toISOString(), xsd.dateTime);\n          const triples: Array<Rdf.Triple> = [\n            Rdf.triple(subject, rdf.type, VocabWorkflow.WorkflowInstantiation),\n            Rdf.triple(subject, VocabWorkflow.subject, workflowData.subject),\n            Rdf.triple(subject, VocabWorkflow.hasState, workflowStateIri),\n            Rdf.triple(subject, VocabWorkflow.currentState, workflowStateIri),\n            Rdf.triple(workflowStateIri, rdf.type, VocabWorkflow.WorkflowState),\n            Rdf.triple(workflowStateIri, VocabWorkflow.step, firstStep),\n            Rdf.triple(workflowStateIri, VocabWorkflow.startTime, timeLiteral),\n          ];\n          if (workflowData.assignee.value) {\n            triples.push(Rdf.triple(workflowStateIri, VocabWorkflow.assignee, workflowData.assignee));\n          }\n          return this.createMetadata(workflowData.metadataQuery, workflowMetadataIri).flatMap((metadataGraph) => {\n            if (metadataGraph.length !== 0) {\n              triples.push(Rdf.triple(subject, VocabWorkflow.metadata, workflowMetadataIri));\n              metadataGraph.forEach((item) => {\n                triples.push(Rdf.triple(item.s, item.p, item.o));\n              });\n            }\n            const workflowGraph = Rdf.graph(triples);\n            return this.ldpService.addResource(workflowGraph, Maybe.Just(subjectIri));\n          });\n        } catch (error) {\n          return Kefir.constantError(error);\n        }\n      })\n      .toProperty();\n  }\n\n  createMetadata(metadataQuery: string, metadataIri: Rdf.Iri): Kefir.Property<Rdf.Triple[]> {\n    if (!metadataQuery) {\n      return Kefir.constant([]);\n    }\n    let query = parseQuerySync(metadataQuery);\n    query = SparqlClient.setBindings(query, {\n      metadataIri,\n    });\n    return SparqlClient.construct(query);\n  }\n\n  updateWorkflowInstantiation({\n    workflowIri,\n    originalGraph,\n    workflowState,\n  }: {\n    workflowIri: Rdf.Iri;\n    originalGraph: Rdf.Graph;\n    workflowState: WorkflowState;\n  }): Kefir.Property<Rdf.Iri> {\n    return Kefir.fromPromise(SecurityUtil.getUser())\n      .flatMap((user) => {\n        const workflowStateIri = Rdf.iri(`${workflowIri.value}/${uuid.v4()}`);\n        const timeLiteral = Rdf.literal(moment().toISOString(), xsd.dateTime);\n        const triples: Array<Rdf.Triple> = [];\n        Rdf.getValueFromPropertyPath<Rdf.Iri>(\n          [VocabWorkflow.currentState],\n          Rdf.pg(workflowIri, originalGraph)\n        ).map((currentState) =>\n          triples.push(\n            Rdf.triple(currentState, VocabWorkflow.endTime, timeLiteral),\n            Rdf.triple(currentState, VocabWorkflow.advancedBy, Rdf.iri(user.userURI))\n          )\n        );\n        triples.push(\n          Rdf.triple(workflowIri, VocabWorkflow.hasState, workflowStateIri),\n          Rdf.triple(workflowIri, VocabWorkflow.currentState, workflowStateIri),\n          Rdf.triple(workflowStateIri, rdf.type, VocabWorkflow.WorkflowState),\n          Rdf.triple(workflowStateIri, VocabWorkflow.step, workflowState.step),\n          Rdf.triple(workflowStateIri, VocabWorkflow.startTime, timeLiteral)\n        );\n        if (workflowState.assignee) {\n          triples.push(Rdf.triple(workflowStateIri, VocabWorkflow.assignee, workflowState.assignee));\n        }\n        originalGraph.triples.forEach((t) => {\n          if (!t.p.equals(VocabWorkflow.currentState)) {\n            triples.push(t);\n          }\n        });\n        const workflowGraph = Rdf.graph(triples);\n        return this.ldpService.update(workflowIri, workflowGraph);\n      })\n      .toProperty();\n  }\n\n  deserializeWorkflowState(workflowIri: Rdf.Iri, workflowGraph: Rdf.Graph): WorkflowState {\n    return Rdf.getValueFromPropertyPath<Rdf.Iri>([VocabWorkflow.currentState], Rdf.pg(workflowIri, workflowGraph))\n      .map((currentState) => {\n        const pg = Rdf.pg(currentState, workflowGraph);\n        const step = Rdf.getValueFromPropertyPath<Rdf.Iri>([VocabWorkflow.step], pg).getOrElse(undefined);\n        const assignee = Rdf.getValueFromPropertyPath<Rdf.Iri>([VocabWorkflow.assignee], pg).getOrElse(undefined);\n        return { step, assignee };\n      })\n      .getOrElse(WorkflowState.empty);\n  }\n\n  isWorkflowExist(resourceIri: Rdf.Iri): Kefir.Property<boolean> {\n    const queryStr = `ASK {\n            ?workflow a ?type .\n            ?workflow ?predicate ?subject .\n        }`;\n    let query = parseQuerySync(queryStr);\n    query = SparqlClient.setBindings(query, {\n      subject: resourceIri,\n      type: VocabWorkflow.WorkflowInstantiation,\n      predicate: VocabWorkflow.subject,\n    });\n    return SparqlClient.ask(query);\n  }\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { Rdf } from 'platform/api/rdf';\nimport { QueryContext } from 'platform/api/sparql';\n\nimport { getPreferredUserLanguage } from 'platform/api/services/language';\n\nimport { BaseResourceService } from './BaseResourceService';\n\nconst LABELS_SERVICE_URL = '/rest/data/rdf/utils/getLabelsForRdfValue';\nconst service = new (class extends BaseResourceService {\n  constructor() {\n    super(LABELS_SERVICE_URL);\n  }\n\n  createRequest(resources: string[], repository: string) {\n    const request = super.createRequest(resources, repository);\n    const preferredLanguage = getPreferredUserLanguage();\n    request.query({ preferredLanguage });\n    return request;\n  }\n})();\n\nexport function getLabel(iri: Rdf.Iri, options?: { context?: QueryContext }) {\n  return service.getResource(iri, options ? options.context : undefined);\n}\n\nexport function getLabels(iris: ReadonlyArray<Rdf.Iri>, options?: { context?: QueryContext }) {\n  return service.getResources(iris, options ? options.context : undefined);\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as Kefir from 'kefir';\nimport * as SparqlJs from 'sparqljs';\n\nimport { SparqlUtil } from 'platform/api/sparql';\n\nimport * as ConfigService from './config';\nimport { NotEnoughPermissionsError } from './security';\n\ninterface RawConfig {\n  environment: EnvironmentConfig;\n  ui: RawUIConfig;\n  global: GlobalConfig;\n}\n\n/**\n * This is static holder of configuration. It's initalized in MainApp, everything is rendered after\n * this component is ready. To use, call getEnvironmentConfig, it will get you either config or\n * throw an error if it's not initialized yet\n */\nexport class ConfigHolderClass {\n  private isLoading: boolean;\n\n  private environmentConfig: EnvironmentConfig;\n  private uiConfig: UIConfig;\n  private globalConfig: GlobalConfig;\n\n  constructor() {\n    this.isLoading = true;\n  }\n\n  /**\n   * Get environment config in runtime. Values will be available when rendering.\n   * @returns EnvironmentConfig\n   */\n  public getEnvironmentConfig(): EnvironmentConfig {\n    if (this.isLoading) {\n      throw Error('Config has not been initialized yet');\n    }\n    return this.environmentConfig;\n  }\n\n  /**\n   * Get environment config in runtime. Values will be available when rendering.\n   * @returns EnvironmentConfig\n   */\n  public getUIConfig(): UIConfig {\n    if (this.isLoading) {\n      throw Error('Config has not been initialized yet');\n    }\n    return this.uiConfig;\n  }\n\n  /**\n   * Get global config in runtime. Values will be available when rendering.\n   * @returns GlobalConfig\n   */\n  public getGlobalConfig(): GlobalConfig {\n    if (this.isLoading) {\n      throw Error('Config has not been initialized yet');\n    }\n    return this.globalConfig;\n  }\n\n  fetchConfig(): Kefir.Property<RawConfig> {\n    return Kefir.combine({\n      environment: ConfigService.getConfigsInGroup('environment'),\n      ui: ConfigService.getConfigsInGroup('ui'),\n      global: ConfigService.getConfigsInGroup('global'),\n    }).toProperty();\n  }\n\n  /**\n   * This method is to be called by MainApp to trigger config initialization.\n   */\n  initializeConfig(rawConfig: RawConfig) {\n    this.setEnvironmentConfig(rawConfig.environment);\n    this.setUIConfig(rawConfig.ui);\n    this.setGlobalConfig(rawConfig.global);\n    this.isLoading = false;\n  }\n\n  private setEnvironmentConfig(config: EnvironmentConfig) {\n    if (!config.resourceUrlMapping) {\n      throw new NotEnoughPermissionsError(\n        'Configuration property \"resourceUrlMapping\" is undefined. ' +\n          'Most likely permissions for reading the configuration properties are not set correctly.'\n      );\n    }\n    this.environmentConfig = config;\n  }\n\n  private setUIConfig(config: RawUIConfig) {\n    const {\n      preferredLanguages,\n      preferredLabels,\n      preferredThumbnails,\n      templateIncludeQuery,\n      enableUiComponentBasedSecurity,\n    } = config;\n\n    const labelPaths = preferredLabels ? preferredLabels.value : [];\n    const thumbnailPaths = preferredThumbnails ? preferredThumbnails.value : [];\n    this.uiConfig = {\n      preferredLanguages: preferredLanguages ? preferredLanguages.value : [],\n      labelPropertyPattern: makePropertyPattern(labelPaths),\n      labelPropertyPath: makePropertyPath(labelPaths),\n      thumbnailPropertyPattern: makePropertyPattern(thumbnailPaths),\n      thumbnailPropertyPath: makePropertyPath(thumbnailPaths),\n      templateIncludeQuery: templateIncludeQuery ? templateIncludeQuery.value : undefined,\n      enableUiComponentBasedSecurity: enableUiComponentBasedSecurity\n        ? Boolean(enableUiComponentBasedSecurity.value)\n        : false,\n    };\n  }\n\n  private setGlobalConfig(config: GlobalConfig) {\n    this.globalConfig = config;\n  }\n}\n\nexport interface EnvironmentConfig {\n  readonly resourceUrlMapping?: StringValue;\n}\n\ninterface RawUIConfig {\n  preferredLanguages?: StringArray;\n  preferredLabels?: StringArray;\n  preferredThumbnails?: StringArray;\n  templateIncludeQuery?: StringValue;\n  enableUiComponentBasedSecurity?: BooleanValue;\n  supportedBrowsers?: StringArray;\n  unsupportedBrowserMessage?: StringValue;\n}\n\nexport interface UIConfig {\n  readonly preferredLanguages: ReadonlyArray<string>;\n  readonly labelPropertyPattern: string;\n  readonly labelPropertyPath: SparqlJs.PropertyPath;\n  readonly thumbnailPropertyPattern: string;\n  readonly thumbnailPropertyPath: SparqlJs.PropertyPath;\n  readonly templateIncludeQuery: string | undefined;\n  readonly enableUiComponentBasedSecurity: boolean;\n  readonly supportedBrowsers?: ReadonlyArray<string>;\n  readonly unsupportedBrowserMessage?: string | undefined;\n}\n\nexport interface GlobalConfig {\n  readonly homePage?: StringValue;\n}\n\nexport interface StringValue {\n  value: string;\n  shadowed: boolean;\n}\n\nexport interface StringArray {\n  value: string[];\n  shadowed: boolean;\n}\n\nexport interface BooleanValue {\n  value: boolean;\n  shadowed: boolean;\n}\n\nfunction makePropertyPattern(paths: ReadonlyArray<string>): string {\n  return keepOnlyPropertyPaths(paths).join('|');\n}\n\nfunction makePropertyPath(paths: ReadonlyArray<string>): SparqlJs.PropertyPath {\n  const alternatives: Array<SparqlJs.Term | SparqlJs.PropertyPath> = [];\n  for (const path of keepOnlyPropertyPaths(paths)) {\n    try {\n      const alternative = SparqlUtil.parsePropertyPath(path);\n      alternatives.push(alternative);\n    } catch (err) {\n      console.warn('Invalid label property path', err);\n    }\n  }\n\n  if (alternatives.length === 0) {\n    throw new Error('Failed to construct property path for labels (path is empty)');\n  }\n\n  return {\n    type: 'path',\n    pathType: '|',\n    items: alternatives,\n  };\n}\n\nfunction keepOnlyPropertyPaths(paths: ReadonlyArray<string>): string[] {\n  return paths.filter((path) => !(path.startsWith('{') || path.endsWith('}')));\n}\n\nexport const ConfigHolder = new ConfigHolderClass();\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as request from 'platform/api/http';\n\nimport { parseTemplate } from './RemoteTemplateFetcher';\n\nconst TEMPLATE_SERVICE_URL = '/rest/template/';\n\nexport function getHeader(cb: (html: string) => void): void {\n  request\n    .get(TEMPLATE_SERVICE_URL + 'header')\n    .accept('text/html')\n    .end((err, res) => {\n      cb(res.text);\n    });\n}\n\nexport function getFooter(cb: (html: string) => void): void {\n  request\n    .get(TEMPLATE_SERVICE_URL + 'footer')\n    .accept('text/html')\n    .end((err, res) => {\n      cb(res.text);\n    });\n}\n\nexport function getNoPermissionsPage(cb: (html: string) => void): void {\n  request\n    .get(TEMPLATE_SERVICE_URL + 'noPermissionsPage')\n    .accept('text/html')\n    .end((err, res) => {\n      cb(res.text);\n    });\n}\n\nexport { ContextCapturer, CapturedContext } from './functions';\nimport * as TemplateParser from './TemplateParser';\nexport { TemplateParser, parseTemplate };\nexport * from './TemplateScope';\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as Kefir from 'kefir';\nimport { get } from 'platform/api/http';\n\nimport { Rdf } from 'platform/api/rdf';\nimport { constructUrlForResource } from 'platform/api/navigation';\n\nmodule URLMinifierService {\n  const URL_MINIFIER_SERVICE_URL = '/rest/url-minify/getShort';\n\n  export function getShortKey(url: string): Kefir.Property<string> {\n    const request = get(URL_MINIFIER_SERVICE_URL).query({ url }).accept('text/plain');\n    return Kefir.fromNodeCallback<string>((cb) => request.end((err, res) => cb(err, res.text))).toProperty();\n  }\n\n  export function getShortURLForResource(iri: Rdf.Iri, repository?: string): Kefir.Property<string> {\n    return constructUrlForResource(iri, {}, repository)\n      .map((url) => url.absoluteTo(location.origin).valueOf())\n      .flatMap(makeShortURL)\n      .toProperty();\n  }\n\n  export function makeShortURL(fullUrl: string): Kefir.Property<string> {\n    return URLMinifierService.getShortKey(fullUrl).map((key) => location.origin + '/l/' + key);\n  }\n}\n\nexport = URLMinifierService;\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as request from 'platform/api/http';\nimport * as Kefir from 'kefir';\nimport { requestAsProperty } from 'platform/api/async';\n\nexport module GenericRestService {\n  export function getJson<T>(path: string): Kefir.Property<T> {\n    const req = request.get(path).type('application/json').accept('application/json');\n\n    return requestAsProperty(req).map((res) => JSON.parse(res.text));\n  }\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nexport { EventsApi, Event, EventType } from './EventsApi';\nimport * as BuiltInEvents from './BuiltInEvents';\nexport { BuiltInEvents };\nexport * from './EventsStore';\nexport * from './Utils';\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\n/**\n * This module can be used to serialize/deserialize JS instance to/from JSON.\n * E.g. it can be used to save state of the react component.\n */\n\nimport * as _ from 'lodash';\nimport { Iterable } from 'immutable';\n\nexport interface Deserializer<T> {\n  /**\n   * Name which is used to determine appropriate deserializer function.\n   * Should be unique across all possible deserializers.\n   */\n  name: string;\n\n  /**\n   * Deserializer function. Converts JSON object to JS instance.\n   */\n  deserializer: (obj: {}) => T;\n}\n\nexport interface Serializer<T> {\n  /**\n   * Name which is used to mark serialized obeject.\n   * Deserializer with corresponding name will be used for deserialization.\n   * Should be unique across all possible serializers.\n   */\n  name: string;\n\n  predicate: (x: any) => boolean;\n\n  /**\n   * Serializer function. Converts JS instance to JSON.\n   */\n  serializer: (x: T) => {};\n}\n\nconst TYPE_VARIABLE_NAME = '#type';\nconst VALUE_VARIABLE_NAME = '#value';\n\n/**\n * All registered desrializers.\n */\nconst deserializers: Array<Deserializer<any>> = [];\n\n/**\n * All registered srializers.\n */\nconst serializers: Array<Serializer<any>> = [];\n\n/**\n * ES6 decorator function to register method as deserializer for class instance.\n *\n * @example\n *  class MyClass {\n *    @deserializer\n *    public static fromJson(obj: {}) {return new MyClass();}\n *  }\n */\nexport function deserializer<T>(target: any, key: string, descriptor: any) {\n  deserializers.push({\n    name: <string>target.prototype.constructor.name,\n    deserializer: descriptor.value,\n  });\n  return descriptor;\n}\n\n/**\n * ES6 decorator function to register method as serializer for class instance.\n *\n * @example\n *  class MyClass {\n *    @serializer\n *    toJson() {return {}}\n *  }\n */\nexport function serializer<T>(target: any, key: string, descriptor: any) {\n  serializers.push({\n    name: target.constructor.name,\n    predicate: (obj) => obj instanceof target.constructor,\n    serializer: descriptor.value,\n  });\n  return descriptor;\n}\n\n/**\n * Register serializer for class.\n * Useful when serializer need to be registered for class that is not under control.\n * Otherwise decorator approach is more concise.\n *\n * @example\n * class MyClassA {\n *    constructor(x: MyClassB) {\n *      this._x = x;\n *    }\n * }\n *\n * serializerFor({\n *   name: MyClassA.prototype.constructor.name,\n *   predicate: function(obj) {\n *     return obj instanceof MyClassA\n *   },\n *   serializer: function(obj: MyClassA) {\n *     return {\n *       x: obj._x\n *     };\n *   }\n * });\n *\n * If serializer for MyClassB has been already defined, it will be properly serialized as well.\n */\nexport function serializerFor<T>(serializer: Serializer<T>) {\n  serializers.push(serializer);\n}\n/**\n * Register deserializer for class.\n * Useful when deserializer need to be registered for class that is not under control.\n * Otherwise decorator approach is more concise.\n *\n * @example\n * class MyClassA {\n *    constructor(x: MyClassB) {\n *      this._x = x;\n *    }\n * }\n *\n * derializerFor({\n *   name: MyClassA.prototype.constructor.name,\n *   deserializer: function(obj: any) {\n *     return new MyClassA(obj.x);\n *   }\n * });\n *\n * If there is deserializer for MyClassB, obj.x will deserialized before invocation of the deserializer for MyClassA.\n * As result obj.x will be instanceof MyClassB.\n */\nexport function deserializerFor<T>(deserializer: Deserializer<T>) {\n  return deserializers.push(deserializer);\n}\n\n/**\n * Serialize JS class instance to JSON object.\n * Serialization rules:\n *   serialize(null) === null\n *   serialize(1) === 1\n *   serialize('string') === 'string'\n *   serialize([1, myClassInstance]) == [1, {#type: MyClass, #value: {...}}]\n *   serialize({x: 1, y: myClassInstance}) == {x: 1, y: {#type: MyClass, #value: {...}}}\n */\nexport function serialize(object: any): {} {\n  if (_.isUndefined(object) || _.isNull(object) || _.isNumber(object) || _.isString(object)) {\n    return object;\n  } else if (_.isArray(object)) {\n    return _.map(object, serialize);\n    // need to have !(object instanceof Iterable) check to avoid warnings from immutablejs\n  } else if (!(object instanceof Iterable) && _.isPlainObject(object)) {\n    return _.transform(\n      object,\n      (res, val, key) => {\n        res[key] = serialize(val);\n        return res;\n      },\n      {}\n    );\n  } else {\n    var serializerObj = _.find(serializers, (serializer) => serializer.predicate(object));\n    if (serializerObj) {\n      return addTypeDiscriminator(serializerObj.serializer, serializerObj.name)(object);\n    } else {\n      return object;\n    }\n  }\n}\n\n/**\n * Deserialize JSON as some JS class instance.\n */\nexport function deserialize<T>(object: any): T {\n  if (_.isUndefined(object) || _.isNull(object) || _.isNumber(object) || _.isString(object)) {\n    return object as any;\n  } else if (_.isArray(object)) {\n    return <any>_.map(object, deserialize);\n  } else {\n    var deserializerObj = _.find(deserializers, (deserializer) => object[TYPE_VARIABLE_NAME] === deserializer.name);\n    if (deserializerObj) {\n      return deserializerObj.deserializer(deserialize(object[VALUE_VARIABLE_NAME]));\n    } else if (_.isPlainObject(object)) {\n      return <any>_.transform(\n        object,\n        (res, val, key) => {\n          res[key] = deserialize(val);\n          return res;\n        },\n        {}\n      );\n    } else {\n      return object;\n    }\n  }\n}\n\nfunction addTypeDiscriminator(originalFn: Function, serializedObjectType) {\n  return function (obj) {\n    var json = {};\n    json[TYPE_VARIABLE_NAME] = serializedObjectType;\n    json[VALUE_VARIABLE_NAME] = serialize(originalFn.apply(obj, [obj]));\n    return json;\n  };\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as SparqlJs from 'sparqljs';\n\nexport function isQuery(node: any): node is SparqlJs.Query {\n  return typeof node === 'object' && node.type === 'query';\n}\n\nexport function isSelectQuery(query: SparqlJs.Query): query is SparqlJs.SelectQuery {\n  return query.queryType === 'SELECT';\n}\n\nexport function isConstructQuery(query: SparqlJs.Query): query is SparqlJs.ConstructQuery {\n  return query.queryType === 'CONSTRUCT';\n}\n\nexport function isAskQuery(query: SparqlJs.Query): query is SparqlJs.AskQuery {\n  return query.queryType === 'ASK';\n}\n\nexport function isDescribeQuery(query: SparqlJs.Query): query is SparqlJs.DescribeQuery {\n  return query.queryType === 'DESCRIBE';\n}\n\nexport function isStarProjection(variables: any): variables is ['*'] {\n  return Array.isArray(variables) && variables.length === 1 && variables[0] === '*';\n}\n\nexport function isPattern(node: any): node is SparqlJs.Pattern {\n  if (typeof node === 'object') {\n    switch (node.type) {\n      case 'bgp':\n      case 'optional':\n      case 'union':\n      case 'group':\n      case 'minus':\n      case 'graph':\n      case 'service':\n      case 'filter':\n      case 'values':\n        return true;\n    }\n  }\n  return false;\n}\n\nexport function isGroupPattern(pattern: SparqlJs.Pattern): pattern is SparqlJs.GroupPattern {\n  return pattern.type === 'group';\n}\n\nexport function isBlockPattern(pattern: SparqlJs.Pattern): pattern is SparqlJs.BlockPattern {\n  switch (pattern.type) {\n    case 'optional':\n    case 'union':\n    case 'group':\n    case 'minus':\n    case 'graph':\n    case 'service':\n      return true;\n    default:\n      return false;\n  }\n}\n\nexport function isExpression(node: any): node is SparqlJs.Expression {\n  if (typeof node === 'string') {\n    return true;\n  } else if (Array.isArray(node)) {\n    return true;\n  } else if (typeof node === 'object') {\n    switch (node.type) {\n      // expressions\n      case 'operation':\n      case 'functionCall':\n      case 'aggregate':\n      // expression-like patterns\n      case 'bgp':\n      case 'group':\n        return true;\n    }\n  }\n  return false;\n}\n\nexport function isQuads(node: any): node is SparqlJs.Quads {\n  return (node.type === 'bgp' || node.type === 'graph') && 'triples' in node;\n}\n\nexport function isTerm(\n  node: SparqlJs.Expression | SparqlJs.PropertyPath | SparqlJs.VariableExpression | SparqlJs.Term\n): node is SparqlJs.Term {\n  return typeof node === 'string';\n}\n\nexport function isVariable(term: any): term is SparqlJs.Term {\n  return typeof term === 'string' && term.length > 0 && (term[0] === '?' || term[0] === '$');\n}\n\nexport function isLiteral(term: any): term is SparqlJs.Term {\n  return typeof term === 'string' && term.length > 0 && term[0] === '\"';\n}\n\nexport function isBlank(term: any): term is SparqlJs.Term {\n  return typeof term === 'string' && term.length > 1 && term[0] === '_';\n}\n\nexport function isIri(term: any): term is SparqlJs.Term {\n  if (typeof term !== 'string' || term.length === 0) {\n    return false;\n  }\n  const first = term[0];\n  return first !== '?' && first !== '$' && first !== '\"' && first !== '_';\n}\n\nexport function isUpdateOperation(update: any) {\n  return isInsertDeleteOperation(update) || isManagementOperation(update);\n}\n\nexport function isInsertDeleteOperation(update: SparqlJs.UpdateOperation): update is SparqlJs.InsertDeleteOperation {\n  if (typeof update !== 'object') {\n    return false;\n  }\n  const updateType = (update as SparqlJs.InsertDeleteOperation).updateType;\n  return (\n    updateType &&\n    (updateType === 'insert' ||\n      updateType === 'delete' ||\n      updateType === 'deletewhere' ||\n      updateType === 'insertdelete')\n  );\n}\n\nexport function isManagementOperation(update: SparqlJs.UpdateOperation): update is SparqlJs.ManagementOperation {\n  if (typeof update !== 'object') {\n    return false;\n  }\n  const type = (update as SparqlJs.ManagementOperation).type;\n  return type && (type === 'load' || type === 'copy' || type === 'move' || type === 'add');\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nexport * from './vocabularies';\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nexport { default as rdfs } from './rdfs';\nexport { default as rdf } from './rdf';\nexport { default as xsd } from './xsd';\nexport { default as dc } from './dc';\nexport { default as dct } from './dct';\n\nexport { default as sp } from './sp';\nexport { default as spl } from './spl';\nexport { default as spin } from './spin';\nexport { default as ldp } from './ldp';\nexport { default as oa } from './oa';\nexport { default as field } from './field';\n\nexport { default as prov } from './prov';\n\nexport { default as persist } from './persist';\nexport { default as VocabPlatform } from './platform';\n\nexport { default as workflow } from './workflow';\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { Props as ReactProps, ReactNode, CSSProperties, createElement } from 'react';\nimport * as _ from 'lodash';\nimport * as maybe from 'data.maybe';\nimport * as Kefir from 'kefir';\n\nimport { Rdf } from 'platform/api/rdf';\nimport { getLabel } from 'platform/api/services/resource-label';\nimport { Cancellation } from 'platform/api/async';\nimport { Component } from 'platform/api/components';\nimport { getRepositoryStatus } from 'platform/api/services/repository';\nimport { SparqlClient, SparqlUtil } from 'platform/api/sparql';\nimport { ErrorNotification } from 'platform/components/ui/notification';\n\nimport { ResourceLink as InternalResourceLink } from './ResourceLink';\nimport { extractParams } from '../NavigationUtils';\n\nexport interface ResourceLinkProps extends ReactProps<ResourceLinkComponent> {\n  iri?: string;\n  /**\n   * @deprecated\n   */\n  uri?: string;\n  getlabel?: boolean;\n  className?: string;\n  style?: CSSProperties;\n  title?: string;\n\n  /**\n   * Specify if link should be draggable, e.g. into sets.\n   *\n   * @default true\n   */\n  draggable?: boolean;\n\n  guessRepository?: boolean;\n\n  /**\n   * Equivalent to the `target` attribute of the `<a>` DOM element.\n   * Can be set to `_blank` to open the link in a new tab/window.\n   *\n   * @default '_self'\n   */\n  target?: '_self' | '_blank';\n\n  /**\n   * Fragment identifier\n   */\n  fragment?: string;\n\n  // catcher for query params\n  [index: string]: any;\n}\n\ninterface State {\n  label?: Data.Maybe<string>;\n  repository: Data.Maybe<string>;\n}\n\ninterface ParamMap {\n  [index: string]: string;\n}\n\n/**\n * Component which can be used in handlebars templates to generate a routed\n * link for the resource. If no childs are given (elements or text), the\n * component will automatically try to fetch a label and render a sensible and\n * human readable default link (unless getlabel=true).\n *\n * 'uri' attribute specifies destination resource uri.\n *\n * 'urlqueryparam-*' attribute specify additional url query parameter,\n * last part of attribute name corresponds to the url query parameter name.\n * For example 'urlqueryparam-example=\"test\"' attribute will result into\n * '?example=test' query parameter.\n *\n * 'getlabel' boolean attribute to specify whether label for the given resource\n * should be fetched automatically. Default: true\n *\n * @example\n *   <semantic-link\n *   \ttitle=\"Execute\" uri=\"http://researchspace.org/SearchDemo\"\n *   \turlqueryparam-query=\"{{ID.value}}\">\n *       <i class=\"fa fa-play-circle\"></i>\n *   </semantic-link>\n *\n * @example\n * \t // fetching label automatically\n *   <semantic-link uri=\"http://xmlns.com/foaf/0.1/Person\">\n *   </semantic-link>\n *\n * @example\n * \t //  fetching no label, will render plain link\n *   <semantic-link uri=\"http://xmlns.com/foaf/0.1/Person\" getlabel=false>\n *   </semantic-link>\n */\nexport class ResourceLinkComponent extends Component<ResourceLinkProps, State> {\n  private cancellation = new Cancellation();\n\n  constructor(props: ResourceLinkProps, context) {\n    super(props, context);\n    this.checkDeprecated(props);\n    this.state = {\n      label: maybe.Nothing<string>(),\n      repository: maybe.Nothing<string>(),\n    };\n  }\n\n  private checkDeprecated(props: ResourceLinkProps) {\n    if (props.uri) {\n      console.warn(\n        'The \"uri\" property of \"ResourceLinkComponent\" is deprecated,',\n        'please use the \"iri\" property instead'\n      );\n    }\n  }\n\n  private getIri = () => {\n    const { iri, uri } = this.props;\n    return iri || uri;\n  };\n\n  public componentDidMount() {\n    const iri = this.getIri();\n\n    if (!iri) {\n      return;\n    }\n\n    this.getRepository().onValue((repository) => {\n      this.fetchLabel(Rdf.iri(iri), this.props.children, repository).onValue((label) =>\n        this.setState({\n          label: maybe.Just(label),\n          repository: maybe.Just(repository),\n        })\n      );\n    });\n  }\n\n  public componentWillReceiveProps(nextProps: ResourceLinkProps) {\n    if (this.props.uri !== nextProps.uri) {\n      this.checkDeprecated(nextProps);\n    }\n  }\n\n  public componentWillUnmount() {\n    this.cancellation.cancelAll();\n  }\n\n  public render() {\n    const iri = this.getIri();\n\n    if (!iri) {\n      return createElement(ErrorNotification, {\n        errorMessage: `The component doesn't have the \"iri\" property`,\n      });\n    }\n\n    return this.state.label.map(this.renderLink).getOrElse(null);\n  }\n\n  private renderLink = (label: string) => {\n    const iri = this.getIri();\n    let props = _.clone(this.props) as any;\n    props.title = label;\n    return createElement(\n      InternalResourceLink,\n      _.assign(\n        {\n          resource: Rdf.iri(iri),\n          params: extractParams(this.props),\n          className: this.props.className,\n          style: this.props.style,\n          title: this.props.title,\n          repository: this.state.repository.getOrElse(undefined),\n          fragment: this.props.fragment,\n        },\n        props\n      ),\n      this.getChildren(this.props.children, this.state.label, iri)\n    );\n  };\n\n  /**\n   * Returns child nodes for the resource link component.\n   * If the child is a plain text node equal to the resource Iri\n   * or no child nodes are present a simple label string will be returned\n   * (if present).\n   *\n   * Otherwise the unmodified array of children will be returned.\n   *\n   * @param {children}  Children of the resource link component.\n   * @param {label}  Label string.\n   * @param {iri}  Iri of the resource link.\n   */\n  private getChildren = (children: ReactNode, label: Data.Maybe<string>, iri: string) => {\n    if ((_.isEmpty(children) || children === iri) && label.isJust) {\n      children = label.get();\n    } else if (_.isEmpty(children)) {\n      children = '';\n    }\n    return children;\n  };\n\n  private fetchLabel = (resource: Rdf.Iri, children: ReactNode, repository: string): Kefir.Property<string> => {\n    if (this.props.getlabel !== false && (_.isEmpty(children) || children === resource.value)) {\n      return this.cancellation.map(getLabel(resource, { context: { repository } }));\n    } else {\n      return Kefir.constant(resource.value);\n    }\n  };\n\n  private static repositories = getRepositoryStatus();\n  private getRepository = (): Kefir.Property<string> => {\n    if (this.props.guessRepository) {\n      return ResourceLinkComponent.repositories\n        .map((repositories) =>\n          repositories.filter((running) => running).map((_, repository) => this.executeGuessQuery(repository))\n        )\n        .flatMap((responses) => Kefir.combine(responses.toKeyedSeq().toObject()))\n        .map((responses) => _.findKey(responses))\n        .toProperty();\n    } else {\n      return Kefir.constant(this.context.semanticContext ? this.context.semanticContext.repository : undefined);\n    }\n  };\n\n  private static GUESS_QUERY = SparqlUtil.Sparql`ASK { ?subject a ?type }`;\n  private executeGuessQuery = (repository: string) => {\n    return SparqlClient.ask(\n      SparqlClient.setBindings(ResourceLinkComponent.GUESS_QUERY, { subject: Rdf.iri(this.getIri()) }),\n      { context: { repository: repository } }\n    );\n  };\n}\nexport default ResourceLinkComponent;\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as Maybe from 'data.maybe';\nimport * as Kefir from 'kefir';\nimport * as request from 'platform/api/http';\nimport * as _ from 'lodash';\nimport * as I from 'immutable';\n\nimport { Rdf } from 'platform/api/rdf';\nimport { BatchedPool, requestAsProperty } from 'platform/api/async';\n\nexport interface NamespaceRecord {\n  prefix: string;\n  iri: string;\n  appId: string;\n}\n\nconst GET_FULL_URIS_URL = '/rest/data/rdf/namespace/getFullUris';\nconst GET_PREFIXED_URIS_URL = '/rest/data/rdf/namespace/getPrefixedUris';\nexport const GET_REGISTERED_PREFIXES = '/rest/data/rdf/namespace/getRegisteredPrefixes';\nconst GET_RECORDS = '/rest/data/rdf/namespace/getRecords';\nconst PUT_PREFIX = '/rest/data/rdf/namespace/setPrefix';\nconst DELETE_PREFIX = '/rest/data/rdf/namespace/deletePrefix';\n\nconst pool = new BatchedPool<Rdf.Iri, Data.Maybe<string>>({\n  fetch: (iris) => getPrefixedIris(iris.toArray()),\n});\n\nexport function getPrefixedUri(iri: Rdf.Iri): Kefir.Property<Data.Maybe<string>> {\n  return pool.query(iri);\n}\n\nexport function getPrefixedIris(iris: Rdf.Iri[]): Kefir.Property<I.Map<Rdf.Iri, Data.Maybe<string>>> {\n  return resolveIri(\n    GET_PREFIXED_URIS_URL,\n    _.map(iris, (iri) => iri.value)\n  ).map((res) =>\n    I.Map(res)\n      .mapEntries<Rdf.Iri, Data.Maybe<string>>((entry) => [Rdf.iri(entry[0]), Maybe.fromNullable<string>(entry[1])])\n      .toMap()\n  );\n}\n\nexport function getFullIri(prefixedIri: string): Kefir.Property<Data.Maybe<Rdf.Iri>> {\n  return getFullIris([prefixedIri]).map((res) => res.get(prefixedIri));\n}\n\nexport function getFullIris(iris: string[]): Kefir.Property<I.Map<string, Data.Maybe<Rdf.Iri>>> {\n  return resolveIri(GET_FULL_URIS_URL, iris).map((res) =>\n    I.Map(res)\n      .map((iri) => Maybe.fromNullable(iri).map(Rdf.iri))\n      .toMap()\n  );\n}\n\nexport function getRegisteredPrefixes(): Kefir.Property<{ [key: string]: string }> {\n  const req = request.get(GET_REGISTERED_PREFIXES).type('application/json').accept('application/json');\n  return Kefir.fromNodeCallback<Record<string, string>>((cb) => req.end((err, res) => cb(err, res.body))).toProperty();\n}\n\nexport function getNamespaceRecords(): Kefir.Property<NamespaceRecord[]> {\n  const req = request.get(GET_RECORDS).type('application/json').accept('application/json');\n  return requestAsProperty(req).map((res) => res.body);\n}\n\nexport function setPrefix(prefix: string, ns: string, targetAppId: string): Kefir.Property<void> {\n  const req = request\n    .put(PUT_PREFIX + '/' + prefix)\n    .query({ targetAppId })\n    .type('text/plain')\n    .send(ns);\n  return requestAsProperty(req).map((res) => {});\n}\n\nexport function deletePrefix(prefix: string, targetAppId: string): Kefir.Property<void> {\n  const req = request.del(DELETE_PREFIX + '/' + prefix).query({ targetAppId });\n  return requestAsProperty(req).map((res) => {});\n}\n\nfunction resolveIri(url: string, iris: string[]): Kefir.Property<{ [key: string]: string }> {\n  const req = request.post(url).send(iris).type('application/json').accept('application/json');\n  return Kefir.fromNodeCallback<Record<string, string>>((cb) =>\n    req.end((err, res) => cb(err, res ? res.body : null))\n  ).toProperty();\n}\n\nexport function isSystemNamespacePrefix(prefix: string) {\n  // either empty or starts with uppercase letter\n  return prefix.length === 0 || prefix[0] === prefix[0].toUpperCase();\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as Kefir from 'kefir';\nimport * as _ from 'lodash';\nimport * as SparqlJs from 'sparqljs';\n\nimport { Rdf } from 'platform/api/rdf';\nimport { getCurrentResource } from '../navigation/CurrentResource';\n\nimport { isQuery, isTerm, isIri } from './TypeGuards';\n\n// by default we initialized parser without prefixes so we don't need\n// to initialize it explicitly in all tests, but the expectation is that\n// in production run init is called on the system startup\nlet Parser: SparqlJs.SparqlParser = new SparqlJs.Parser();\nexport let RegisteredPrefixes: {\n  Default: string; Admin: string; Help: string;\n} & { [key: string]: string };\nexport function init(registeredPrefixes: { [key: string]: string }) {\n  RegisteredPrefixes = registeredPrefixes as typeof RegisteredPrefixes;\n  Parser = new SparqlJs.Parser(registeredPrefixes);\n}\n\nconst Generator = new SparqlJs.Generator();\n\nexport type RDFResultFormat =\n  | 'application/ld+json'\n  | 'application/n-quads'\n  | 'application/n-triples'\n  | 'application/rdf+json'\n  | 'application/rdf+xml'\n  | 'application/trig'\n  | 'application/trix'\n  | 'application/x-binary-rdf'\n  | 'application/x-trig'\n  | 'application/x-turtle'\n  | 'application/xml'\n  | 'text/n3'\n  | 'text/nquads'\n  | 'text/plain'\n  | 'text/rdf+n3'\n  | 'text/turtle'\n  | 'text/x-nquads';\n\nexport type TupleResultFormat =\n  | 'application/json'\n  | 'application/sparql-results+json'\n  | 'application/sparql-results+xml'\n  | 'application/x-binary-rdf-results-table'\n  | 'text/csv'\n  | 'text/tab-separated-values';\n\nexport type BooleanResultFormat = 'text/boolean';\nexport type ResultFormat = RDFResultFormat | TupleResultFormat | BooleanResultFormat;\n\nexport function guessFileEnding(resultFormat: RDFResultFormat) {\n  switch (resultFormat) {\n    case 'application/rdf+xml':\n      return 'rdf';\n    case 'text/turtle':\n      return 'ttl';\n    case 'application/x-trig':\n      return 'trig';\n    case 'application/trix':\n      return 'trix';\n    case 'application/ld+json':\n      return 'jsonld';\n    case 'text/n3':\n      return 'n3';\n    case 'text/x-nquads':\n      return 'nq';\n    case 'application/n-triples':\n      return 'nt';\n    default:\n      return 'application/rdf+xml';\n  }\n}\n\nexport function getFileEnding(file: File): string {\n  return file.name.split('.').pop().toLowerCase().trim();\n}\n\nexport function getMimeType(fileEnding: String): RDFResultFormat {\n  switch (fileEnding) {\n    case 'owl':\n      return 'application/rdf+xml';\n    case 'rdf':\n      return 'application/rdf+xml';\n    case 'ttl':\n      return 'text/turtle';\n    case 'trig':\n      return 'application/x-trig';\n    case 'trix':\n      return 'application/trix';\n    case 'jsonld':\n      return 'application/ld+json';\n    case 'n3':\n      return 'text/n3';\n    case 'nq':\n      return 'text/x-nquads';\n    case 'nt':\n      return 'text/plain';\n    case 'ntriples':\n      return 'text/plain';\n    default:\n      return 'application/rdf+xml';\n  }\n}\n\nexport function addOrChangeLimit(query: SparqlJs.SelectQuery, limit: number): SparqlJs.SparqlQuery {\n  query.limit = limit;\n  return query;\n}\n\n/**\n * TODO deprecated, please use parseQuerySync\n */\nexport function parseQueryAsync(query: string): Kefir.Property<SparqlJs.SparqlQuery> {\n  try {\n    return Kefir.constant(parseQuery(query));\n  } catch (e) {\n    console.error('Error while parsing the query: ' + e);\n    return Kefir.constantError(e);\n  }\n}\n\n/**\n * Parses SPARQL query from string representation to Query Algebra using SPARQL.js\n * Resolving all namespaces with platform namespace service.\n */\nexport function parseQuery<T extends SparqlJs.SparqlQuery>(query: string): T {\n  return Parser.parse(encodeLegacyVars(replaceQueryParams(query))) as T;\n}\n\nexport function parseQuerySync<T extends SparqlJs.SparqlQuery>(query: string): T {\n  return parseQuery<T>(query);\n}\n\nexport function serializeQuery(query: SparqlJs.SparqlQuery): string {\n  return decodeLegacyVars(Generator.stringify(query));\n}\n\nexport function validateSelectQuery(query: SparqlJs.Query): Kefir.Property<SparqlJs.SelectQuery> {\n  if (isQuery(query) && query.queryType === 'SELECT') {\n    return Kefir.constant(query);\n  } else {\n    return Kefir.constantError<any>(new Error(`Invalid SELECT query: ${serializeQuery(query)}`));\n  }\n}\n\nexport function Sparql(strings: TemplateStringsArray, ...values: any[]): SparqlJs.SparqlQuery {\n  return parseQuerySync(strings.raw[0]);\n}\n\nfunction replaceQueryParams(query: string): string {\n  // TODO, for legacy purpose only. Bind ?? to current resource\n  if (typeof getCurrentResource() === 'undefined') {\n    return query;\n  } else {\n    // replace special Template: prefix which is not substitued by the NS service\n    const contextResource = getCurrentResource().value.startsWith('Template:')\n      ? '<' + getCurrentResource().value.substr('Template:'.length) + '>'\n      : getCurrentResource().toString();\n    return query.replace(/\\?\\?/g, contextResource).replace(/\\$_this/g, contextResource);\n  }\n}\n\nfunction decodeLegacyVars(query: string): string {\n  return query.replace(/\\?____/g, '?:');\n}\n\nfunction encodeLegacyVars(query: string): string {\n  return query.replace(/\\?:/g, '?____');\n}\n\nexport function randomVariableName(): string {\n  return '_' + Math.random().toString(36).substring(7);\n}\n\n/**\n * @see https://lucene.apache.org/core/2_9_4/queryparsersyntax.html\n */\nconst LUCENE_ESCAPE_REGEX = /([+\\-&|!(){}\\[\\]^\"~*?:\\\\])/g;\n\n/**\n * Create a Lucene full text search query from a user input by\n * splitting it on whitespaces and escaping any special characters.\n */\nexport function makeLuceneQuery(inputText: string, escape = true, tokenize = true): Rdf.Literal {\n  const words = inputText\n    .split(' ')\n    .map((w) => w.trim())\n    .filter((w) => w.length > 0)\n    .map((w) => {\n      if (escape) {\n        w = w.replace(LUCENE_ESCAPE_REGEX, '\\\\$1');\n      }\n      if (tokenize) {\n        w += '*';\n      }\n      return w;\n    })\n    .join(' ');\n  return Rdf.literal(words);\n}\n\nexport function parsePatterns(patterns: string, prefixes?: { [prefix: string]: string }): SparqlJs.Pattern[] {\n  const wrappedPattern = `SELECT * WHERE { ${patterns} }`;\n  const parser = prefixes ? new SparqlJs.Parser(prefixes) : Parser;\n  const query = parser.parse(encodeLegacyVars(replaceQueryParams(wrappedPattern))) as SparqlJs.SelectQuery;\n  return query.where;\n}\n\nexport function parsePropertyPath(propertyPath: string): SparqlJs.Term | SparqlJs.PropertyPath {\n  const query = Parser.parse(`SELECT * WHERE { ?s ${propertyPath} ?o }`);\n  if (query.type === 'query' && query.where.length === 1) {\n    const pattern = query.where[0];\n    if (pattern.type === 'bgp' && pattern.triples.length === 1) {\n      const iriOrPath = pattern.triples[0].predicate;\n      if (!isTerm(iriOrPath) || isIri(iriOrPath)) {\n        return iriOrPath;\n      }\n    }\n  }\n  throw new Error(`Invalid Sparql property path: '${propertyPath}'`);\n}\n\n/**\n * Checks if SPARQL SELECT result is empty. With workaround for blazegraph bug\n * when empty result have one empty binding.\n * e.g for query like 'SELECT ?s ?p ?o WHERE { }'\n */\nexport function isSelectResultEmpty(result: { results: { bindings: {}[] } }): boolean {\n  const bindings = result.results.bindings;\n  return _.isEmpty(bindings) || (bindings.length === 1 && _.isEmpty(bindings[0]));\n}\n\n/**\n * Resolves prefixed IRIs to full ones using platform-wide registered prefixes.\n * If an IRI is already in a full form, it would be returned as is.\n */\nexport function resolveIris(iris: string[]): Rdf.Iri[] {\n  if (iris.length === 0) {\n    return [];\n  }\n  const serializedIris = iris.map((iri) => `(${iri})`).join(' ');\n  // using initialized Sparql.js parser to resolve IRIs\n  const parsed = parseQuery<SparqlJs.SelectQuery>(`SELECT * WHERE {} VALUES (?iri) { ${serializedIris} }`);\n  return parsed.values.map((row) => Rdf.iri(row['?iri']));\n}\n\n// see SPARQL 1.1 grammar for all allowed characters:\n// https://www.w3.org/TR/sparql11-query/#rPN_LOCAL\nconst IRI_LOCAL_PART = /^[a-zA-Z][-_a-zA-Z0-9]*$/;\n\n// TODO: move to NamespaceService\nexport function compactIriUsingPrefix(iri: Rdf.Iri): string {\n  const iriValue = iri.value;\n  for (const prefix in RegisteredPrefixes) {\n    if (!RegisteredPrefixes.hasOwnProperty(prefix)) {\n      continue;\n    }\n    const expandedPrefix = RegisteredPrefixes[prefix];\n    if (iriValue.startsWith(expandedPrefix)) {\n      const localPart = iriValue.substring(expandedPrefix.length, iriValue.length);\n      if (IRI_LOCAL_PART.test(localPart)) {\n        return prefix + ':' + localPart;\n      }\n    }\n  }\n  return `<${iriValue}>`;\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { registerSerializersAndDeserializers as forImmutable } from './3rd-party/immutable';\nimport { registerSerializersAndDeserializers as forDataMaybe } from './3rd-party/data.maybe';\nimport { registerSerializersAndDeserializers as forMoment } from './3rd-party/moment';\n\nexport * from './JsonCore';\nexport { recordSerializer } from './3rd-party/immutable';\n\nforImmutable();\nforDataMaybe();\nforMoment();\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { ReactElement, createElement, Props, MouseEvent, CSSProperties } from 'react';\nimport * as D from 'react-dom-factories';\nimport { assign } from 'lodash';\nimport * as classNames from 'classnames';\nimport * as Maybe from 'data.maybe';\nimport * as _ from 'lodash';\n\nimport { Cancellation } from 'platform/api/async';\nimport { Component } from 'platform/api/components';\nimport { Rdf } from 'platform/api/rdf';\nimport { Draggable } from 'platform/components/dnd';\nimport {\n  getCurrentResource,\n  navigateToResource,\n  getCurrentUrl,\n  constructUrlForResource,\n  construcUrlForResourceSync,\n} from '../Navigation';\n\nexport enum ResourceLinkAction {\n  edit,\n}\n\ninterface ResourceLinkProps extends Props<ResourceLink> {\n  resource: Rdf.Iri;\n  title?: string;\n  draggable?: boolean;\n  action?: ResourceLinkAction;\n  params?: {};\n  className?: string;\n  activeClassName?: string;\n  style?: CSSProperties;\n  repository?: string;\n  target?: '_self' | '_blank';\n  fragment?: string;\n}\n\ninterface State {\n  readonly url?: uri.URI;\n}\n\nexport class ResourceLink extends Component<ResourceLinkProps, State> {\n  private readonly cancellation = new Cancellation();\n\n  constructor(props: ResourceLinkProps, context: any) {\n    super(props, context);\n    this.state = {\n      url: construcUrlForResourceSync(\n        this.props.resource,\n        this.props.params,\n        this.getRepository(),\n        this.props.fragment\n      ),\n    };\n  }\n\n  static defaultProps = {\n    target: '_self' as '_self',\n  };\n\n  componentDidMount() {\n    this.cancellation\n      .map(constructUrlForResource(this.props.resource, this.props.params, this.getRepository(), this.props.fragment))\n      .observe({\n        value: (url) => this.setState({ url }),\n        error: (error) => console.error(error),\n      });\n  }\n\n  componentWillUnmount() {\n    this.cancellation.cancelAll();\n  }\n\n  public render() {\n    const { title, className, activeClassName, style, resource, draggable, target } = this.props;\n    const { url } = this.state;\n    const props = {\n      href: url.toString(),\n      title: title,\n      className: classNames(className, {\n        [activeClassName]: this.isLinkActive(),\n      }),\n      style: style,\n      onClick: this.onClick,\n      target: target,\n    };\n\n    // by default all links are draggable, but sometimes we want to disable this behavior\n    if (draggable === false) {\n      return D.a(props, this.props.children);\n    } else {\n      return createElement(Draggable, { iri: resource.value }, D.a(props, this.props.children));\n    }\n  }\n\n  private onClick = (e: MouseEvent<HTMLAnchorElement>) => {\n    if (isSimpleClick(e) && this.props.target === '_self') {\n      e.preventDefault();\n      e.stopPropagation();\n\n      const query = { action: ResourceLinkAction[this.props.action], ...this.props.params };\n      navigateToResource(this.props.resource, query, this.getRepository(), this.props.fragment).onValue(() => {\n        /**/\n      });\n    }\n    // otherwise we just let default link action trigger, and for example if\n    // target='_blank' is set it will just open the page in a new window\n  };\n\n  private getRepository = () =>\n    this.props.repository\n      ? this.props.repository\n      : this.context.semanticContext\n      ? this.context.semanticContext.repository\n      : undefined;\n\n  private isLinkActive = () => {\n    const { resource, params } = this.props;\n    const urlParams = assign({}, params);\n    if (!_.isUndefined(this.props.action)) {\n      urlParams['action'] = ResourceLinkAction[this.props.action];\n    }\n\n    // extract params from current url and drop ?uri param\n    // for comparison i.e. in case of dealing with full uris\n    const currentUrlParms = assign({}, getCurrentUrl().search(true));\n    delete currentUrlParms.uri;\n    return getCurrentResource().equals(resource) && _.isEqual(currentUrlParms, urlParams);\n  };\n}\n\n/**\n * make sure that we don't hijack Ctrl+Click, Meta+Click, middle mouse click default actions\n */\nexport function isSimpleClick(e: MouseEvent<HTMLAnchorElement>) {\n  return e.button === 0 && !(e.ctrlKey || e.metaKey);\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as Rdf from './core/Rdf';\nexport { Rdf };\n\nimport * as vocabularies from './vocabularies/vocabularies';\nexport { vocabularies };\n\nimport * as turtle from './formats/turtle';\nexport { turtle };\n\nimport * as ObjectGraph from './formats/JsObjectGraph';\nexport { ObjectGraph };\n\n// we don't export './formats/JsonLd' due to large library size\n\nimport * as XsdDataTypeValidation from './core/XsdDatatypeValidation';\nexport { XsdDataTypeValidation };\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as N3 from 'n3';\nimport * as Kefir from 'kefir';\nimport * as _ from 'lodash';\n\nimport * as Rdf from '../core/Rdf';\nimport { rdf as rdfVocab } from '../vocabularies/vocabularies';\n\nconst N3Util = N3.Util;\n\n/**\n * Provides functions for RDF serialization into Turtle.\n * As well as converters beetwen {@link ../core/Rdf} and {@link n3}\n */\nexport module serialize {\n  export const Format = {\n    Turtle: 'turtle',\n    NTriples: 'N-Triples',\n    Trig: 'application/trig',\n    NQuads: 'N-Quads',\n  };\n\n  /**\n   * Serialize {@link Rdf.Graph} into Turtle format.\n   */\n  export function serializeGraph(graph: Rdf.Graph, format: string = Format.Turtle): Kefir.Property<string> {\n    const writer = N3.Writer({ format: format });\n    graph.triples.forEach((triple) => writer.addTriple(tripleToN3(triple)));\n    return Kefir.fromNodeCallback<string>(writer.end.bind(writer)).toProperty();\n  }\n\n  /**\n   * Convert {@link Rdf.Triple} into N3 Triple representation.\n   *\n   * @see https://github.com/RubenVerborgh/N3.js#triple-representation\n   */\n  export function tripleToN3(triple: Rdf.Triple): N3.Triple {\n    const nTriple: N3.Triple = {\n      subject: nodeToN3(triple.s),\n      predicate: nodeToN3(triple.p),\n      object: nodeToN3(triple.o),\n    };\n\n    if (!_.isUndefined(triple.g) && !triple.g.equals(Rdf.DEFAULT_GRAPH)) {\n      nTriple.graph = nodeToN3(triple.g);\n    }\n\n    return nTriple;\n  }\n\n  /**\n   * Convert {@link Rdf.Node} into N3 value.\n   *\n   * @see https://github.com/RubenVerborgh/N3.js#triple-representation\n   */\n  export function nodeToN3(value: Rdf.Node): string {\n    return value.cata(\n      (iri) => iri.value,\n      (literal) => literalToN3(literal),\n      (bnode) => bnode.value\n    );\n  }\n\n  /**\n   * Convert {@link Rdf.Literal} into N3 value.\n   *\n   * @see https://github.com/RubenVerborgh/N3.js#triple-representation\n   */\n  export function literalToN3(literal: Rdf.Literal): string {\n    if (literal.language) {\n      return `\"${literal.value}\"@${literal.language}`;\n    } else {\n      return `\"${literal.value}\"^^${literal.datatype.value}`;\n    }\n  }\n}\n\n/**\n * Provides functions for RDF de-serialization from Turtle.\n * As well as converters beetwen {@link ../core/Rdf} and {@link n3}\n */\nexport module deserialize {\n  /**\n   * Deserialize Turtle string as {@link Rdf.Graph}.\n   */\n  export function turtleToGraph(turtle: string): Kefir.Property<Rdf.Graph> {\n    return turtleToTriples(turtle).map(Rdf.graph);\n  }\n\n  /**\n   * Deserialize Turtle string as array of {@link Rdf.Triple}\n   */\n  export function turtleToTriples(turtle: string): Kefir.Property<Rdf.Triple[]> {\n    return Kefir.stream((emitter) => {\n      initN3Parser(emitter, turtle);\n    })\n      .scan((acc: Rdf.Triple[], x: Rdf.Triple) => {\n        acc.push(x);\n        return acc;\n      }, <Rdf.Triple[]>[])\n      .last();\n  }\n\n  /**\n   * Converts N3.js representation of the RDF triple into {@link Rdf.Triple}.\n   */\n  export function n3TripleToRdf(triple: N3.Triple): Rdf.Triple {\n    return Rdf.triple(\n      n3ValueToRdf(triple.subject),\n      <Rdf.Iri>n3ValueToRdf(triple.predicate),\n      n3ValueToRdf(triple.object)\n    );\n  }\n\n  /**\n   * Converts N3.js representation of the RDF value into {@link Rdf.Node}.\n   */\n  export function n3ValueToRdf(value: string): Rdf.Node {\n    // TODO seems to be a bug with N3Util.isIRI in n3.js, need to revise this later\n    if (N3Util.isIRI(value) || value === '') {\n      return Rdf.iri(value);\n    } else if (N3Util.isLiteral(value)) {\n      return n3LiteralToRdf(value);\n    } else if (N3Util.isBlank(value)) {\n      return Rdf.bnode(value);\n    } else {\n      throw new Error(`Invalid rdf value: ${value}`);\n    }\n  }\n\n  /**\n   * Converts N3.js RDF literal representation into the internal {@link Rdf.Literal}.\n   */\n  export function n3LiteralToRdf(literal: string): Rdf.Literal {\n    switch (N3Util.getLiteralType(literal)) {\n      case rdfVocab.langString.value:\n        return Rdf.langLiteral(N3Util.getLiteralValue(literal), N3Util.getLiteralLanguage(literal));\n      default:\n        return Rdf.literal(N3Util.getLiteralValue(literal), Rdf.iri(N3Util.getLiteralType(literal)));\n    }\n  }\n\n  /**\n   * Create streaming Turtle parser.\n   */\n  export function initN3Parser(emitter: Kefir.Emitter<Rdf.Triple>, turtle: string): N3.Parser {\n    const parser = N3.Parser();\n    parser.parse(turtle, (error, triple, prefixes) => {\n      if (error) {\n        emitter.error(error);\n      }\n      if (triple != null) {\n        emitter.emit(n3TripleToRdf(triple));\n      } else {\n        emitter.end();\n      }\n    });\n    return parser;\n  }\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as Immutable from 'immutable';\nimport * as _ from 'lodash';\nimport * as SparqlJs from 'sparqljs';\n\nimport {\n  isQuery,\n  isStarProjection,\n  isPattern,\n  isBlockPattern,\n  isExpression,\n  isQuads,\n  isTerm,\n  isVariable,\n  isLiteral,\n  isBlank,\n  isIri,\n  isInsertDeleteOperation,\n  isManagementOperation,\n} from './TypeGuards';\n\nexport type QueryNodeCollection =\n  | 'from.default'\n  | 'from.named'\n  | 'updates'\n  | 'insert'\n  | 'delete'\n  | 'template'\n  | 'variables'\n  | 'where'\n  | 'group'\n  | 'having'\n  | 'order'\n  | 'triples'\n  | 'patterns'\n  | 'args'\n  | 'items';\nexport type QueryNodeMember = 'expression' | 'name' | 'variable' | 'values' | 'subject' | 'predicate' | 'object';\n\nexport class QueryVisitor {\n  private nodeMember: QueryNodeCollection | QueryNodeMember;\n\n  protected get currentMember() {\n    return this.nodeMember;\n  }\n\n  protected visitMember<Node, Member extends keyof Node & QueryNodeMember>(\n    node: Node,\n    member: Member,\n    visit: (this: this, x: Node[Member]) => Node[Member] | undefined\n  ): Node[Member] | undefined {\n    this.nodeMember = member;\n    const memberName: Member = member;\n    const result = visit.call(this, node[memberName]);\n    if (result !== undefined) {\n      node[memberName] = result;\n    }\n    return result;\n  }\n\n  sparqlQuery(sparqlQuery: SparqlJs.SparqlQuery): SparqlJs.SparqlQuery {\n    if (sparqlQuery.type === 'query') {\n      return this.query(sparqlQuery);\n    } else if (sparqlQuery.type === 'update') {\n      return this.update(sparqlQuery);\n    }\n  }\n\n  query(query: SparqlJs.Query): SparqlJs.Query {\n    if (query.queryType === 'SELECT') {\n      const result = this.select(query);\n      if (result === undefined) {\n        return undefined;\n      } else if (isQuery(result)) {\n        return result;\n      } else {\n        this.throwUnexpected(result, { expected: 'Query', transformed: 'SelectQuery' });\n      }\n    } else if (query.queryType === 'CONSTRUCT') {\n      return this.construct(query);\n    } else if (query.queryType === 'ASK') {\n      return this.ask(query);\n    } else if (query.queryType === 'DESCRIBE') {\n      return this.describe(query);\n    }\n  }\n\n  update(update: SparqlJs.Update): SparqlJs.Update {\n    this.walkArray('updates', update.updates, this.updateOperation);\n    return undefined;\n  }\n\n  updateOperation(update: SparqlJs.UpdateOperation): SparqlJs.UpdateOperation {\n    if (isInsertDeleteOperation(update)) {\n      return this.insertDelete(update);\n    } else if (isManagementOperation(update)) {\n      return this.managementOperation(update);\n    } else {\n      console.warn(`Unknown UpdateOperation object ${JSON.stringify(update)}`);\n      return undefined;\n    }\n  }\n\n  insertDelete(operation: SparqlJs.InsertDeleteOperation): SparqlJs.UpdateOperation {\n    this.walkArray('insert', operation.insert, this.quads);\n    this.walkArray('delete', operation.delete, this.quads);\n    this.walkArray('where', operation.where, this.pattern);\n    return undefined;\n  }\n\n  managementOperation(operation: SparqlJs.ManagementOperation): SparqlJs.UpdateOperation {\n    return undefined;\n  }\n\n  valuesRows(rows: SparqlJs.ValuePatternRow[]): SparqlJs.ValuePatternRow[] {\n    const transforms = this.walkValuesVariables(rows);\n    rows.forEach((row) => {\n      for (const variable in row) {\n        if (row.hasOwnProperty(variable)) {\n          let resultVariable = variable;\n\n          const transformedVariable = transforms.get(variable);\n          if (transformedVariable !== undefined) {\n            row[transformedVariable] = row[variable];\n            delete row[variable];\n            resultVariable = transformedVariable;\n          }\n\n          const value = row[resultVariable];\n          const valueResult = this.term(value);\n          if (valueResult !== undefined) {\n            row[resultVariable] = this.coerce(valueResult, (t) => isTerm(t) && t, {\n              expected: 'Term',\n              transformed: 'VALUES row value',\n            });\n          }\n        }\n      }\n    });\n    return undefined;\n  }\n\n  /**\n   * @return replacements for VALUES() block variables, in a form\n   *   { oldVariableTerm -> newVariableTerm }\n   */\n  protected walkValuesVariables(rows: SparqlJs.ValuePatternRow[]): Immutable.Map<string, string> {\n    // find complete set of VALUES pattern variables\n    // e.g. VALUES(?v1 ?v2 ?v3) -> {?v1, ?v2, ?v3}\n    const variables = Immutable.List(rows).reduce((vars, row) => {\n      for (const variable in row) {\n        if (!row.hasOwnProperty(variable)) {\n          continue;\n        }\n        vars = vars.add(variable as SparqlJs.Term);\n      }\n      return vars;\n    }, Immutable.Set<SparqlJs.Term>());\n    // try to transform each variable (walk over it)\n    return variables.reduce((transforms, variable) => {\n      const result = this.variableTerm(variable);\n      if (result === undefined) {\n        return transforms;\n      } else if (isVariable(result)) {\n        return transforms.set(variable, result);\n      } else {\n        this.throwUnexpected(result, { expected: '?variable', transformed: 'variable Term' });\n      }\n    }, Immutable.Map<string, string>());\n  }\n\n  select(select: SparqlJs.SelectQuery): SparqlJs.Query | SparqlJs.Pattern {\n    this.walkBaseQuery(select);\n    this.walkProjectionVariables(select.variables);\n\n    if (select.from) {\n      const walkOnlyIri = (iri: SparqlJs.Term) =>\n        this.coerce(this.iri(iri), (term) => isIri(term) && term, { expected: '<iri>', transformed: 'IRI Term' });\n      this.walkArray('from.default', select.from.default, walkOnlyIri);\n      this.walkArray('from.named', select.from.named, walkOnlyIri);\n    }\n\n    this.walkArray('group', select.group, this.grouping);\n    this.walkArray('having', select.having, this.expression);\n    this.walkArray('order', select.order, this.ordering);\n    return undefined;\n  }\n\n  grouping(grouping: SparqlJs.Grouping): SparqlJs.Grouping {\n    this.visitMember(grouping, 'expression', this.expression);\n    return undefined;\n  }\n\n  ordering(ordering: SparqlJs.Ordering): SparqlJs.Ordering {\n    this.visitMember(ordering, 'expression', this.expression);\n    return undefined;\n  }\n\n  construct(construct: SparqlJs.ConstructQuery): SparqlJs.Query {\n    this.walkBaseQuery(construct);\n    this.walkArray('template', construct.template, this.triple);\n    return undefined;\n  }\n\n  ask(ask: SparqlJs.AskQuery): SparqlJs.Query {\n    this.walkBaseQuery(ask);\n    return undefined;\n  }\n\n  describe(describe: SparqlJs.DescribeQuery): SparqlJs.Query {\n    this.walkBaseQuery(describe);\n    this.walkProjectionVariables(describe.variables);\n    return undefined;\n  }\n\n  pattern(pattern: SparqlJs.Pattern): SparqlJs.Pattern {\n    if (pattern.type === 'bgp') {\n      return this.coerce(this.bgp(pattern), (bgp) => isPattern(bgp) && bgp, {\n        expected: 'Pattern',\n        transformed: 'BgpPattern',\n      });\n    } else if (isBlockPattern(pattern)) {\n      return this.block(pattern);\n    } else if (pattern.type === 'filter') {\n      return this.filter(pattern);\n    } else if (pattern.type === 'bind') {\n      return this.bind(pattern);\n    } else if (pattern.type === 'values') {\n      return this.valuesPattern(pattern);\n    } else if (isQuery(pattern)) {\n      const queryType: string = pattern.queryType;\n      if (queryType !== 'SELECT') {\n        throw new Error(`Invalid query Pattern: unexpected ${queryType} query`);\n      }\n      return this.coerce(this.select(pattern), (p) => isPattern(p) && p, {\n        expected: 'Pattern',\n        transformed: 'SelectQuery',\n      });\n    } else {\n      console.warn(`Unknown pattern '${JSON.stringify(pattern)}'`);\n      return undefined;\n    }\n  }\n\n  quads(quads: SparqlJs.Quads): SparqlJs.Quads {\n    if (quads.type === 'bgp') {\n      return this.coerce(this.bgp(quads), (bgp) => isQuads(bgp) && bgp, {\n        expected: 'Quads',\n        transformed: 'SelectQuery',\n      });\n    } else if (quads.type === 'graph') {\n      return this.graphQuads(quads);\n    } else {\n      console.warn(`Unknown quads '${JSON.stringify(quads)}'`);\n      return undefined;\n    }\n  }\n\n  bgp(bgp: SparqlJs.BgpPattern): SparqlJs.Expression | SparqlJs.Pattern | SparqlJs.Quads {\n    this.walkArray('triples', bgp.triples, this.triple);\n    return undefined;\n  }\n\n  graphQuads(graphQuads: SparqlJs.GraphQuads): SparqlJs.Quads {\n    this.visitMember(graphQuads, 'name', (name) => {\n      const term = this.term(name);\n      return this.coerce(term, (t) => isTerm(t) && t, { expected: 'Term', transformed: 'GraphQuads' });\n    });\n    this.walkArray('triples', graphQuads.triples, this.triple);\n    return undefined;\n  }\n\n  block(pattern: SparqlJs.BlockPattern): SparqlJs.Pattern {\n    if (pattern.type === 'graph') {\n      return this.graph(pattern as SparqlJs.GraphPattern);\n    } else if (pattern.type === 'service') {\n      return this.service(pattern as SparqlJs.ServicePattern);\n    } else {\n      this.walkArray('patterns', pattern.patterns, this.pattern);\n      return undefined;\n    }\n  }\n\n  graph(graph: SparqlJs.GraphPattern): SparqlJs.Pattern {\n    this.visitMember(graph, 'name', (name) => {\n      const term = this.term(name);\n      return this.coerce(term, (t) => isTerm(t) && t, { expected: 'Term', transformed: 'GraphPattern' });\n    });\n    this.walkArray('patterns', graph.patterns, this.pattern);\n    return undefined;\n  }\n\n  service(service: SparqlJs.ServicePattern): SparqlJs.Pattern {\n    this.visitMember(service, 'name', (name) => {\n      const term = this.term(name);\n      return this.coerce(term, (t) => isTerm(t) && t, { expected: 'Term', transformed: 'ServicePattern' });\n    });\n    this.walkArray('patterns', service.patterns, this.pattern);\n    return undefined;\n  }\n\n  filter(pattern: SparqlJs.FilterPattern): SparqlJs.Pattern {\n    this.visitMember(pattern, 'expression', this.expression);\n    return undefined;\n  }\n\n  bind(pattern: SparqlJs.BindPattern): SparqlJs.Pattern {\n    this.visitMember(pattern, 'expression', this.expression);\n    this.visitMember(pattern, 'variable', (variable) => {\n      const variableTerm = this.variableTerm(variable);\n      return this.coerce(variableTerm, (v) => isVariable(v) && v, {\n        expected: '?variable',\n        transformed: 'variable Term',\n      });\n    });\n    return undefined;\n  }\n\n  valuesPattern(pattern: SparqlJs.ValuesPattern): SparqlJs.Pattern {\n    this.visitMember(pattern, 'values', this.valuesRows);\n    return undefined;\n  }\n\n  expression(expression: SparqlJs.Expression): SparqlJs.Expression {\n    if (Array.isArray(expression)) {\n      return this.tuple(expression);\n    } else if (isTerm(expression)) {\n      return this.coerce(this.term(expression), (expr) => isExpression(expr) && expr, {\n        expected: 'Expression',\n        transformed: 'term-like Expression',\n      });\n    } else if (expression.type === 'operation') {\n      return this.operation(expression);\n    } else if (expression.type === 'functionCall') {\n      return this.functionCall(expression);\n    } else if (expression.type === 'aggregate') {\n      return this.aggregate(expression);\n    } else if (isPattern(expression)) {\n      return this.walkPatternLikeExpression(expression);\n    } else {\n      console.warn(`Unknown expression '${JSON.stringify(expression)}'`);\n      return undefined;\n    }\n  }\n\n  protected walkPatternLikeExpression(expression: SparqlJs.Pattern): SparqlJs.Expression {\n    let result: SparqlJs.Expression | SparqlJs.Pattern | SparqlJs.Quads = undefined;\n    if (expression.type === 'bgp') {\n      result = this.bgp(expression);\n    } else if (expression.type === 'group') {\n      result = this.block(expression);\n    } else {\n      console.warn(`Unknown pattern-like Expression type '${expression.type}'`);\n    }\n\n    return this.coerce(result, (expr) => isExpression(expr) && expr, {\n      expected: 'Expression',\n      transformed: 'pattern-like Expression',\n    });\n  }\n\n  operation(operation: SparqlJs.OperationExpression): SparqlJs.Expression {\n    this.walkArray('args', operation.args, this.expression);\n    return undefined;\n  }\n\n  functionCall(functionCall: SparqlJs.FunctionCallExpression): SparqlJs.Expression {\n    this.walkArray('args', functionCall.args, this.expression);\n    return undefined;\n  }\n\n  aggregate(aggregate: SparqlJs.AggregateExpression): SparqlJs.Expression {\n    this.visitMember(aggregate, 'expression', this.expression);\n    return undefined;\n  }\n\n  variable(variable: SparqlJs.Variable): SparqlJs.Variable {\n    if (isTerm(variable)) {\n      const variableTerm = this.variableTerm(variable);\n      return this.coerce(variableTerm, (v) => isVariable(v) && v, {\n        expected: '?variable',\n        transformed: 'variable Term',\n      });\n    } else {\n      this.visitMember(variable, 'expression', this.expression);\n      this.visitMember(variable, 'variable', (variableName) => {\n        const variableTerm = this.variableTerm(variableName);\n        return this.coerce(variableTerm, (v) => isVariable(v) && v, {\n          expected: '?variable',\n          transformed: 'variable Term',\n        });\n      });\n      return undefined;\n    }\n  }\n\n  tuple(tuple: SparqlJs.Tuple): SparqlJs.Expression {\n    this.walkArray<SparqlJs.Expression>(undefined, tuple, this.expression);\n    return undefined;\n  }\n\n  triple(triple: SparqlJs.Triple): SparqlJs.Triple {\n    this.visitMember(triple, 'subject', (subject) => {\n      const term = this.term(subject);\n      return this.coerce(term, (t) => isTerm(t) && t, { expected: 'Term', transformed: 'subject Term' });\n    });\n\n    this.visitMember(triple, 'predicate', (predicate) =>\n      isTerm(predicate) ? this.term(predicate as SparqlJs.Term) : this.propertyPath(predicate as SparqlJs.PropertyPath)\n    );\n\n    this.visitMember(triple, 'object', (object) => {\n      const term = this.term(object);\n      return this.coerce(term, (t) => isTerm(t) && t, { expected: 'Term', transformed: 'object Term' });\n    });\n\n    return undefined;\n  }\n\n  term(term: SparqlJs.Term): SparqlJs.Term | SparqlJs.PropertyPath {\n    if (term === undefined) {\n      return undefined;\n    } else if (isVariable(term)) {\n      return this.variableTerm(term);\n    } else if (isLiteral(term)) {\n      return this.literal(term);\n    } else if (isBlank(term)) {\n      return this.blank(term);\n    } else if (isIri(term)) {\n      return this.iri(term);\n    }\n    return undefined;\n  }\n\n  variableTerm(variable: SparqlJs.Term): SparqlJs.Term | SparqlJs.PropertyPath {\n    return undefined;\n  }\n\n  literal(literal: SparqlJs.Term): SparqlJs.Term | SparqlJs.PropertyPath {\n    return undefined;\n  }\n\n  blank(blank: SparqlJs.Term): SparqlJs.Term | SparqlJs.PropertyPath {\n    return undefined;\n  }\n\n  iri(iri: SparqlJs.Term): SparqlJs.Term | SparqlJs.PropertyPath {\n    return undefined;\n  }\n\n  propertyPath(path: SparqlJs.PropertyPath): SparqlJs.Term | SparqlJs.PropertyPath {\n    this.walkArray('items', path.items, (item) => (isTerm(item) ? this.term(item) : this.propertyPath(item)));\n    return undefined;\n  }\n\n  protected walkBaseQuery(query: SparqlJs.Query) {\n    if (query.where) {\n      this.walkArray('where', query.where, this.pattern);\n    }\n    if (query.values) {\n      this.visitMember(query, 'values', this.valuesRows);\n    }\n  }\n\n  protected walkProjectionVariables(variables: SparqlJs.Variable[] | ['*']) {\n    if (!isStarProjection(variables)) {\n      this.walkArray('variables', variables, this.variable);\n    }\n  }\n\n  protected walkArray<T>(collectionName: QueryNodeCollection, nodes: T[], walk: (this: this, node: T) => T) {\n    if (nodes === null || nodes === undefined) {\n      return;\n    }\n    this.nodeMember = collectionName;\n    let index = 0;\n    while (index < nodes.length) {\n      if (nodes[index]) {\n        index = this.walkItem(nodes, index, walk);\n      } else {\n        index++;\n      }\n    }\n  }\n\n  protected walkItem<T>(nodes: T[], index: number, walk: (this: this, node: T) => T): number {\n    const result = walk.call(this, nodes[index]);\n    if (result !== undefined) {\n      nodes[index] = result;\n    }\n    return index + 1;\n  }\n\n  protected coerce<Coerced, Value>(\n    value: Value | undefined,\n    coerce: (input: Value) => Coerced | false,\n    names: { expected: string; transformed: string }\n  ): Coerced | undefined {\n    if (value === undefined) {\n      return undefined;\n    }\n    const coerced = coerce(value);\n    if (typeof coerced === 'boolean') {\n      this.throwUnexpected(value, names);\n    } else {\n      return coerced;\n    }\n  }\n\n  protected throwUnexpected<T>(value: T, names: { expected: string; transformed: string }) {\n    throw new Error(\n      `${names.expected} is expected as result of ${names.transformed} ` +\n        `transformation but ${JSON.stringify(value)} was given`\n    );\n  }\n}\n\n/**\n * Creates a full deep clone of SparqlQuery object from SparqlJS library.\n *\n * By default when parsing query using SparqlJs.Parser component\n * SparqlQuery.prefixes property will be initialized to empty object\n * with [[Prototype]] set to prefixes map passed to Parser's constructor.\n * This method preserves a prototype of the prefixes object.\n */\nexport function cloneQuery<T extends SparqlJs.SparqlQuery>(query: T): T {\n  const clone = _.cloneDeep(query);\n  if (query.prefixes && Object.getPrototypeOf(query.prefixes) !== Object.getPrototypeOf(clone.prefixes)) {\n    clone.prefixes = Object.create(Object.getPrototypeOf(query.prefixes));\n    for (const key in query.prefixes) {\n      if (query.prefixes.hasOwnProperty(key)) {\n        clone.prefixes[key] = query.prefixes[key];\n      }\n    }\n  }\n  return clone;\n}\n\nexport default QueryVisitor;\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Affero General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU Affero General Public License for more details.\n *\n * You should have received a copy of the GNU Affero General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { ParsedTemplate } from './TemplateCommons';\n\nexport const remoteTemplateCache = new Map<string, Promise<ParsedTemplate>>();\nexport function purgeRemoteTemplateCache() {\n  remoteTemplateCache.clear();\n}\n\nexport const defaultContextCache = new Map<string, HandlebarsTemplateDelegate>();\n\nexport function purgeTemplateCache() {\n  defaultContextCache.clear();\n  purgeRemoteTemplateCache();\n}\n\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { ComponentClass } from 'react';\n\n/**\n * That is a special require, custom-components module will be generated by\n * webpack custom componentsLoader that uses component.json file to create\n * set of dynamic 'System.import' for web components.\n */\nconst components = require('platform-components');\n\n/**\n * Asynchronously load JS file for React based web-component.\n */\nexport function loadComponent(tagName: string): Promise<ComponentClass<any>> {\n  if (hasComponent(tagName)) {\n    return components(tagName).then((component) => {\n      const comp = component.default ? component.default : component;\n      return comp;\n    });\n  } else {\n    console.warn('component not found for tag ' + tagName);\n  }\n}\n\n/**\n * Check if there is React component that corresponds to tagName.\n */\nexport function hasComponent(tagName: string): boolean {\n  const loader = components(tagName);\n  if (loader) {\n    return true;\n  } else {\n    return false;\n  }\n}\n\nexport interface ComponentClassMetadata {\n  __htmlTag?: string;\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as _ from 'lodash';\nimport * as Maybe from 'data.maybe';\nimport * as Immutable from 'immutable';\n\nimport { serializer, deserializer } from 'platform/api/json';\n\nmodule Rdf {\n  export type TermType = 'NamedNode' | 'BlankNode' | 'Literal' | 'Variable' | 'DefaultGraph';\n\n  export abstract class Node {\n    private _value: string;\n\n    constructor(value: string) {\n      this._value = value;\n    }\n\n    abstract get termType(): TermType;\n\n    get value(): string {\n      return this._value;\n    }\n\n    public static cata<T>(onIri: (iri: Iri) => T, onLiteral: (literal: Literal) => T, onBnode: (bnode: BNode) => T) {\n      return (node: Node) => {\n        if (node.isIri()) {\n          return onIri(<Iri>node);\n        } else if (node.isLiteral()) {\n          return onLiteral(<Literal>node);\n        } else {\n          return onBnode(<BNode>node);\n        }\n      };\n    }\n\n    public hashCode() {\n      return hashString(this.value);\n    }\n\n    public equals(other: Node) {\n      if (!other || typeof other !== 'object') {\n        return false;\n      } else {\n        return this.value === other.value;\n      }\n    }\n\n    public cata<T>(onIri: (iri: Iri) => T, onLiteral: (literal: Literal) => T, onBnode: (bnode: BNode) => T) {\n      return Node.cata(onIri, onLiteral, onBnode)(this);\n    }\n\n    public isIri(): this is Rdf.Iri {\n      return this instanceof Iri;\n    }\n\n    public isLiteral(): this is Rdf.Literal {\n      return this instanceof Literal;\n    }\n\n    public isBnode(): this is BNode {\n      return this instanceof BNode;\n    }\n\n    abstract toJSON(): any;\n\n    public toString(): string {\n      throw Error('Node.toString() is not implemented');\n    }\n  }\n\n  export class Iri extends Node {\n    get termType(): 'NamedNode' {\n      return 'NamedNode';\n    }\n\n    public equals(other: Node) {\n      return super.equals(other) && other instanceof Rdf.Iri;\n    }\n\n    public toString() {\n      return `<${this.value}>`;\n    }\n\n    @serializer\n    toJSON() {\n      return {\n        termType: 'NamedNode',\n        value: this.value,\n      };\n    }\n\n    @deserializer\n    static fromJSON(obj: Pick<Iri, 'value'>) {\n      return new Iri(obj.value);\n    }\n  }\n  export function iri(value: string) {\n    return new Iri(value);\n  }\n\n  /**\n   * Convert <> enclosed Iri into [Rdf.Iri];\n   * @param value full iri enclosed in <>\n   */\n  export function fullIri(value: string): Rdf.Iri {\n    if (_.startsWith(value, '<') && _.endsWith(value, '>')) {\n      // remove '<' and '>' form iri string\n      return iri(value.slice(1, -1));\n    } else {\n      throw new Error('Expected IRI to be enclosed in <>, for ' + value);\n    }\n  }\n\n  export const BASE_IRI = iri('');\n\n  const RDF_LANG_STRING = iri('http://www.w3.org/1999/02/22-rdf-syntax-ns#langString');\n  const XSD_STRING = iri('http://www.w3.org/2001/XMLSchema#string');\n  const XSD_BOOLEAN = iri('http://www.w3.org/2001/XMLSchema#boolean');\n\n  export class Literal extends Node {\n    private _datatype: Iri;\n    private _lang: string;\n\n    constructor(value: string, datatypeOrLanguage: Iri | string) {\n      super(value);\n      if (typeof datatypeOrLanguage === 'string') {\n        this._datatype = RDF_LANG_STRING;\n        this._lang = datatypeOrLanguage;\n      } else {\n        this._datatype = datatypeOrLanguage;\n        this._lang = '';\n      }\n    }\n\n    get termType(): 'Literal' {\n      return 'Literal';\n    }\n\n    get datatype(): Iri {\n      return this._datatype;\n    }\n\n    get language(): string {\n      return this._lang;\n    }\n\n    public toString() {\n      return this.language ? `\"${this.value}\"@${this.language}` : `\"${this.value}\"^^${this.datatype.toString()}`;\n    }\n\n    public equals(other: Node) {\n      if (!other || typeof other !== 'object') {\n        return false;\n      } else {\n        return (\n          other instanceof Literal &&\n          this.value === other.value &&\n          this.datatype.equals(other.datatype) &&\n          this.language === other.language\n        );\n      }\n    }\n\n    @serializer\n    toJSON() {\n      return {\n        termType: 'Literal',\n        value: this.value,\n        datatype: this.datatype,\n        language: this.language,\n      };\n    }\n\n    @deserializer\n    static fromJSON(\n      obj: Pick<Literal, 'value' | 'datatype' | 'language'> & { readonly dataType?: Rdf.Iri; readonly lang?: string }\n    ): Literal {\n      // preserve backwards-compatibility with previous serialization\n      const datatype = obj.datatype ? Iri.fromJSON(obj.datatype) : obj.dataType;\n      const language = typeof obj.language === 'string' ? obj.language : obj.lang;\n      return new Literal(obj.value, language ? language : datatype);\n    }\n  }\n\n  export function literal(value: string | boolean, dataType?: Iri) {\n    if (typeof value === 'boolean') {\n      return new Literal(value.toString(), XSD_BOOLEAN);\n    } else {\n      if (dataType === undefined) {\n        return new Literal(value, XSD_STRING);\n      } else {\n        return new Literal(value, dataType);\n      }\n    }\n  }\n\n  export function langLiteral(value: string, lang: string): Literal {\n    return new Literal(value, lang);\n  }\n\n  export class BNode extends Node {\n    get termType(): 'BlankNode' {\n      return 'BlankNode';\n    }\n\n    public toString() {\n      return `${this.value}`;\n    }\n\n    @serializer\n    public toJSON() {\n      return {\n        termType: 'BlankNode',\n        value: this.value,\n      };\n    }\n\n    @deserializer\n    static fromJSON(obj: Pick<BNode, 'value'>): BNode {\n      return new BNode(obj.value);\n    }\n  }\n\n  export function bnode(value?: string) {\n    if (_.isUndefined(value)) {\n      return new BNode('_:' + Math.random().toString(36).substring(7));\n    } else {\n      return new BNode(value.startsWith('_:') ? value : '_:' + value);\n    }\n  }\n\n  export class Triple {\n    private _s: Node;\n    private _p: Iri;\n    private _o: Node;\n    private _g: Iri;\n\n    constructor(s: Node, p: Iri, o: Node, g: Iri = DEFAULT_GRAPH) {\n      this._s = s;\n      this._p = p;\n      this._o = o;\n      this._g = g;\n    }\n\n    get s(): Node {\n      return this._s;\n    }\n\n    get p(): Iri {\n      return this._p;\n    }\n\n    get o(): Node {\n      return this._o;\n    }\n\n    get g(): Iri {\n      return this._g;\n    }\n\n    public hashCode() {\n      const prime = 31;\n      let result = 1;\n      result = prime * result + (this.s == null ? 0 : this.s.hashCode());\n      result = prime * result + (this.p == null ? 0 : this.p.hashCode());\n      result = prime * result + (this.o == null ? 0 : this.o.hashCode());\n      result = prime * result + (_.isUndefined(this.g) ? 0 : this.g.hashCode());\n      return result;\n    }\n  }\n\n  export function triple(s: Node, p: Iri, o: Node, g?: Rdf.Iri) {\n    return new Triple(s, p, o, g);\n  }\n\n  export class Graph {\n    private _triples: Immutable.Set<Triple>;\n\n    constructor(triples: Immutable.Set<Triple>) {\n      this._triples = triples;\n    }\n\n    get triples(): Immutable.Set<Triple> {\n      return this._triples;\n    }\n  }\n\n  export function graph(triples: ReadonlyArray<Triple> | Immutable.Set<Triple>): Rdf.Graph {\n    return new Graph(Immutable.Set<Triple>(triples));\n  }\n\n  export function union(...graphs: Graph[]): Rdf.Graph {\n    return graph(\n      Immutable.Set(graphs)\n        .map((g) => g.triples)\n        .flatten() as Immutable.Set<Triple>\n    );\n  }\n\n  export class PointedGraph {\n    private _pointer: Node;\n    private _graph: Graph;\n\n    constructor(pointer: Node, graph: Rdf.Graph) {\n      this._pointer = pointer;\n      this._graph = graph;\n    }\n\n    get pointer(): Node {\n      return this._pointer;\n    }\n\n    get graph(): Rdf.Graph {\n      return this._graph;\n    }\n  }\n  export function pg(pointer: Node, graph: Graph) {\n    return new PointedGraph(pointer, graph);\n  }\n\n  // http://jsperf.com/hashing-strings\n  export function hashString(string: string) {\n    // This is the hash from JVM\n    // The hash code for a string is computed as\n    // s[0] * 31 ^ (n - 1) + s[1] * 31 ^ (n - 2) + ... + s[n - 1],\n    // where s[i] is the ith character of the string and n is the length of\n    // the string. We \"mod\" the result to make it between 0 (inclusive) and 2^31\n    // (exclusive) by dropping high bits.\n    let hash = 0;\n    for (let ii = 0; ii < string.length; ii++) {\n      hash = (31 * hash + string.charCodeAt(ii)) | 0;\n    }\n    return smi(hash);\n  }\n\n  // v8 has an optimization for storing 31-bit signed numbers.\n  // Values which have either 00 or 11 as the high order bits qualify.\n  // This function drops the highest order bit in a signed number, maintaining\n  // the sign bit.\n  export function smi(i32: number) {\n    return ((i32 >>> 1) & 0x40000000) | (i32 & 0xbfffffff);\n  }\n\n  export const DEFAULT_GRAPH = new Iri('default');\n  export const EMPTY_GRAPH = graph([]);\n\n  export function getValueFromPropertyPath<T extends Rdf.Node = Rdf.Node>(\n    propertyPath: Array<Rdf.Iri>,\n    pg: Rdf.PointedGraph\n  ): Data.Maybe<T> {\n    const values = getValuesFromPropertyPath(propertyPath, pg);\n    if (values.length > 1) {\n      throw new Error('more than one value found in the graph for property path ' + propertyPath);\n    }\n    return Maybe.fromNullable(getValuesFromPropertyPath(propertyPath, pg)[0]) as Data.Maybe<T>;\n  }\n\n  export function getValuesFromPropertyPath<T extends Rdf.Node = Rdf.Node>(\n    propertyPath: Array<Rdf.Iri>,\n    pg: Rdf.PointedGraph\n  ): Array<T> {\n    // reduce property path from left to right traversing the graph\n    const nodes = _.reduce(\n      propertyPath,\n      (ss, p) =>\n        _.flatMap(ss, (iri) => pg.graph.triples.filter((t) => t.s.equals(iri) && t.p.equals(p)).toArray()).map(\n          (t) => t.o\n        ),\n      [pg.pointer]\n    );\n    return _.uniqBy(nodes, (node) => node.value) as Array<T>;\n  }\n\n  /**\n   * Extracts local name for URI the same way as it's done in RDF4J.\n   */\n  export function getLocalName(uri: string): string | undefined {\n    let index = uri.indexOf('#');\n    if (index < 0) {\n      index = uri.lastIndexOf('/');\n    }\n    if (index < 0) {\n      index = uri.lastIndexOf(':');\n    }\n    if (index < 0) {\n      return undefined;\n    }\n    return uri.substring(index + 1);\n  }\n}\n\nexport = Rdf;\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { Component, Children, createFactory } from 'react';\nimport * as PropTypes from 'prop-types';\n\nimport { Rdf, turtle } from 'platform/api/rdf';\nimport { QueryContext } from 'platform/api/sparql';\n\nexport interface SemanticConfigProps {\n  /**\n   * Repository ID as registered in the platform repository manager.\n   * Queries will be executed/evaluated against this repository.\n   *\n   * @default \"default\"\n   */\n  repository?: string;\n  /**\n   * Specifies the default graph, i.e. will be translated into a FROM <graphiri> clause.\n   * Several default graphs will be interpreted as a single merge graph, i.e. according to the SPARQL 1.1 standard:\n   * \"A default graph consisting of the RDF merge of the graphs referred to in the FROM clauses.\"\n   *\n   * Defaults to an empty array, which usually means all graphs.\n   * However, this may differ across database vendors (for example, in Stardog you will have to configure the database with query.all.graphs=true )\n   *\n   * See <a href='https://www.w3.org/TR/rdf-sparql-query/#unnamedGraph' target='_blank'> https://www.w3.org/TR/rdf-sparql-query/#unnamedGraph </a> for details.\n   *\n   * This functionality is still beta and not yet well tested.\n   */\n  defaultGraphs?: Array<string>;\n  /**\n   * List of named graphs that will restrict any GRAPH ?g{} clause within the query body to the enumerated graphs.\n   *\n   * See <a href='https://www.w3.org/TR/rdf-sparql-query/#namedGraphs' target='_blank'>https://www.w3.org/TR/rdf-sparql-query/#namedGraphs</a> for details.\n   *\n   * This functionality is still beta and not yet well tested.\n   */\n  namedGraphs?: Array<string>;\n  /**\n   * A string indexed map (object), of key value pairs to inject into queries.\n   * The key is the plain binding name (without ? or $) and the value is the plain IRI or literal value to be injected.\n   *\n   * The interface and implementation is not yet stable and might be changed or even be removed in the future without notice.\n   */\n  bindings?: { [binding: string]: string | Rdf.Node };\n}\n\nexport interface SemanticContext {\n  readonly semanticContext: QueryContext;\n}\n\nexport const SemanticContextTypes: { [K in keyof SemanticContext]: any } = {\n  semanticContext: PropTypes.object,\n};\n\n/**\n * Component that propagates down SPARQL query context.\n * Nested context would be merged with parent one, overriding\n * repository and bindings with the same keys.\n *\n * @example\n * <semantic-context repository='assets'\n *   named-graphs='[\"http://graph2\", \"http://graph2\"]'\n *   default-graphs='[\"http://graph3\", \"http://graph4\"]'\n *   bindings='{\"var1\": \"http://some-iri\",\n *     \"var2\": \"\\\\\"42\\\\\"^^<http://www.w3.org/2001/XMLSchema#integer>\"}'>\n *   <semantic-table query=\"SELECT * WHERE { ?x a ?var1 }\"></semantic-table>\n * </semantic-context>\n *\n * @author Alexey Morozov\n */\nexport class SemanticContextProvider extends Component<SemanticConfigProps, {}> {\n  static childContextTypes = SemanticContextTypes;\n  static contextTypes = SemanticContextTypes;\n\n  context: SemanticContext;\n\n  getChildContext(): SemanticContext {\n    const parentContext: QueryContext = (this.context && this.context.semanticContext) || {};\n    const { repository, bindings, defaultGraphs, namedGraphs } = deserializeContext(this.props);\n    const semanticContext: QueryContext = {\n      repository,\n      defaultGraphs,\n      namedGraphs,\n      bindings: mergeIfDefined(parentContext.bindings, bindings),\n      isDefault: false,\n    };\n    return { semanticContext };\n  }\n\n  render() {\n    return Children.only(this.props.children);\n  }\n}\n\nexport class BaseSemanticContextProvider extends SemanticContextProvider {\n  getChildContext(): SemanticContext {\n    const context = super.getChildContext();\n    return { semanticContext: { ...context.semanticContext, isDefault: true } };\n  }\n}\n\nfunction deserializeContext(props: SemanticConfigProps): QueryContext {\n  const bindings: { [binding: string]: Rdf.Node } = {};\n  let hasAnyBinding = false;\n\n  if (props.bindings) {\n    for (const key in props.bindings) {\n      if (!props.bindings.hasOwnProperty(key)) {\n        continue;\n      }\n      let value = props.bindings[key];\n      if (typeof value === 'string') {\n        value = turtle.deserialize.n3ValueToRdf(value);\n      }\n      bindings[key] = value;\n      hasAnyBinding = true;\n    }\n  }\n\n  return {\n    repository: props.repository,\n    defaultGraphs: props.defaultGraphs,\n    namedGraphs: props.namedGraphs,\n    bindings: hasAnyBinding ? bindings : undefined,\n  };\n}\n\nfunction mergeIfDefined<T>(first: T | undefined, second: T | undefined): T | undefined {\n  if (first && second) {\n    return { ...(first as any), ...(second as any) };\n  } else if (first) {\n    return first;\n  } else if (second) {\n    return second;\n  } else {\n    return undefined;\n  }\n}\n\nexport type component = SemanticContextProvider;\nexport const component = SemanticContextProvider;\nexport const factory = createFactory(component);\nexport default component;\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as _ from 'lodash';\n\nexport interface ParamMap {\n  [index: string]: string;\n}\n\nexport const QUERY_PARAM_PREFIX = 'urlqueryparam';\n\n/**\n * Extracts all values from object where key starts with 'paramPrefix',\n * drops `paramPrefix`.\n *\n * Useful in web-components that needs to accept additional\n * arbitrary query parameters for url.\n *\n * For example lets say we have `paramPrefix` = 'urlqueryparam' and\n * the following object:\n * {\n *   urlqueryparamParamA: 'a',\n *   urlqueryparamParamB: 'b',\n *   someProp: 'c'\n * }\n *\n * As result of the transformation we will get:\n * {\n *   paramA: 'a',\n *   paramB: 'b'\n * }\n */\nexport function extractParams(props: {}, paramPrefix: string = QUERY_PARAM_PREFIX): ParamMap {\n  return _.transform(props, (res: ParamMap, value: any, key: string) => {\n    if (_.startsWith(key, paramPrefix)) {\n      const propName = _.camelCase(key.substr(paramPrefix.length));\n      res[propName] = value;\n    }\n    return res;\n  });\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nconst h = require('history');\nimport * as React from 'react';\nimport * as _ from 'lodash';\nimport * as Kefir from 'kefir';\nimport * as uri from 'urijs';\nimport * as Maybe from 'data.maybe';\n\nimport { Rdf } from 'platform/api/rdf';\nimport { SparqlUtil } from 'platform/api/sparql';\nimport { getPrefixedUri, getFullIri } from 'platform/api/services/namespace';\nimport { ConfigHolder } from 'platform/api/services/config-holder';\nimport { getOverlaySystem } from 'platform/components/ui/overlay';\nimport { NavigationConfirmationDialog } from './components/NavigationConfirmationDialog';\nimport { init as initPersistentHistory, persistRecentPages } from './PersistentHistory';\nimport { getCurrentResource, __unsafe__setCurrentResource } from './CurrentResource';\nexport { getCurrentResource, __unsafe__setCurrentResource };\n\nexport type EventType = 'NAVIGATED' | 'BEFORE_NAVIGATE';\nexport type Listener = NavigatedListener | BeforeNavigateListener;\n\nexport interface NavigatedListener {\n  eventType: 'NAVIGATED';\n  callback: (e: Event) => void;\n}\n\nexport interface BeforeNavigateListener {\n  eventType: 'BEFORE_NAVIGATE';\n  callback: (e: Event, performNavigation: (navigate: boolean) => void) => void;\n}\n\n/**\n * Location change event.\n */\nexport interface Event {\n  url: uri.URI;\n\n  /**\n   * REFRESH should be used when one want to refresh current page with actual page reload\n   */\n  action: 'PUSH' | 'REPLACE' | 'POP' | 'REFRESH' | 'BEFORE_NAVIGATE';\n}\nconst listeners: Map<string, Listener> = new Map();\nlet currentLocation: uri.URI;\n\nconst history = h.createBrowserHistory();\nhistory.listen((location, action) =>\n  init(location).onValue((mUrl) => mUrl.map((url) => notifyAll({ url: url, action: action })))\n);\n\n/**\n * Listen to browser Location changes.\n * @return a callback to unsubscribe.\n */\nexport function listen(cb: Listener) {\n  const id = _.uniqueId();\n  listeners.set(id, cb);\n  return () => {\n    listeners.delete(id);\n  };\n}\n\n/**\n * Show confirmation dialog before navigating from the current page.\n */\nexport function navigationConfirmation(message: string): () => void {\n  return listen({\n    eventType: 'BEFORE_NAVIGATE',\n    callback: (event: Event, navigate: (b: boolean) => void) => {\n      showNavigationConfirmationDialog(message, navigate);\n    },\n  });\n}\n\nexport function getCurrentRepository(): string {\n  return currentLocation.search(true)['repository'] || 'default';\n}\n\n/**\n * Returns current browser Location URL.\n */\nexport function getCurrentUrl(): uri.URI {\n  return currentLocation;\n}\n\n/**\n * Workaround for ThinkingFrames navigation.\n * When in ThinkingFrame all navigation requests\n * are redirected to frame component.\n */\nlet inFrame = false;\nlet inFrameNavigationHandler: (iri: Rdf.Iri, props?: {}) => boolean;\nexport function setFrameNavigation(enable: boolean, handler?: typeof inFrameNavigationHandler) {\n  inFrame = enable;\n  inFrameNavigationHandler = handler;\n}\n\n/**\n * Navigate to specified resource, it is possible to provide\n * additional query parameters with 'props' map.\n */\nexport function navigateToResource(\n  iri: Rdf.Iri,\n  props?: {},\n  repository?: string,\n  fragment?: string\n): Kefir.Property<void> {\n  if (inFrame && inFrameNavigationHandler(iri, props)) {\n    return Kefir.constant(null);\n  } else {\n    return constructUrlForResource(iri, props, repository, fragment).flatMap(navigateToUrl).toProperty();\n  }\n}\n\n/**\n * This function opens a link in a new window, it is synchronous, so we can't create pretty\n * URL with namespace.\n * We can't have async call here, because by default browsers prevent opening of\n * new windows/tab not from the action triggered by the user\n */\nexport function openResourceInNewWindow(iri: Rdf.Iri, props?: {}, repository?: string): void {\n  window.open(construcUrlForResourceSync(iri, props, repository).toString(), '_blank');\n}\n\nexport function openExternalLink(url: uri.URI, target = '_blank') {\n  return confirmAll(url)\n    .filter((c) => c)\n    .map(() => {\n      window.open(url.toString(), target);\n    });\n}\n\nconst START_PAGE = uri('/');\n\n/**\n * Navigate to platform internal URL, e.g '/sparql'. In case of navigation to root we redirect to\n * start page.\n */\nexport function navigateToUrl(url: uri.URI): Kefir.Property<void> {\n  return confirmAll(url)\n    .filter((c) => c)\n    .map(() => {\n      if (url.equals(START_PAGE)) {\n        // Because home page configuration value can be full or prefixed IRI we\n        // need to apply the same heuristic that we use in HomePageFilter.java#guessStartPage\n        const homePage = SparqlUtil.resolveIris([ConfigHolder.getGlobalConfig().homePage.value])[0];\n        navigateToResource(homePage).onValue(() => {\n          /**/\n        });\n      } else {\n        let newUrl = url.toString();\n        history.push(newUrl);\n        persistRecentPages(newUrl);\n      }\n    });\n}\n\n/**\n * Refresh current Location with actual page reload.\n */\nexport function refresh(): void {\n  notifyAll({ url: currentLocation, action: 'REFRESH' });\n}\n\n/**\n * Construct URL for resource page with optional additional query parameters.\n * If possible, shortcuts full IRI to prefixed IRI.\n */\nexport function constructUrlForResource(\n  iri: Rdf.Iri,\n  props: {} = {},\n  repository = 'default',\n  fragment = ''\n): Kefir.Property<uri.URI> {\n  return getPrefixedUri(iri).map((mUri) => {\n    const baseQuery = repository === 'default' ? {} : { repository: repository };\n    const resourceUrl = ConfigHolder.getEnvironmentConfig().resourceUrlMapping.value;\n    if (mUri.isJust) {\n      const url = uri(`${resourceUrl}${mUri.get()}`);\n      url.setQuery({ ...baseQuery, ...props });\n      url.fragment(fragment);\n      return url;\n    } else {\n      return construcUrlForResourceSync(iri, props, repository, fragment);\n    }\n  });\n}\n\nexport function construcUrlForResourceSync(iri: Rdf.Iri, props: {} = {}, repository = 'default', fragment = '') {\n  const baseQuery = repository === 'default' ? {} : { repository: repository };\n  const resourceUrl = ConfigHolder.getEnvironmentConfig().resourceUrlMapping.value;\n  const url = uri(`${resourceUrl}`);\n  url.setQuery({ ...baseQuery, ...props, uri: iri.value });\n  url.fragment(fragment);\n  return url;\n}\n\n/**\n * Initialize Navigation with current browser Location.\n */\nexport function init(location = history.location): Kefir.Property<Data.Maybe<uri.URI>> {\n  currentLocation = uri({\n    path: location.pathname,\n    query: location.search,\n    fragment: location.hash,\n  });\n  return resolveResourceIri(currentLocation).map((maybeIri) =>\n    maybeIri.map(__unsafe__setCurrentResource).map((_) => currentLocation)\n  );\n}\n\nfunction showNavigationConfirmationDialog(message: string, navigate: (b: boolean) => void) {\n  const dialogRef = 'navigation-confirmation';\n  const onHide = () => getOverlaySystem().hide(dialogRef);\n  getOverlaySystem().show(\n    dialogRef,\n    React.createElement(NavigationConfirmationDialog, {\n      onHide: onHide,\n      message: message,\n      onConfirm: (b) => {\n        onHide();\n        navigate(b);\n      },\n    })\n  );\n}\n\n/**\n * Notify all subscribed listeners.\n */\nexport function notifyAll(event: Event) {\n  listeners.forEach((listener) => {\n    if (isNavigationListener(listener)) {\n      listener.callback(event);\n    }\n  });\n}\n\nfunction confirmAll(url: uri.URI): Kefir.Property<boolean> {\n  const responsess: Array<Kefir.Property<boolean>> = [];\n  listeners.forEach((listener) => {\n    if (isBeforeNavigationListener(listener)) {\n      responsess.push(\n        Kefir.fromCallback<boolean>((cb) => listener.callback({ action: 'BEFORE_NAVIGATE', url: url }, cb)).toProperty()\n      );\n    } else {\n      responsess.push(Kefir.constant(true));\n    }\n  });\n  return Kefir.combine(responsess).map(_.every).toProperty();\n}\n\nfunction isNavigationListener(listener: Listener): listener is NavigatedListener {\n  return listener.eventType === 'NAVIGATED';\n}\n\nfunction isBeforeNavigationListener(listener: Listener): listener is BeforeNavigateListener {\n  return listener.eventType === 'BEFORE_NAVIGATE';\n}\n\nexport function resolveResourceIri(url: uri.URI): Kefir.Property<Data.Maybe<Rdf.Iri>> {\n  if (url.hasSearch('uri')) {\n    const iriStr = url.search(true)['uri'];\n    return Kefir.constant(Maybe.Just(Rdf.iri(iriStr)));\n  } else {\n    // treat everything after /resource context path as a prefixed IRI\n    // this allows us to have resolvable IRIs even for nested context paths\n    // e.g with Default namespace = http://localhost:10214/resource/\n    // request to http://localhost:10214/resource/person/Bob URL will be properly resolved\n    // to <http://localhost:10214/resource/person/Bob> resource\n    const prefixedIriStr = url.path().substring('/resource/'.length);\n    return getFullIri(prefixedIriStr);\n  }\n}\n\n\ninitPersistentHistory(init, notifyAll);\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { Props as ReactProps, createElement, cloneElement, Children, MouseEvent } from 'react';\n\nimport { Rdf } from 'platform/api/rdf';\nimport { navigateToResource, NavigationUtils, openResourceInNewWindow } from 'platform/api/navigation';\nimport { Draggable } from 'platform/components/dnd';\nimport { Component } from 'platform/api/components';\nimport { isSimpleClick } from './ResourceLink';\n\n/**\n * See 'Link'.\n */\nexport interface ResourceLinkContainerConfig {\n  /**\n   * resource IRI to navigate\n   */\n  uri: string;\n\n  /**\n   * Specify if link should be draggable, e.g. into sets.\n   *\n   * @default true\n   */\n  draggable?: boolean;\n\n  /**\n   * Equivalent to the `target` attribute of the `<a>` DOM element.\n   * Can be set to `_blank` to open the link in a new tab/window.\n   *\n   * @default '_self'\n   */\n  target?: '_self' | '_blank';\n\n  // catcher for query params\n  [index: string]: any;\n}\nexport type ResourceLinkContainerProps = ResourceLinkContainerConfig & ReactProps<ResourceLinkContainer>;\n\nexport class ResourceLinkContainer extends Component<ResourceLinkContainerProps, {}> {\n  static defaultProps = {\n    target: '_self',\n  };\n\n  onClick = (event: MouseEvent<HTMLAnchorElement>) => {\n    event.preventDefault();\n    event.stopPropagation();\n\n    const iri = Rdf.iri(this.props.uri);\n    const repository = this.context.semanticContext ? this.context.semanticContext.repository : undefined;\n    const params = NavigationUtils.extractParams(this.props);\n\n    if (isSimpleClick(event) && this.props.target === '_self') {\n      navigateToResource(iri, params, repository).onValue(() => {\n        /**/\n      });\n    } else {\n      openResourceInNewWindow(iri, params, repository);\n    }\n  };\n\n  render() {\n    const props = {\n      onClick: this.onClick,\n    };\n    if (this.props.draggable === false) {\n      return cloneElement(<any>Children.only(this.props.children), props);\n    } else {\n      return createElement(\n        Draggable,\n        { iri: this.props.uri },\n        cloneElement(<any>Children.only(this.props.children), props)\n      );\n    }\n  }\n}\nexport default ResourceLinkContainer;\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { BrowserPersistence } from '../persistence/BrowserPersistence';\nimport { Rdf } from 'platform/api/rdf';\n\nimport { ConfigHolder } from 'platform/api/services/config-holder';\n\nconst LS_LANGUAGE_PREFERENCES_KEY = 'preferredLanguage';\nconst DEFAULT_LANGUAGE = 'en';\n\nconst LanguagePreferences = BrowserPersistence.adapter<{\n  userLanguageTag?: string;\n}>();\n\nlet computedPreferences:\n  | undefined\n  | {\n      readonly preferredLanguage: string;\n      readonly languageRanks: ReadonlyMap<string, number>;\n    };\n\n/**\n * @returns BCP 47 language tag\n */\nexport function getPreferredUserLanguage(): string {\n  return getOrComputePreferences().preferredLanguage;\n}\n\nexport function setPreferredUserLanguage(bcp47LanguageTag: string | undefined) {\n  LanguagePreferences.update(LS_LANGUAGE_PREFERENCES_KEY, {\n    userLanguageTag: bcp47LanguageTag,\n  });\n  // invalidate computed language preferences\n  computedPreferences = undefined;\n}\n\nfunction getOrComputePreferences(): typeof computedPreferences {\n  if (!computedPreferences) {\n    // initialize preferred language and ranks\n    const preferredLanguage = readPreferredUserLanguage();\n    const languageRanks = computeLanguageRanks();\n    computedPreferences = { preferredLanguage, languageRanks };\n  }\n  return computedPreferences;\n}\n\nfunction readPreferredUserLanguage() {\n  const preferences = LanguagePreferences.get(LS_LANGUAGE_PREFERENCES_KEY) || {};\n  if (typeof preferences.userLanguageTag === 'string') {\n    return preferences.userLanguageTag;\n  }\n  const { preferredLanguages } = ConfigHolder.getUIConfig();\n  if (preferredLanguages.length > 0) {\n    return preferredLanguages[0];\n  }\n  return DEFAULT_LANGUAGE;\n}\n\n/**\n * See LabelCache.java `chooseLabelWithPreferredLanguage()` for reference.\n */\nfunction computeLanguageRanks(): Map<string, number> {\n  const languageToRank = new Map<string, number>();\n  // unlike original Java method we do not put selected language into\n  // language ranks to be able to choose it dynamically\n\n  // lower rank means better, best rank is zero\n  let nextRank = 1;\n  const { preferredLanguages } = ConfigHolder.getUIConfig();\n  for (const language of preferredLanguages) {\n    if (!languageToRank.has(language)) {\n      languageToRank.set(language, nextRank++);\n    }\n  }\n\n  if (!languageToRank.has('')) {\n    languageToRank.set('', nextRank++);\n  }\n\n  return languageToRank;\n}\n\n/**\n * Returns the label with the user preferred language, otherwise returns the label based on\n * the order of the preferredLanguages. In case the label is missing, returns the label with\n * empty language. If no label exists, returns undefined.\n *\n * This client-side logic is only to be used in exceptional cases (i.e. if physical triples might\n * no be present in the triple store) and otherwise the global/backend label service should be used.\n *\n * See LabelCache.java `chooseLabelWithPreferredLanguage()` for reference.\n */\nexport function selectPreferredLabel<T extends { readonly value: string; readonly language: string } = Rdf.Literal>(\n  labels: ReadonlyArray<T>,\n  selectedLanguage?: string\n): T | undefined {\n  // fast path: no labels detected\n  if (labels.length === 0) {\n    return undefined;\n  }\n\n  const { languageRanks } = getOrComputePreferences();\n\n  let bestObserved: T | undefined;\n  let bestObservedRank = Number.MAX_SAFE_INTEGER;\n  for (const label of labels) {\n    const { language } = label;\n    if (language === selectedLanguage) {\n      // optimal match found\n      return label;\n    }\n\n    let rank = languageRanks.get(language);\n    if (typeof rank === 'undefined') {\n      // better than uninitialized\n      rank = Number.MAX_SAFE_INTEGER - 1;\n    }\n\n    if (rank < bestObservedRank) {\n      // remember best match thus far\n      bestObservedRank = rank;\n      bestObserved = label;\n    } // else: continue scanning\n  }\n\n  return bestObserved;\n}\n\n/**\n * Returns the defined label for the IRI if the literal in the optional is present, otherwise\n * computing a fall back label. The fallback is the IRI's local name and if local name is empty,\n * it simply returns the full IRI as a string.\n *\n * See LabelCache.java `resolveLabelWithFallback()` for reference.\n */\nexport function resolveLabelWithFallback(labelIfDefined: Rdf.Literal | undefined, iri: Rdf.Iri): string {\n  if (labelIfDefined) {\n    return labelIfDefined.value;\n  }\n  return Rdf.getLocalName(iri.value) || iri.value;\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as request from 'platform/api/http';\nimport * as Kefir from 'kefir';\nimport { pick } from 'lodash';\n\nimport { requestAsProperty } from 'platform/api/async';\nimport { Rdf } from 'platform/api/rdf';\n\nimport { getPreferredUserLanguage } from './language';\nimport { purgeTemplateCache } from './template/TemplateCache';\n\nexport interface TemplateContent {\n  appId: string | null;\n  revision: string | null;\n  source: string;\n  definedByApps: ReadonlyArray<string>;\n  applicableTemplates: string[];\n  appliedTemplate: string;\n  includes: string[];\n}\n\ninterface RenderedTemplate {\n  jsurls: string[];\n  templateHtml: string;\n}\n\nexport interface RevisionInfo {\n  appId: string;\n  iri: string;\n  revision: string | undefined;\n}\n\nconst REVISION_INFO_TEMPLATE: { [K in keyof RevisionInfo]: null } = {\n  appId: null,\n  iri: null,\n  revision: null,\n};\n/** Compiler-enforced array with all the keys of revision info */\nconst REVISION_INFO_KEYS = Object.keys(REVISION_INFO_TEMPLATE);\n\nexport interface TemplateInfo extends RevisionInfo {\n  author: string;\n  date?: string;\n}\n\nexport interface TemplateStorageStatus {\n  appId: string;\n  writable: boolean;\n}\n\nexport module PageService {\n  const GET_SOURCE = '/rest/template/source';\n  const GET_PAGE_HTML = '/rest/template/pageHtml';\n  const GET_HTML = '/rest/template/html';\n  const PUT_SOURCE = '/rest/template/source';\n  const GET_ALL_INFO = '/rest/template/getAllInfo';\n  const POST_EXPORT_REVISIONS = '/rest/template/exportRevisions';\n  const DELETE_REVISIONS = '/rest/template/deleteRevisions';\n  const GET_STORAGE_STATUS = '/rest/template/storageStatus';\n\n  export function loadTemplateSource(iri: string): Kefir.Property<TemplateContent> {\n    const req = request.get(GET_SOURCE).query({ iri: iri }).type('application/json').accept('application/json');\n\n    return requestAsProperty(req)\n      .mapErrors((err) => err.status)\n      .map((res) => JSON.parse(res.text) as TemplateContent);\n  }\n\n  export function loadPageTemplateHtml(iri: Rdf.Iri): Kefir.Property<{ templateHtml: string }> {\n    const req = request\n      .get(GET_PAGE_HTML)\n      .query({\n        iri: iri.value,\n        preferredLanguage: getPreferredUserLanguage(),\n      })\n      .type('application/json')\n      .accept('application/json');\n\n    return requestAsProperty(req).map((res) => JSON.parse(res.text));\n  }\n\n  export function loadRenderedTemplate(\n    iri: Rdf.Iri,\n    contextIri?: Rdf.Iri,\n    params?: { [index: string]: string }\n  ): Kefir.Property<RenderedTemplate> {\n    const req = request\n      .get(GET_HTML)\n      .query({\n        iri: iri.value,\n        preferredLanguage: getPreferredUserLanguage(),\n      })\n      .query(params)\n      .type('application/json')\n      .accept('application/json');\n\n    if (contextIri) {\n      req.query({ context: contextIri.value });\n    }\n\n    return requestAsProperty(req)\n      .mapErrors((err) => err.rawResponse)\n      .map((res) => JSON.parse(res.text) as RenderedTemplate);\n  }\n\n  export function save(params: {\n    iri: string;\n    targetAppId: string;\n    sourceAppId?: string;\n    sourceRevision?: string;\n    rawContent: string;\n  }): Kefir.Property<boolean> {\n    const { iri, targetAppId, sourceAppId, sourceRevision, rawContent } = params;\n    purgeTemplateCache();\n    const req = request\n      .put(PUT_SOURCE)\n      .query({\n        iri,\n        targetAppId,\n        sourceAppId,\n        sourceRevision,\n      })\n      .send(rawContent)\n      .type('text/html')\n      .accept('application/json');\n\n    return requestAsProperty(req)\n      .mapErrors((err) => err.rawResponse)\n      .map((res) => res.status === 201);\n  }\n\n  export function getAllTemplateInfos(): Kefir.Property<TemplateInfo[]> {\n    const req = request.get(GET_ALL_INFO).type('application/json').accept('application/json');\n\n    return requestAsProperty(req)\n      .mapErrors((err) => err.response.statusText)\n      .map((res) => JSON.parse(res.text));\n  }\n\n  export function deleteTemplateRevisions(selected: ReadonlyArray<RevisionInfo>): Kefir.Property<boolean> {\n    const req = request.del(DELETE_REVISIONS).type('application/json').send(selected.map(cleanRevisionInfo));\n\n    return requestAsProperty(req).map((res) => true);\n  }\n\n  export function exportTemplateRevisions(selected: ReadonlyArray<RevisionInfo>): Kefir.Property<request.Response> {\n    const req = request\n      .post(POST_EXPORT_REVISIONS)\n      .type('application/json')\n      .accept('application/zip')\n      .on('request', function (re) {\n        re.xhr.responseType = 'arraybuffer'; // or blob\n      })\n      .send(selected.map(cleanRevisionInfo));\n\n    return requestAsProperty(req).mapErrors((err) => err.response.statusText);\n  }\n\n  export function getStorageStatus(): Kefir.Property<TemplateStorageStatus[]> {\n    const req = request.get(GET_STORAGE_STATUS).accept('application/json');\n\n    return requestAsProperty(req)\n      .mapErrors((err) => err.response.statusText)\n      .map((res) => JSON.parse(res.text) as TemplateStorageStatus[]);\n  }\n}\n\n/**\n * Removes extra properties from template revision info to\n * avoid server error when trying to deserialize object.\n */\nfunction cleanRevisionInfo(info: RevisionInfo): RevisionInfo {\n  return pick(info, REVISION_INFO_KEYS);\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as assign from 'object-assign';\nimport * as Kefir from 'kefir';\nimport * as _ from 'lodash';\nimport * as SparqlJs from 'sparqljs';\nimport * as URI from 'urijs';\n\nimport { serializeQuery, parseQuerySync } from './SparqlUtil';\nimport { cloneQuery } from './QueryVisitor';\nimport { VariableBinder, TextBinder } from './QueryBinder';\nimport * as turtle from '../rdf/formats/turtle';\nimport * as Rdf from '../rdf/core/Rdf';\nimport * as request from 'platform/api/http';\nimport { requestAsProperty } from 'platform/api/async';\n\n/**\n * Javascript client for SPARQL 1.1 endpoint.\n *\n * @see {@link @see http://www.w3.org/TR/sparql11-protocol/}\n */\nmodule SparqlClient {\n  /**\n   * SPARQL protocol operations.\n   *\n   * @see {@link http://www.w3.org/TR/sparql11-protocol/#protocol}\n   */\n  export enum SparqlOperationType {\n    QUERY,\n    UPDATE,\n  }\n\n  /**\n   * Supported SPARQL query forms.\n   *\n   * @see {@link http://www.w3.org/TR/sparql11-query/#QueryForms}\n   */\n  export enum SparqlQueryForm {\n    SELECT,\n    CONSTRUCT,\n    ASK,\n    DESCRIBE,\n  }\n\n  /**\n   * String representation for {@link SparqlQueryform}\n   */\n  export var stringToSparqlQueryForm: Dictionary<SparqlQueryForm> = {\n    SELECT: SparqlQueryForm.SELECT,\n    CONSTRUCT: SparqlQueryForm.CONSTRUCT,\n    ASK: SparqlQueryForm.ASK,\n    DESCRIBE: SparqlQueryForm.DESCRIBE,\n  };\n\n  const SPARQL_RESULT_ACCEPT_HEADERS = {\n    SELECT: {\n      JSON: 'application/sparql-results+json',\n    },\n    CONSTRUCT: {\n      TURTLE: 'text/turtle',\n    },\n  };\n\n  const DefaultResultHeaders = {\n    [SparqlQueryForm.CONSTRUCT]: SPARQL_RESULT_ACCEPT_HEADERS.CONSTRUCT.TURTLE,\n    [SparqlQueryForm.SELECT]: SPARQL_RESULT_ACCEPT_HEADERS.SELECT.JSON,\n    [SparqlQueryForm.ASK]: SPARQL_RESULT_ACCEPT_HEADERS.SELECT.JSON,\n    [SparqlQueryForm.DESCRIBE]: SPARQL_RESULT_ACCEPT_HEADERS.CONSTRUCT.TURTLE,\n  };\n\n  export interface Dictionary<T> {\n    [index: string]: T;\n  }\n\n  interface SparqlSelectBinding {\n    value: string;\n    type: string;\n    datatype?: string;\n    'xml:lang'?: string;\n  }\n\n  export interface SparqlSelectJsonResult {\n    head: {\n      link: any[];\n      vars: string[];\n    };\n    results: {\n      bindings: Dictionary<SparqlSelectBinding>[];\n      distinct: boolean;\n      ordered: boolean;\n    };\n  }\n\n  export type Binding = Dictionary<Rdf.Node>;\n  export type Bindings = Binding[];\n\n  export interface SparqlSelectResult {\n    head: {\n      link: any[];\n      vars: string[];\n    };\n    results: {\n      bindings: Bindings;\n      distinct: boolean;\n      ordered: boolean;\n    };\n  }\n\n  export type Parameters = Dictionary<Rdf.Node>[];\n\n  /**\n   * Parametrize query using VALUES clause.\n   *\n   * Example:\n   * query = SELECT ?p WHERE {?s ?p ?o}\n   * parameters = [{'p': <example>}, {'p': <example2>}]\n   * result = SELECT ?p WHERE {?s ?p ?o . VALUES(?p) { (<example>) (<example2>) }}\n   */\n  export function prepareQuery(query: string, parameters: Parameters): Kefir.Property<SparqlJs.SparqlQuery> {\n    return Kefir.constant(parseQuerySync(query)).map(prepareParsedQuery(parameters));\n  }\n\n  export function prepareParsedQuery(parameters: Parameters) {\n    return <TQuery extends SparqlJs.Query>(query: TQuery): TQuery => {\n      const values = serializeParameters(parameters);\n      if (_.isEmpty(values) === false) {\n        const queryCopy = _.cloneDeep(query);\n        // When query has no where clause we need to add empty one.\n        // This can happen in case of simple construct query.\n        queryCopy.where = queryCopy.where ? queryCopy.where : [];\n        queryCopy.where.unshift({\n          type: 'values',\n          values: values,\n        });\n        return queryCopy;\n      } else {\n        return query;\n      }\n    };\n  }\n\n  function serializeParameters(parameters: Parameters) {\n    return _.map(parameters, (tuple) =>\n      _.reduce(\n        tuple,\n        (acc, v, k) => {\n          acc['?' + k] = turtle.serialize.nodeToN3(v) as SparqlJs.Term;\n          return acc;\n        },\n        {} as Dictionary<SparqlJs.Term>\n      )\n    );\n  }\n\n  /**\n   * Parametrize query by replacing variables or IRIs.\n   *\n   * @example\n   * setBindings(\n   *   parseQuery('SELECT * WHERE { ?s ?p <my:obj> }'),\n   *   { 'p': Rdf.iri('my:iri'), 'my:obj': Rdf.literal('my_literal') })\n   * === parseQuery('SELECT * WHERE { ?s <my:iri> \"my_literal\"^^xsd:string }')\n   */\n  export function setBindings<TQuery extends SparqlJs.SparqlQuery>(\n    query: TQuery,\n    parameters: Dictionary<Rdf.Node>\n  ): TQuery {\n    const queryCopy = cloneQuery(query);\n    new VariableBinder(parameters).sparqlQuery(queryCopy);\n    return queryCopy;\n  }\n\n  /**\n   * Parametrize query by applying specified RegExp to its literals.\n   *\n   * @example\n   * setTextBindings(\n   *   parseQuery('SELECT * WHERE { ?s ?p \"text TOKEN othertext\" }'),\n   *   [{test: /TOKEN/, replace: 'replacement' })\n   * === parseQuery('SELECT * WHERE { ?s ?p \"text replacement othertext\" }')\n   */\n  export function setTextBindings<TQuery extends SparqlJs.SparqlQuery>(\n    query: TQuery,\n    replacements: Array<{ test: RegExp; replace: string }>\n  ) {\n    const queryCopy = cloneQuery(query);\n    new TextBinder(replacements).sparqlQuery(queryCopy);\n    return queryCopy;\n  }\n\n  export interface SparqlOptions {\n    endpoint?: string;\n    context?: QueryContext;\n  }\n\n  export interface QueryContext {\n    readonly repository?: string;\n    readonly bindings?: SparqlContext;\n\n    readonly defaultGraphs?: Array<string>;\n    readonly namedGraphs?: Array<string>;\n\n    /**\n     * Applicable only to CONSTRUCT/DESCRIBE queries. True if result should be pretty printed.\n     */\n    readonly prettyPrint?: boolean;\n\n    /**\n     * True if the context is a default one and has not been overwritten.\n     */\n    readonly isDefault?: boolean;\n  }\n\n  export interface SparqlContext {\n    [binding: string]: Rdf.Node;\n  }\n\n  export function construct(\n    query: string | SparqlJs.SparqlQuery,\n    options?: SparqlOptions\n  ): Kefir.Property<Rdf.Triple[]> {\n    return graphQuery(query, true, options);\n  }\n\n  export function describe(\n    query: string | SparqlJs.SparqlQuery,\n    options?: SparqlOptions\n  ): Kefir.Property<Rdf.Triple[]> {\n    return graphQuery(query, false, options);\n  }\n\n  export function select(\n    query: string | SparqlJs.SparqlQuery,\n    options?: SparqlOptions\n  ): Kefir.Property<SparqlSelectResult> {\n    return sparqlQuery(query, SparqlQueryForm.SELECT, options).map((res) => {\n      const selectJson = <SparqlSelectJsonResult>JSON.parse(res);\n      return sparqlJsonToSelectResult(selectJson);\n    });\n  }\n\n  export function sparqlJsonToSelectResult(selectJson: SparqlSelectJsonResult): SparqlSelectResult {\n    const bindings = _.map(selectJson.results.bindings, (binding) =>\n      _.mapValues(binding, sparqlSelectBindingValueToRdf)\n    );\n    return {\n      head: selectJson.head,\n      results: {\n        bindings: bindings,\n        distinct: selectJson.results.distinct,\n        ordered: selectJson.results.ordered,\n      },\n    };\n  }\n\n  export function ask(query: string | SparqlJs.SparqlQuery, options?: SparqlOptions): Kefir.Property<boolean> {\n    return sparqlQuery(query, SparqlQueryForm.SELECT, options).map((res) => JSON.parse(res)['boolean']);\n  }\n\n  function graphQuery(query: string | SparqlJs.SparqlQuery, isConstruct: boolean, options?: SparqlOptions) {\n    return sparqlQuery(query, isConstruct ? SparqlQueryForm.CONSTRUCT : SparqlQueryForm.DESCRIBE, options)\n      .flatMap(turtle.deserialize.turtleToTriples)\n      .toProperty();\n  }\n\n  export function sparqlQuery(query: string | SparqlJs.SparqlQuery, form: SparqlQueryForm, options?: SparqlOptions) {\n    const format = DefaultResultHeaders[form];\n    return sendSparqlQuery(query, format, options);\n  }\n\n  export function sendSparqlQuery(query: string | SparqlJs.SparqlQuery, format: string, options: SparqlOptions = {}) {\n    const { endpoint, context } = options;\n    return sparqlQueryRequest({\n      query,\n      endpoint,\n      headers: { Accept: format },\n      context,\n    });\n  }\n\n  export function sparqlQueryRequest(params: {\n    query: string | SparqlJs.SparqlQuery;\n    endpoint: string;\n    headers: { [header: string]: string };\n    context: QueryContext;\n  }): Kefir.Property<string> {\n    const { query, endpoint = '/sparql', headers, context = {} } = params;\n\n    let parametrizedEndpoint = new URI(endpoint);\n    if (context.repository) {\n      parametrizedEndpoint.addQuery({ repository: context.repository });\n    }\n    if (context.prettyPrint) {\n      parametrizedEndpoint.addQuery({ 'prettyPrint': true });\n    }\n    if (context.defaultGraphs) {\n      parametrizedEndpoint.addQuery({ 'default-graph-uri': context.defaultGraphs });\n    }\n    if (context.namedGraphs) {\n      parametrizedEndpoint.addQuery({ 'named-graph-uri': context.namedGraphs });\n    }\n    let parsedQuery: SparqlJs.SparqlQuery;\n    try {\n      parsedQuery = typeof query === 'string' ? parseQuerySync(query) : query;\n    } catch (e) {\n      return Kefir.constantError(e);\n    }\n    const queryWithContext = context.bindings ? setBindings(parsedQuery, context.bindings) : parsedQuery;\n    const preparedQuery = serializeQuery(queryWithContext);\n\n    const header = assign(\n      {\n        'Content-Type': 'application/sparql-query; charset=utf-8',\n      },\n      headers\n    );\n\n    const req = request.post(parametrizedEndpoint.toString()).send(preparedQuery).set(header);\n    return requestAsProperty(req).map((res) => res.text);\n  }\n\n  export function executeSparqlUpdate(\n    query: SparqlJs.Update | string,\n    options: SparqlOptions = {}\n  ): Kefir.Property<void> {\n    const { endpoint = '/sparql', context = {} } = options;\n\n    let parametrizedEndpoint = endpoint;\n    if (context.repository) {\n      parametrizedEndpoint += '?' + URI.buildQuery({ repository: context.repository });\n    }\n\n    const parsedQuery = typeof query === 'string' ? parseQuerySync(query) : query;\n    const queryWithContext = context.bindings ? setBindings(parsedQuery, context.bindings) : parsedQuery;\n    const preparedQuery = serializeQuery(queryWithContext);\n\n    const updateRequest = request\n      .post(parametrizedEndpoint)\n      .send(preparedQuery)\n      .set('Content-Type', 'application/sparql-query; charset=utf-8')\n      .set('Accept', 'text/boolean');\n\n    return requestAsProperty(updateRequest).map((res) => res.body);\n  }\n\n  /**\n   * Convert sparql-results+json binding term to internal RDF representation.\n   *\n   * @see http://www.w3.org/TR/sparql11-results-json/#select-encode-terms\n   */\n  function sparqlSelectBindingValueToRdf(binding: SparqlSelectBinding): Rdf.Node {\n    if (binding.type === 'uri') {\n      return Rdf.iri(binding.value);\n    } else if (binding.type === 'literal') {\n      return sparqlSelectBindingLiteralToRdf(binding);\n    } else {\n      return Rdf.bnode(binding.value);\n    }\n  }\n\n  function sparqlSelectBindingLiteralToRdf(binding: SparqlSelectBinding): Rdf.Literal {\n    if (!_.isUndefined(binding['xml:lang'])) {\n      return Rdf.langLiteral(binding.value, binding['xml:lang']);\n    } else if (!_.isUndefined(binding.datatype)) {\n      return Rdf.literal(binding.value, Rdf.iri(binding.datatype));\n    } else {\n      return Rdf.literal(binding.value);\n    }\n  }\n}\n\nexport = SparqlClient;\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as Kefir from 'kefir';\nimport * as request from 'platform/api/http';\n\nexport { Cancellation } from './Cancellation';\nexport { WrappingError } from './WrappingError';\nexport { BatchedPool } from './BatchedPool';\n\nexport function requestAsProperty(req: request.SuperAgentRequest): Kefir.Property<request.Response> {\n  return Kefir.stream<request.Response>((emitter) => {\n    req.then(\n      (response) => {\n        emitter.emit(response);\n        emitter.end();\n      },\n      (error) => {\n        emitter.error(error);\n        emitter.end();\n      }\n    );\n    return () => req.abort();\n  }).toProperty();\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as Immutable from 'immutable';\n\nimport * as Rdf from '../core/Rdf';\n\nmodule xsd {\n  /**\n   * For XSD namespace considerations see\n   * https://www.w3.org/TR/xmlschema-2/#namespaces\n   */\n  export const _NAMESPACE = 'http://www.w3.org/2001/XMLSchema#';\n  export const _DATATYPES_NAMESPACE = 'http://www.w3.org/2001/XMLSchema-datatypes#';\n  export const iri = (s: string) => Rdf.iri(_NAMESPACE + s);\n\n  export const _string = iri('string');\n  export const langString = iri('langString');\n  export const integer = iri('integer');\n  export const float = iri('float');\n  export const double = iri('double');\n  export const boolean = iri('boolean');\n  export const date = iri('date');\n  export const time = iri('time');\n  export const dateTime = iri('dateTime');\n  export const decimal = iri('decimal');\n  export const anyURI = iri('anyURI');\n  export const positiveInteger = iri('positiveInteger');\n  export const negativeInteger = iri('negativeInteger');\n  export const nonPositiveInteger = iri('nonPositiveInteger');\n  export const nonNegativeInteger = iri('nonNegativeInteger');\n\n  export const LIST_TYPES = [\n    { value: anyURI.value, label: 'xsd:anyURI' },\n    { value: integer.value, label: 'xsd:integer' },\n    { value: date.value, label: 'xsd:date' },\n    { value: dateTime.value, label: 'xsd:dateTime' },\n    { value: _string.value, label: 'xsd:string' },\n    { value: langString.value, label: 'xsd:langString' },\n    { value: boolean.value, label: 'xsd:boolean' },\n    { value: double.value, label: 'xsd:double' },\n    { value: decimal.value, label: 'xsd:decimal' },\n  ];\n\n  export const NUMERIC_TYPES = Immutable.Set<Rdf.Iri>([\n    integer,\n    positiveInteger,\n    negativeInteger,\n    nonPositiveInteger,\n    nonNegativeInteger,\n    float,\n    double,\n    decimal,\n  ]);\n}\n\nexport default xsd;\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nexport * from './BrowserPersistence';\nexport * from './ComponentPersistence';\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as request from 'superagent';\n\nexport { SuperAgentRequest, Response } from 'superagent';\n\nlet baseUrl = null;\nexport function init(base?: string) {\n  baseUrl = base;\n}\n\nexport function getBaseUrl() {\n  return baseUrl;\n}\n\nfunction getAbsoluteUrl(url: string) {\n  return baseUrl ? baseUrl + url : url;\n}\n\nexport function options(url: string) {\n  return request.options(getAbsoluteUrl(url));\n}\n\nexport function get(url: string) {\n  return request.get(getAbsoluteUrl(url));\n}\n\nexport function post(url: string) {\n  return request.post(getAbsoluteUrl(url));\n}\n\nexport function put(url: string) {\n  return request.put(getAbsoluteUrl(url));\n}\n\nexport function patch(url: string) {\n  return request.patch(getAbsoluteUrl(url));\n}\n\nexport function head(url: string) {\n  return request.head(getAbsoluteUrl(url));\n}\n\nexport function del(url: string) {\n  return request.delete(getAbsoluteUrl(url));\n}\nexport { del as delete };\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as Immutable from 'immutable';\nimport { serializerFor, deserializerFor } from '../JsonCore';\n\n/**\n * Serializers and deserializers for Immutable.js.\n */\nexport function registerSerializersAndDeserializers() {\n  // for Immutable.OrderedSet\n  serializerFor({\n    name: 'Immutable.Set',\n    predicate: function (obj) {\n      return obj instanceof Immutable.Set;\n    },\n    serializer: function (obj: any) {\n      return obj.toArray();\n    },\n  });\n  deserializerFor({\n    name: 'Immutable.Set',\n    deserializer: function (object: any) {\n      return Immutable.Set((<any>Immutable).Seq.Indexed(object));\n    },\n  });\n\n  // for Immutable.OrderedSet\n  serializerFor({\n    name: 'Immutable.OrderedSet',\n    predicate: function (obj) {\n      return obj instanceof Immutable.OrderedSet;\n    },\n    serializer: function (obj: any) {\n      return obj.toArray();\n    },\n  });\n  deserializerFor({\n    name: 'Immutable.OrderedSet',\n    deserializer: function (object: any) {\n      return Immutable.OrderedSet((<any>Immutable).Seq.Indexed(object));\n    },\n  });\n\n  // for Immutable.List\n  serializerFor({\n    name: 'Immutable.List',\n    predicate: function (obj) {\n      return obj instanceof Immutable.List;\n    },\n    serializer: function (obj: any) {\n      return obj.toArray();\n    },\n  });\n  deserializerFor({\n    name: 'Immutable.List',\n    deserializer: function (object: any) {\n      return Immutable.List((<any>Immutable).Seq.Indexed(object));\n    },\n  });\n\n  // for Immutable.OrderedMap\n  serializerFor({\n    name: 'Immutable.OrderedMap',\n    predicate: function (obj) {\n      return obj instanceof Immutable.OrderedMap;\n    },\n    serializer: function (obj: any) {\n      return obj.toObject();\n    },\n  });\n  deserializerFor({\n    name: 'Immutable.OrderedMap',\n    deserializer: function (object: any) {\n      return Immutable.OrderedMap((<any>Immutable).Seq.Keyed(object));\n    },\n  });\n\n  // for Immutable.Map\n  serializerFor({\n    name: 'Immutable.Map',\n    predicate: function (obj) {\n      return obj instanceof Immutable.Map;\n    },\n    serializer: function (obj: any) {\n      return obj.toObject();\n    },\n  });\n  deserializerFor({\n    name: 'Immutable.Map',\n    deserializer: function (object: any) {\n      return Immutable.Map((<any>Immutable).Seq.Keyed(object));\n    },\n  });\n}\n\nexport function recordSerializer<T>(name: string, constructorFn: Immutable.Record.Factory<T>) {\n  serializerFor<T>({\n    name: name,\n    predicate: (obj) => obj instanceof constructorFn,\n    serializer: (record) => {\n      return (<any>record).toObject();\n    },\n  });\n  deserializerFor({\n    name: name,\n    deserializer: (obj) => new constructorFn(<T>obj),\n  });\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as Rdf from '../core/Rdf';\n\nmodule rdf {\n  export const _NAMESPACE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#';\n  export const iri = (s: string) => Rdf.iri(_NAMESPACE + s);\n\n  export const type = iri('type');\n  export const langString = iri('langString');\n  export const first = iri('first');\n  export const rest = iri('rest');\n  export const nil = iri('nil');\n  export const value = iri('value');\n}\n\nexport default rdf;\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Affero General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU Affero General Public License for more details.\n *\n * You should have received a copy of the GNU Affero General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\nimport { Rdf } from 'platform/api/rdf';\n\nlet currentResource: Rdf.Iri;\n\n/**\n * Returns current resource IRI.\n */\nexport function getCurrentResource(): Rdf.Iri {\n  return currentResource;\n}\n\n/**\n * For testing purpose only\n */\nexport function __unsafe__setCurrentResource(resource: Rdf.Iri) {\n  currentResource = resource;\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as SparqlJs from 'sparqljs';\n\nimport { Rdf } from 'platform/api/rdf';\n\nimport * as turtle from '../rdf/formats/turtle';\n\nimport { QueryVisitor } from './QueryVisitor';\nimport { isTerm } from './TypeGuards';\n\n/**\n * Replaces variables with IRIs or literals.\n *\n * @example\n * const query = parseQuery('SELECT * WHERE { ?s ?foo ?bar }');\n * new VariableBinder({\n *   foo: Rdf.iri('http://example'),\n *   bar: Rdf.literal('Some bar'),\n * }).sparqlQuery(query);\n *\n * // result:\n * query === parseQuery('SELECT * WHERE { ?s <http://example> \"Some bar\" }')\n */\nexport class VariableBinder extends QueryVisitor {\n  constructor(protected replacements: { [variableName: string]: Rdf.Node }) {\n    super();\n  }\n\n  private tryReplace(termValue: string) {\n    const replacement = this.replacements[termValue];\n    if (replacement !== undefined) {\n      return turtle.serialize.nodeToN3(replacement) as SparqlJs.Term;\n    } else {\n      return undefined;\n    }\n  }\n\n  variableTerm(variable: SparqlJs.Term) {\n    const name = variable.substring(1);\n    return this.tryReplace(name);\n  }\n}\n\n/**\n * Replaces variables in triple's predicate position with property path.\n * The specified path will be replaced with a single predicate if it's\n * consists of single item and path operation is '|' or '/'.\n *\n * @example\n * const query = parseQuery(`SELECT * WHERE {\n *   ?s ?p1 ?p1 .\n *   ?s ?p2 ?p2 .\n * }`);\n * new PropertyPathBinder({\n *   p1: {type: 'path', pathType: '/',\n *     items: ['http:a', 'http:b'] as SparqlJs.Term[]},\n *   p2: {type: 'path', pathType: '|',\n *     items: ['http:c'] as SparqlJs.Term[]},\n * }).sparqlQuery(query);\n *\n * // result:\n * query === parseQuery(`SELECT * WHERE {\n *   ?s <http:a> / <http:b> ?p1 .\n *   ?s <http:c> ?p2 .\n * }`);\n */\nexport class PropertyPathBinder extends QueryVisitor {\n  constructor(\n    protected replacements: {\n      [propertyVariable: string]: SparqlJs.PropertyPath;\n    }\n  ) {\n    super();\n  }\n\n  variableTerm(variable: SparqlJs.Term): SparqlJs.Term | SparqlJs.PropertyPath {\n    if (this.currentMember === 'predicate') {\n      const propertyPath = this.replacements[variable.substring(1)];\n      return PropertyPathBinder.normalize(propertyPath);\n    }\n  }\n\n  static normalize(path: SparqlJs.PropertyPath): SparqlJs.PropertyPath | SparqlJs.Term {\n    if (path === undefined) {\n      return undefined;\n    }\n    const type = path.pathType;\n    if (path.items.length === 1 && (type === '|' || type === '/')) {\n      const item = path.items[0];\n      return isTerm(item) ? item : PropertyPathBinder.normalize(item);\n    }\n    return path;\n  }\n}\n\n/**\n * Applies specified RegExp to every literal.\n *\n * @example\n * const query = parseQuery('SELECT * WHERE { ?s ?p \"text TOKEN othertext\" }');\n * new TextBinder([\n *   {test: /TOKEN/, replace: 'replacement'}\n * ]).sparqlQuery(query);\n *\n * // result:\n * query === parseQuery('SELECT * WHERE { ?s ?p \"text replacement othertext\" }')\n */\nexport class TextBinder extends QueryVisitor {\n  constructor(protected replacements: Array<{ test: RegExp; replace: string }>) {\n    super();\n  }\n\n  literal(literal: SparqlJs.Term): SparqlJs.Term {\n    for (const { test, replace } of this.replacements) {\n      if (test.test(literal)) {\n        return literal.replace(test, replace) as SparqlJs.Term;\n      }\n    }\n    return undefined;\n  }\n}\n\n/**\n * Replaces `FILTER(?placeholder)` pattern with any number of other query patterns.\n *\n * @example\n * const triples = [{subject: '?s', predicate: '?p', object: '?o'}];\n * const query = parseQuery('SELECT * WHERE { FILTER(?foo) }');\n * new PatternBinder('foo', [{type: 'bgp', triples}]).sparqlQuery(query);\n *\n * // result:\n * query === parseQuery('SELECT * WHERE { ?s ?p ?o }')\n */\nexport class PatternBinder extends QueryVisitor {\n  private readonly placeholder: SparqlJs.Term;\n  private readonly patterns: ReadonlyArray<SparqlJs.Pattern>;\n  private placeholderFound = false;\n\n  constructor(filterPlaceholder: string, patterns: ReadonlyArray<SparqlJs.Pattern>) {\n    super();\n    this.placeholder = ('?' + filterPlaceholder) as SparqlJs.Term;\n    this.patterns = patterns;\n  }\n\n  filter(pattern: SparqlJs.FilterPattern): SparqlJs.Pattern {\n    if (isTerm(pattern.expression) && pattern.expression === this.placeholder) {\n      this.placeholderFound = true;\n      return undefined;\n    } else {\n      return super.filter(pattern);\n    }\n  }\n\n  protected walkItem(nodes: any[], index: number, walk: (node: any) => any): number {\n    const newIndex = super.walkItem(nodes, index, walk);\n    if (this.placeholderFound) {\n      this.placeholderFound = false;\n      nodes.splice(index, 1, ...this.patterns);\n      return index + this.patterns.length;\n    }\n    return newIndex;\n  }\n}\n\n/**\n * Renames every `?(fromVariable)` variable to `?(toVariable)`.\n *\n * @example\n * const query = parseQuery('SELECT ?foo WHERE { ?foo ?p \"bar\" }');\n * new VariableRenameBinder('foo', 'qux').sparqlQuery(query);\n *\n * // result:\n * query === parseQuery('SELECT ?qux WHERE { ?qux ?p \"bar\" }')\n */\nexport class VariableRenameBinder extends QueryVisitor {\n  constructor(private fromVariable: string, private toVariable: string) {\n    super();\n  }\n\n  variableTerm(variable: SparqlJs.Term) {\n    if (variable.substring(1) === this.fromVariable) {\n      return ('?' + this.toVariable) as SparqlJs.Term;\n    }\n  }\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as Handlebars from 'handlebars';\nimport { partition } from 'lodash';\n\nimport { WrappingError } from 'platform/api/async';\nimport { Rdf } from 'platform/api/rdf';\nimport { SparqlUtil } from 'platform/api/sparql';\n\nimport { escapeRemoteTemplateHtml } from './TemplateParser';\nimport { ParsedTemplate } from './TemplateCommons';\nimport { remoteTemplateCache } from './TemplateCache';\n\nimport { PageService } from '../page';\n\n\n\nexport function fetchRemoteTemplate(iri: Rdf.Iri): Promise<ParsedTemplate> {\n  if (remoteTemplateCache.has(iri.value)) {\n    return remoteTemplateCache.get(iri.value);\n  }\n\n  // fetching and parsing template source\n  const promise = PageService.loadPageTemplateHtml(iri)\n    .toPromise()\n    .then((template) => escapeRemoteTemplateHtml(template.templateHtml))\n    .then(parseTemplate)\n    .catch((error) => Promise.reject(new WrappingError(`Failed to load the source of template ${iri}`, error)));\n\n  remoteTemplateCache.set(iri.value, promise);\n  return promise;\n}\n\ninterface HandlebarsAPI {\n  JavaScriptCompiler?: HandlebarsJavaScriptCompilerConstructor;\n}\n\ninterface HandlebarsJavaScriptCompilerConstructor {\n  new (...args: any[]): HandlebarsJavaScriptCompiler;\n}\n\ninterface HandlebarsJavaScriptCompiler {\n  nameLookup(parent: any, name: any, type: string): any;\n  /**\n   * Undocumented reference to constructor function of itself.\n   * Nested partials compilation will use default JavaScriptCompiler if this field isn't set to\n   * derived compiler's constructor function.\n   */\n  // See `compiler: JavaScriptCompiler` field here:\n  // tslint:disable-next-line:max-line-length\n  // https://github.com/wycats/handlebars.js/blob/714a4c448281aef44bcafc4d9e4ecf32ed063b8b/lib/handlebars/compiler/javascript-compiler.js#L695\n  compiler?: HandlebarsJavaScriptCompilerConstructor;\n}\n\n/**\n * Handlebars runtime compiler with added ability to resolve partial name\n * specified as short prefixed IRI using platform-wide registered prefixes.\n */\nclass IRIResolvingCompiler extends (Handlebars as HandlebarsAPI).JavaScriptCompiler {\n  nameLookup(parent: any, name: any, type: string) {\n    if (type === 'partial' && typeof name === 'string' && isRemoteReference(name)) {\n      const iri = resolveTemplateIri(name);\n      return super.nameLookup(parent, iri.value, type);\n    }\n    return super.nameLookup(parent, name, type);\n  }\n}\nIRIResolvingCompiler.prototype.compiler = IRIResolvingCompiler;\n\nexport function isRemoteReference(partialName: string) {\n  return partialName.includes(':');\n}\n\nclass RemoteTemplateScanner extends Handlebars.Visitor {\n  readonly localReferences = new Set<string>();\n  readonly remoteReferences: string[] = [];\n\n  PartialStatement(partial: hbs.AST.PartialStatement): void {\n    this.addReference(partial);\n  }\n\n  PartialBlockStatement(partial: hbs.AST.PartialBlockStatement): void {\n    this.addReference(partial);\n  }\n\n  private addReference(partial: hbs.AST.PartialStatement | hbs.AST.PartialBlockStatement) {\n    const name = this.getPartialName(partial.name);\n    // exclude special partial names, e.g. @partial-block\n    if (name && name.indexOf('@') !== 0) {\n      if (isRemoteReference(name)) {\n        this.remoteReferences.push(name);\n      } else {\n        this.localReferences.add(name);\n      }\n    }\n  }\n\n  private getPartialName(name: hbs.AST.PathExpression | hbs.AST.SubExpression | hbs.AST.StringLiteral) {\n    if (name.type === 'PathExpression') {\n      const path = name as hbs.AST.PathExpression;\n      if (path.parts.length === 1) {\n        return path.original;\n      }\n    } else if (name.type === 'StringLiteral') {\n      return (name as hbs.AST.StringLiteral).value;\n    }\n    return undefined;\n  }\n}\n\nexport function createHandlebarsWithIRILookup() {\n  const handlebars = Handlebars.create();\n  (handlebars as HandlebarsAPI).JavaScriptCompiler = IRIResolvingCompiler;\n  return handlebars;\n}\n\nexport function parseTemplate(body: string): ParsedTemplate {\n  const ast = typeof body === 'string' ? Handlebars.parse(body) : body;\n  const scanner = new RemoteTemplateScanner();\n  scanner.accept(ast);\n\n  const references = scanner.localReferences;\n\n  // if reference starts with http then it is full IRI, otherwise it is prefixed one\n  const [expanded, prefixed] = partition(scanner.remoteReferences, ref => ref.startsWith('http'));\n  expanded.forEach(ref => references.add(ref));\n\n  SparqlUtil.resolveIris(prefixed)\n    .map((iri) => iri.value)\n    .forEach((remoteReference) => references.add(remoteReference));\n\n  return { source: body, ast, references: Array.from(references.values()) };\n}\n\nfunction resolveTemplateIri(ref: string) {\n  if (ref.startsWith('http:/')) {\n    return Rdf.iri(ref);\n  } else {\n    return SparqlUtil.resolveIris([ref])[0];\n  }\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { Parser as HtmlParser, Node } from 'html-to-react';\nimport * as render from 'dom-serializer';\n\nexport function isTemplate(node: Node): boolean {\n  return node.type === 'tag' && node.name === 'template';\n}\n\n/**\n * Extracts locally defined templates from a node.\n *\n * For example, `<set-management>` node in this markup locally defines\n * a separate template scope with templates 'foo', 'qux' and\n * 'http://www.researchspace.org/resource/system/bar':\n *\n * <set-management>\n *   <template id='foo'>\n *     <span style='backround: red'>{{> qux}}</span>\n *   </template>\n *   <template id='qux'>\n *     <div>QUX</div>\n *     {{> @partial-block}}\n *   </template>\n *   <template id='http://www.researchspace.org/resource/system/bar'>\n *     {{> foo}}\n *     {{#> qux}}footer{{/qux}}\n *   </template>\n * </set-management>\n */\nexport function extractTemplates(node: Node): Array<{ id: string; source: string }> {\n  let missingID = false;\n  const templateNodes = node.children\n    .filter((child) => child.name === 'template')\n    .filter((template) => {\n      const hasId = template.attribs.id !== undefined;\n      if (!hasId) {\n        missingID = true;\n      }\n      return hasId;\n    });\n\n  if (missingID) {\n    throw new Error(`Missing an ID attribute for a mini-template in <${node.name}>`);\n  }\n\n  return templateNodes.map((templateNode) => {\n    const id = templateNode.attribs.id;\n    const source = extractTemplate(templateNode);\n    return { id, source };\n  });\n}\n\nfunction extractTemplate(templateNode: Node): string {\n  const escapedTemplate = escapeTemplateBody(templateNode);\n  return getInnerHtml(escapedTemplate);\n}\n\nexport function escapeRemoteTemplateHtml(html: string): Promise<string> {\n  const parser = new HtmlParser(null);\n  const renderTemplate = (node: Node) => render(escapeChild(node));\n  return parser\n    .parseWithInstructions(`<div>${html}</div>`, (node) => true, [\n      {\n        shouldProcessNode: (node) => true,\n        processNode: (node) => node as any,\n      },\n    ])\n    .then((root: any) => {\n      const node = root as Node;\n      return node.children.map(renderTemplate).join('\\n');\n    });\n}\n\n/**\n * Escapes inline and nested templates of every element inside template and\n * inserts helper calls to be able to capture and restore Handelbars data context\n * across template / React boundaries.\n *\n * Each element inside markup (including template markup) creates its own\n * template scope and data context, so templates of the element needs to be\n * escaped in order to not be immediately expanded when rendering parent\n * template.\n *\n * Escaping implemented by raw helper blocks `{{{{capture}}}}`, e.g.\n *\n * <template-item template='{\"source\": \"{{> foo}}\", \"options\": {\"qux\": 42}}'>\n *   <template id='foo'>\n *     {{qux}}\n *     <template-item template='{\n *       \"source\": \"{{> foo}}\",\n *       \"options\": {\"qux\": 55}\n *     }'>\n *       <template id='foo'>{{qux}}, {{$parent.qux}}</template>\n *     </template-item>\n *   </template>\n * </template-item>\n *\n * would be escaped like this:\n *\n * <template-item template='{\"source\": \"{{> foo}}\", \"options\": {\"qux\": 42}}'>\n *   <template id='foo'>\n *     {{qux}}\n *     <template-item template='{\n *       \"source\": \"{{{{capture}}}}{{> foo}}{{{{/capture}}}}\",\n *       \"options\": {\"qux\": 55}\n *     }'>\n *       <template id='foo'>{{{{capture}}}}{{qux}}, {{$parent.qux}}{{{{/capture}}}}</template>\n *     </template-item>\n *   </template>\n * </template-item>\n */\nfunction escapeTemplateBody(node: Node): Node {\n  let newAttributes: Record<string, string> = undefined;\n  for (const key in node.attribs) {\n    if (!Object.prototype.hasOwnProperty.call(node.attribs, key)) {\n      continue;\n    }\n    const value = node.attribs[key];\n    const escaped = escapePartialReferences(value);\n    if (escaped !== value) {\n      if (!newAttributes) {\n        newAttributes = {};\n      }\n      newAttributes[key] = escaped;\n    }\n  }\n  const override: Partial<Node> = {\n    attribs: { ...node.attribs, ...newAttributes },\n    children: node.children ? node.children.map(escapeChild) : node.children,\n  };\n  return { ...node, ...override };\n}\n\nfunction escapeChild(child: Node) {\n  if (isTemplate(child)) {\n    if (!child.children || child.children.every(isEmptyTextNode)) {\n      // prevent Handlebars syntax error on empty {{{{capture}}}}{{{{/capture}}}} raw block\n      return child;\n    }\n\n    const { start, end } = generateEscapeBrackets();\n    const children: Node[] = [\n      { type: 'text', data: start, parent: child },\n      ...child.children,\n      { type: 'text', data: end, parent: child },\n    ];\n    return { ...child, children };\n  } else {\n    return escapeTemplateBody(child);\n  }\n}\n\nfunction isEmptyTextNode(node: Node) {\n  return node.type === 'text' && !node.data;\n}\n\nfunction escapePartialReferences(content: string): string {\n  if (content.indexOf('{{#>') >= 0) {\n    throw new Error('Partial blocks ({{#>) are disallowed in the inline templates');\n  }\n  const { start, end } = generateEscapeBrackets();\n  return content.replace(/({{>[^}\"']+}})/g, `${start}$1${end}`);\n}\n\nfunction generateEscapeBrackets() {\n  return {\n    start: `{{{{capture}}}}`,\n    end: `{{{{/capture}}}}`,\n  };\n}\n\n/**\n * Returns inner HTML of the node by concatenating it's children markup.\n */\nfunction getInnerHtml(node: Node) {\n  return node.children ? node.children.map(render).join('') : '';\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as Basil from 'basil.js';\nimport * as Immutable from 'immutable';\n\nimport { serialize, deserialize } from 'platform/api/json';\n\nconst UNSUPPORTED_MSG = 'Local storage is not available. Data will be persisted to memory.';\n\n/**\n * Wrapper around client-side persistence layer using basil.js.\n * Takes care of calling custom serialize and deserialize methods\n * when storing and retrieving data from the persistence layer.\n * Custom (de)serialization methods take in particular\n * care of proper (de)serialization  of immutable structures.\n *\n * Tries to use local storage by default and memory storage otherwise.\n */\nclass BrowserPersistenceClass {\n  private storage: any;\n  private readonly anyAdapter: PersistenceAdapter<any>;\n\n  constructor() {\n    this.storage = new Basil({\n      storages: ['local', 'memory'],\n    });\n\n    // if LocalStorage not available - show warning\n    if (!this.storage.check('local')) {\n      console.warn(UNSUPPORTED_MSG);\n    }\n\n    this.anyAdapter = this.createAdapter();\n  }\n\n  private createAdapter(): PersistenceAdapter<any> {\n    const get = (identifier: string): any => {\n      const item = this.getRawItem(identifier);\n      return typeof item === 'object' && item !== null ? item : {};\n    };\n    const set = (identifier: string, newState: any) => {\n      this.setItem(identifier, newState);\n    };\n    const update = (identifier: string, partialState: any) => {\n      set(identifier, { ...get(identifier), ...partialState });\n    };\n    const remove = (identifier: string) => {\n      this.removeItem(identifier);\n    };\n    return { get, set, update, remove };\n  }\n\n  /**\n   * Retrieves any entry from the persistence layer as idenfified by the composite key\n   * of the supplied namespace and identifier.\n   *\n   * Calls custom deserialize method before parsing back to JSON object.\n   *\n   * @param identifier - Identifier of the entry in the persistence layer. Must be unqiue\n   *                     within the supplied namespace or globally if no namespace is supplied.\n   * @param namespace - Optional namespace to prefix the identifier in the persistence layer.\n   *                    If namespace is provided it will be used as composite\n   *                    key in the persistence layer together with the identifier.\n   * @returns Any object as being persisted and deserialized.\n   *                     Object will be wrapped into immutable strucures.\n   */\n  public getItem(identifier: string, namespace?: string): any {\n    return Immutable.fromJS(this.getRawItem(identifier, namespace));\n  }\n\n  private getRawItem(identifier: string, namespace?: string): any {\n    const value = this.storage.get(identifier, { namespace });\n    return deserialize(JSON.parse(value));\n  }\n\n  /**\n   * Stores any supplied object into the persistence layer (possibly overwritting existing entry)\n   * using a composition of the supplied namespace and identifier as key.\n   *\n   * Calls custom serialize method before object will be stringified.\n   *\n   * @param identifier - Identifier of the entry in the persistence layer to be set. Must be unqiue\n   *                     within the supplied namespace or globally if no namespace is supplied.\n   * @param value - any object to be persisted\n   * @param namespace - Optional namespace to prefix the identifier in the persistence layer.\n   *                    If namespace is provided it will be used as composite\n   *                    key in the persistence layer together with the identifier.\n   */\n  public setItem(identifier: string, value: any, namespace?: string): void {\n    this.storage.set(identifier, JSON.stringify(serialize(value)), { namespace });\n  }\n\n  /**\n   * Removes any existing entry from the persistence layer as idenfified by the composite key\n   * of the supplied namespace and identifier.\n   *\n   * @param identifier - Identifier of the entry in the persistence layer to be deleted.\n   *                     Must be unqiue within the supplied namespace or globally\n   *                     if no namespace is supplied.\n   * @param namespace - Optional namespace to prefix the identifier in the persistence layer.\n   *                    If namespace is provided it will be used as composite\n   *                    key in the persistence layer together with the identifier.\n   */\n  public removeItem(identifier: string, namespace?: string): void {\n    this.storage.remove(identifier, { namespace });\n  }\n\n  adapter<State>(): PersistenceAdapter<State> {\n    return this.anyAdapter;\n  }\n}\n\n// TODO: uncomment type constraint when 'object' would be available\nexport interface PersistenceAdapter<State /* extends object */> {\n  get(identifier: string): State;\n  set(identifier: string, newState: State): void;\n  update(identifier: string, partialState: State): void;\n  remove(identifier: string): void;\n}\n\nexport const BrowserPersistence = new BrowserPersistenceClass();\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { DataContextFunctions } from './DataContextFunctions';\nimport { GenericFunctions } from './GenericFunctions';\nimport { DateTimeFunctions } from './DateTimeFunctions';\nimport { RdfFunctions } from './RdfFunctions';\nimport { UriComponentFunctions } from './UriComponentFunctions';\nimport { NumbersFunctions } from './NumbersFunctions';\n\nexport const DefaultHelpers = {\n  ...DataContextFunctions,\n  ...GenericFunctions,\n  ...DateTimeFunctions,\n  ...RdfFunctions,\n  ...UriComponentFunctions,\n  ...NumbersFunctions,\n};\n\nexport { ContextCapturer, CapturedContext } from './DataContextFunctions';\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nexport interface DataContext {\n  /** `this` context */\n  context: any;\n  /** `@data` stack */\n  data: HandlebarsDataStack;\n}\n\nexport class ContextCapturer {\n  static readonly DATA_KEY = '$contextCapturer';\n\n  constructor(private contexts?: Map<number, DataContext>) {}\n\n  private static lastContextKey = 0;\n  private static generateUniqueContextKey(): number {\n    ContextCapturer.lastContextKey++;\n    return ContextCapturer.lastContextKey;\n  }\n\n  /** @returns context key for {{expose}} block */\n  captureContext(dataContext: DataContext): number {\n    const { context, data } = dataContext;\n    const key = ContextCapturer.generateUniqueContextKey();\n    if (!this.contexts) {\n      this.contexts = new Map<number, DataContext>();\n    }\n    this.contexts.set(key, { context, data: cloneContextData(data) });\n    return key;\n  }\n\n  getResult() {\n    return new CapturedContext(this.contexts);\n  }\n}\n\nexport class CapturedContext {\n  static readonly DATA_KEY = '$capturedContext';\n\n  constructor(private contexts?: ReadonlyMap<number, DataContext>) {}\n\n  getContext(contextKey: number): DataContext | undefined {\n    if (!this.contexts) {\n      return undefined;\n    }\n    const context = this.contexts.get(contextKey);\n    if (!context) {\n      console.warn(`Missing context for context key ${contextKey}`);\n    }\n    return context;\n  }\n\n  static inheritAndCapture(base?: CapturedContext) {\n    const inheritedContexts = base && base.contexts ? new Map(base.contexts) : undefined;\n    return new ContextCapturer(inheritedContexts);\n  }\n}\n\n/**\n * Represents `@data` stack from Handlebars template context.\n */\ninterface HandlebarsDataStack {\n  _parent?: HandlebarsDataStack;\n  root?: any;\n  index?: number;\n  key?: number | string;\n  first?: boolean;\n  last?: boolean;\n}\n\nconst CAPTURED_DATA_KEYS: Array<keyof HandlebarsDataStack> = ['root', 'index', 'key', 'first', 'last'];\n\nfunction cloneContextData(data: HandlebarsDataStack) {\n  if (!data) {\n    return data;\n  }\n  const clone: HandlebarsDataStack = {};\n  for (const key of CAPTURED_DATA_KEYS) {\n    if (key in data) {\n      (clone as any)[key] = data[key];\n    }\n  }\n  if ('_parent' in data) {\n    clone._parent = cloneContextData(data._parent);\n  }\n  return clone;\n}\n\nfunction mergeDataContext(outer: any, inner: any) {\n  if (isPlainObjectOrNothing(inner)) {\n    if (isPlainObjectOrNothing(outer)) {\n      return { ...outer, ...inner };\n    } else {\n      // 'outer' is a primitive and can be inherited only when 'inner' is empty\n      return hasAnyOwnKey(inner) ? inner : outer;\n    }\n  } else {\n    // 'inner' is a primitive and cannot inherit data context\n    return inner;\n  }\n}\n\n/**\n * Checks if `target` is a plain object (not function, class instance or boxed primitive)\n * or `undefined` / `null`.\n */\nfunction isPlainObjectOrNothing(target: any) {\n  if (target === null || target === undefined) {\n    return true;\n  }\n  if (typeof target !== 'object') {\n    return false;\n  }\n  const prototype = Object.getPrototypeOf(target);\n  return !prototype || prototype === Object.getPrototypeOf({});\n}\n\nfunction hasAnyOwnKey(target: object): boolean {\n  for (const key in target) {\n    if (target.hasOwnProperty(key)) {\n      return true;\n    }\n  }\n  return false;\n}\n\nfunction overrideContextData(base: HandlebarsDataStack, override: HandlebarsDataStack): HandlebarsDataStack {\n  const result = { ...base, ...override };\n  if (base._parent && override._parent) {\n    result._parent = overrideContextData(base._parent, override._parent);\n  }\n  return result;\n}\n\nexport const DataContextFunctions = {\n  /**\n   * {{{{capture}}}} raw helper escapes it's child template and captures all\n   * available template context (`this` context and `@data` stack) at that point.\n   * `ContextCapturer` instance in `@data` stack is required to be able to capture.\n   *\n   * When result is evaluated the second time, it uses {{#expose <generated-key>}} block to\n   * restore captured template context.\n   *\n   * Currently it is not possible to directly refer to parent context (../something)\n   * because parent `this` context doesn't exposed to helper functions\n   * (in contrast with `@data`-references like `@../key`), e.g:\n   * ```\n   * {{#each xs}} {{#each ys}}\n   *   {{-- this won't work --}}\n   *   x={{..}}\n   * {{/each}} {{/each}}\n   * ```\n   * It's possible to use either a partial call or dynamic lookup by index as a workaround.\n   */\n  capture: function (this: any, options: any) {\n    const data = options ? options.data : {};\n    const capturedContext = data[ContextCapturer.DATA_KEY];\n    if (capturedContext instanceof ContextCapturer) {\n      const key = capturedContext.captureContext({ context: this, data: options.data });\n      return `{{#expose ${key}}}${options.fn(this)}{{/expose}}`;\n    }\n    return options.fn(this);\n  },\n\n  /**\n   * {{expose <generated-key>}} helper restores previously captured template context\n   * (`this` context and `@data` stack) using `CapturedContext` in `@data` stack.\n   */\n  expose: function (this: any, key: number, options: any) {\n    if (typeof key !== 'number') {\n      throw new Error('{{#expose}} context key is missing or not a number');\n    }\n\n    const data = options ? options.data : {};\n    const capturedContext = data[CapturedContext.DATA_KEY];\n    const dataContext = capturedContext instanceof CapturedContext ? capturedContext.getContext(key) : undefined;\n\n    if (dataContext) {\n      return options.fn(mergeDataContext(dataContext.context, this), {\n        data: overrideContextData(data, dataContext.data),\n      });\n    } else {\n      return options.fn(this);\n    }\n  },\n\n  /**\n   * {{bind}} helper allows to explicitly put any referenceable value into\n   * current data context. This allows to reference aliased block params (`as |foo|`)\n   * and values from parent data context (`../../foo`) when invoking a partial.\n   * @example\n   * <!-- outer context: foos, bars, qux -->\n   * {{#each foos as |foo|}}\n   *   {{#each bars as |bar|}}\n   *      {{bind f=foo b=bar q=../../qux}}\n   *        <semantic-query query='SELECT * WHERE {}'\n   *          template='{{> sub foo=f bar=b qux=q}}'>\n   *          <template id='sub'>\n   *            <span>{{foo}} {{bar}} {{qux}}</span>\n   *          </template>\n   *        </semantic-query>\n   *     {{/bind}}\n   *   {{/each}}\n   * {{/each}}\n   */\n  bind: function (this: any, options: any) {\n    const boundContext = mergeDataContext(this, options.hash);\n    return options.fn(boundContext);\n  },\n};\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as React from 'react';\nimport * as _ from 'lodash';\n\nimport { ErrorNotification } from 'platform/components/ui/notification';\n\nconst ERROR = '__unsafeError';\nconst WRAPPED_BY_CATCHER = '__wrappedByErrorCatcher';\nconst METHODS_TO_WRAP = [\n  'componentWillMount',\n  'componentDidMount',\n  'componentWillReceiveProps',\n  'componentWillUpdate',\n  'componentDidUpdate',\n  'componentWillUnmount',\n];\n\n/**\n * Wrap component prototype functions to catch unexpected errors.\n */\nfunction wrap(component) {\n  return function (method) {\n    const isMethodNotDefined =\n      _.isUndefined(component.prototype) ||\n      !(component.prototype.hasOwnProperty(method) && component.prototype[method]);\n    if (isMethodNotDefined) {\n      return;\n    }\n\n    const unsafe = component.prototype[method];\n    const safe = function () {\n      try {\n        unsafe.apply(this, arguments);\n      } catch (e) {\n        console.error(e);\n        this.setState({ [ERROR]: e });\n      }\n    };\n    safe[WRAPPED_BY_CATCHER] = true;\n    component.prototype[method] = safe;\n  };\n}\n\n/**\n * Wrap react component creation functions to catch unexpected errors.\n */\nfunction wrapComponent<F extends Function>(original: F): F {\n  return function (comp) {\n    if (\n      _.isUndefined(comp.prototype) ||\n      comp instanceof ErrorNotification ||\n      comp[WRAPPED_BY_CATCHER] // prevent multiple wrapping\n    ) {\n      return original.apply(this, arguments);\n    }\n    comp[WRAPPED_BY_CATCHER] = true;\n\n    if (!comp.prototype.componentDidCatch) {\n      comp.prototype.componentDidCatch = defaultComponentDidCatch;\n    }\n\n    const unsafeRender = comp.prototype.render;\n    // Default unstable_handleError (without override) set state item\n    // that leads to error message rendering\n    if (!comp.prototype.unstable_handleError) {\n      comp.prototype.unstable_handleError = function (e) {\n        this.setState({ [ERROR]: e });\n      };\n    }\n    comp.prototype.render = function () {\n      const error = getError(this);\n      if (error !== undefined) {\n        return React.createElement(ErrorNotification, { errorMessage: error });\n      } else {\n        try {\n          return unsafeRender.apply(this);\n        } catch (e) {\n          console.error(e);\n          return React.createElement(ErrorNotification, { errorMessage: e });\n        }\n      }\n    };\n    _.forEach(METHODS_TO_WRAP, wrap(comp));\n\n    if (comp.prototype.getChildContext) {\n      const unsafeGetChildContext = comp.prototype.getChildContext;\n      comp.prototype.getChildContext = function () {\n        // prevent stack overflow on error\n        if (getError(this) !== undefined) {\n          return undefined;\n        }\n        try {\n          return unsafeGetChildContext.apply(this);\n        } catch (e) {\n          console.error(e);\n          this.setState({ [ERROR]: e });\n          return undefined;\n        }\n      };\n    }\n\n    return original.apply(this, arguments);\n  } as any;\n}\n\nfunction defaultComponentDidCatch(this: React.Component<any, any>, error: any, info: { componentStack: string }) {\n  console.error(error);\n  console.error(info.componentStack);\n  this.setState({ [ERROR]: error });\n}\n\nfunction getError(componentInstance: any) {\n  return componentInstance.state ? componentInstance.state[ERROR] : undefined;\n}\n\n/**\n * Wrapped versions of React.createElement and React.createFactory\n * Components created by them handle exceptions in React lifetime methods (enumerated in METHODS_TO_WRAP)\n * and display messages about exceptions if any instead of component render result\n * Also user can override unstable_handleError in order to get other desired behavior\n */\nexport const safeReactCreateElement = wrapComponent(React.createElement);\nexport const safeReactCreateFactory = wrapComponent(React.createFactory);\n\n/**\n * Changes react functions like createElement and createFactory in a way that\n * all errors thrown from the components will not be propagated up the tree and\n * will not crash the main app. Instead error message will be shown in place of\n * failed component.\n */\nexport function initReactErrorCatcher() {\n  /**/\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nexport {\n  PlatformComponent as Component,\n  ComponentProps,\n  ComponentContext,\n  ContextTypes,\n  ComponentChildContext,\n} from './PlatformComponent';\n\nexport * from './SemanticContext';\nexport { TemplateContext, TemplateContextTypes } from './TemplateContext';\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as PropTypes from 'prop-types';\n\nimport * as TemplateService from 'platform/api/services/template';\n\n/**\n * @author Alexey Morozov\n */\nexport interface TemplateContext {\n  readonly templateScope: TemplateService.TemplateScope;\n  readonly templateDataContext?: TemplateService.CapturedContext;\n}\n\nexport const TemplateContextTypes: Readonly<Record<keyof TemplateContext, any>> = {\n  templateScope: PropTypes.object,\n  templateDataContext: PropTypes.object,\n};\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { EventType } from './EventsApi';\n\nexport type EventMaker<EventData> = <K extends keyof EventData>(key: K) => EventType<EventData[K]>;\nexport const EventMaker: EventMaker<any> = (key) => key as any;\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as Kefir from 'kefir';\nimport { post } from 'platform/api/http';\nimport * as Immutable from 'immutable';\n\nimport { BatchedPool, requestAsProperty } from 'platform/api/async';\nimport { Rdf } from 'platform/api/rdf';\nimport { QueryContext } from 'platform/api/sparql';\n\nexport class BaseResourceService {\n  private serviceUrl: string;\n  private pools = new Map<string, BatchedPool<string, string>>();\n\n  constructor(serviceUrl: string) {\n    this.serviceUrl = serviceUrl;\n  }\n\n  private getPool(context?: QueryContext) {\n    const repository = getRepositoryFromContext(context);\n    if (!this.pools.has(repository)) {\n      this.pools.set(\n        repository,\n        new BatchedPool<string, string>({\n          fetch: (iris) => this.fetchResources(iris.toArray(), repository),\n        })\n      );\n    }\n    return this.pools.get(repository);\n  }\n\n  getResource(iri: Rdf.Iri, context?: QueryContext): Kefir.Property<string> {\n    return this.getPool(context).query(iri.value);\n  }\n\n  getResources(iris: ReadonlyArray<Rdf.Iri>, context?: QueryContext): Kefir.Property<Immutable.Map<Rdf.Iri, string>> {\n    if (iris.length === 0) {\n      return Kefir.constant(Immutable.Map());\n    }\n\n    const pool = this.getPool(context);\n    if (iris.length >= pool.batchSize) {\n      const repository = getRepositoryFromContext(context);\n      return this.fetchResources(\n        iris.map((iri) => iri.value),\n        repository\n      ).map((labels) =>\n        Immutable.Map<Rdf.Iri, string>().withMutations((map) => {\n          for (const iri of iris) {\n            map.set(iri, labels.get(iri.value));\n          }\n        })\n      );\n    }\n\n    return Kefir.combine(\n      iris.map((iri) => this.getResource(iri, context).map((value) => [iri, value] as [Rdf.Iri, string]))\n    )\n      .map(Immutable.Map as <K, V>(pairs: ReadonlyArray<[K, V]>) => Immutable.Map<K, V>)\n      .toProperty();\n  }\n\n  protected createRequest(resources: string[], repository: string) {\n    const request = post(this.serviceUrl)\n      .send(resources)\n      .query({ repository: repository })\n      .type('application/json')\n      .accept('application/json');\n    return request;\n  }\n\n  protected fetchResources(resources: string[], repository: string) {\n    const request = this.createRequest(resources, repository);\n    return requestAsProperty(request).map((response) => {\n      const batch = response.body as { [key: string]: string };\n      return Immutable.Map(batch);\n    });\n  }\n}\n\nfunction getRepositoryFromContext(context: QueryContext | undefined): string {\n  if (context) {\n    if (context.repository) {\n      return context.repository;\n    }\n  }\n  return 'default';\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { Component, Props as ReactProps, MouseEvent } from 'react';\nimport * as D from 'react-dom-factories';\nimport * as classNames from 'classnames';\nimport * as uri from 'urijs';\nimport * as _ from 'lodash';\n\nimport { navigateToUrl, getCurrentUrl } from '../Navigation';\nimport { extractParams } from '../NavigationUtils';\n\n/**\n * Component that uses platform 'Navigation',\n * to navigate to the given internal URL without page reload.\n *\n * @example\n *   <mp-link url=\"/sparql\">sparql</mp-link>\n */\nexport interface LinkConfig {\n  /**\n   * Root-relative URL to navigate to. e.g \"/sparql\"\n   */\n  url: string;\n\n  /**\n   * link title shown on mouse-hover\n   */\n  title?: string;\n\n  /**\n   * 'urlqueryparam-*' attribute specify additional url query parameters\n   * that will be attached to the resulting url\n   */\n  params?: { [name: string]: string };\n\n  /**\n   * if link should be highlighted as active, if not specified\n   * link will be highlighted by active if link's url\n   * and parameters fully match current location\n   */\n  active?: boolean;\n\n  /**\n   * css class names list\n   */\n  className?: string;\n\n  /**\n   * css classes that should be applied to the active link\n   */\n  activeClassName?: string;\n}\nexport type LinkProps = LinkConfig & ReactProps<LinkComponent>;\n\nexport class LinkComponent extends Component<LinkProps, {}> {\n  public render() {\n    const { title, className, activeClassName } = this.props;\n    const props = {\n      title: title,\n      className: classNames(className, {\n        [activeClassName]: this.isLinkActive(this.props),\n      }),\n      onClick: this.onClick,\n    };\n    return D.a(props, this.props.children);\n  }\n\n  private onClick = (e: MouseEvent<HTMLAnchorElement>) => {\n    e.preventDefault();\n    e.stopPropagation();\n\n    navigateToUrl(this.constructUrl(this.props)).onValue(() => {\n      /**/\n    });\n  };\n\n  private constructUrl(props: LinkProps) {\n    const { url } = props;\n    const query = extractParams(props);\n    return uri(url).setSearch(query);\n  }\n\n  private isLinkActive(props: LinkProps) {\n    const url = this.constructUrl(props);\n    return getCurrentUrl().equals(url) && (_.isUndefined(this.props.active) ? true : this.props.active);\n  }\n}\nexport default LinkComponent;\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as SparqlClient from './SparqlClient';\nimport * as SparqlTypeGuards from './TypeGuards';\nimport * as SparqlUtil from './SparqlUtil';\n\nexport { SparqlClient, SparqlTypeGuards, SparqlUtil };\nexport * from './QueryVisitor';\nexport { QueryContext } from './SparqlClient';\nexport * from './QueryBinder';\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as NavigationUtils from './NavigationUtils';\nexport * from './Navigation';\nexport { NavigationUtils };\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nexport * from './Link';\nexport * from './ResourceLinkComponent';\nexport * from './ResourceLinkContainer';\nexport * from './ResourceLink';\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as Kefir from 'kefir';\n\n/**\n * Utility object to propagate Kefir.Observable deactivation (cancellation).\n *\n * @example\n *\n * const cancellation = new Cancellation();\n *\n * const taskA = cancellation.map(query(...))\n *  .onValue(value => { [only called if not cancelled] });\n * const taskB = cancellation.map(query(...));\n *\n * const subCancellation = cancellation.derive();\n * const taskC = subCancellation.map(query(...));\n * // ends taskC observable\n * subCancellation.cancelAll();\n *\n * // ends all mapped observables (taskA, taskB, taskC)\n * cancellation.cancelAll();\n *\n * @author Alexey Morozov\n */\nexport class Cancellation {\n  static readonly cancelled = new Cancellation();\n\n  private isCancelled = false;\n  private cancelHandlers: Array<() => void> = [];\n\n  get aborted() {\n    return this.isCancelled;\n  }\n\n  /**\n   * Wraps observable as another which produces the same values and errors,\n   * unsibscribes from source and ends when .cancelAll() invoked.\n   */\n  map<T>(observable: Kefir.Observable<T>): Kefir.Property<T> {\n    if (this.isCancelled) {\n      return Kefir.never<T>().toProperty();\n    }\n    const { observable: mapped, dispose } = subscribe(observable);\n    this.onCancel(dispose);\n    return mapped.toProperty();\n  }\n\n  /**\n   * Creates derived Cancellation which becomes cancelled when parent is cancelled.\n   */\n  derive(): Cancellation {\n    const derived = new Cancellation();\n    if (!this.isCancelled) {\n      this.onCancel(() => derived.cancelAll());\n    }\n    return derived;\n  }\n\n  /**\n   * Convenient method to cancel token and replace it with a newly derived one.\n   */\n  deriveAndCancel(previous: Cancellation): Cancellation {\n    previous.cancelAll();\n    return this.derive();\n  }\n\n  /**\n   * Register handler which is invoked when this Cancellation\n   * becomes cancelled or if it was already cancelled.\n   */\n  onCancel(handler: () => void) {\n    if (this.isCancelled) {\n      handler();\n    } else {\n      this.cancelHandlers.push(handler);\n    }\n  }\n\n  /**\n   * Unregisters specified handler from cancel notifications.\n   */\n  offCancel(handler: () => void) {\n    if (!this.isCancelled && this.cancelHandlers) {\n      const index = this.cancelHandlers.findIndex(handler);\n      if (index >= 0) {\n        this.cancelHandlers.splice(index, 1);\n      }\n    }\n  }\n\n  /**\n   * Makes this Cancellation cancelled and ends all wrapped observables.\n   */\n  cancelAll() {\n    if (this.isCancelled) {\n      return;\n    }\n    this.isCancelled = true;\n    for (const onCancel of this.cancelHandlers) {\n      onCancel();\n    }\n    this.cancelHandlers = undefined;\n  }\n}\n\nfunction subscribe<T>(\n  source: Kefir.Observable<T>\n): {\n  observable: Kefir.Stream<T>;\n  dispose: () => void;\n} {\n  if (!source) {\n    throw new Error('source observable must be present');\n  }\n\n  let disposed = false;\n  let subscription: Kefir.Subscription;\n  const dispose = () => {\n    if (disposed) {\n      return;\n    }\n    disposed = true;\n    if (subscription) {\n      subscription.unsubscribe();\n    }\n  };\n\n  const observable = Kefir.stream<T>((emitter) => {\n    if (disposed) {\n      emitter.end();\n    } else {\n      subscription = source.observe({\n        value: (value) => emitter.emit(value),\n        error: (error) => emitter.error(error),\n        end: () => emitter.end(),\n      });\n    }\n    return dispose;\n  });\n\n  return { observable, dispose };\n}\n\nCancellation.cancelled.cancelAll();\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { EventMaker } from 'platform/api/events';\n\nexport interface SetManagementEventData {\n  'Components.SetManagement.SetAdded': void;\n  'Components.SetManagement.SetRenamed': void;\n  'Components.SetManagement.SetRemoved': void;\n  'Components.SetManagement.ItemAdded': void;\n  'Components.SetManagement.ItemRemoved': void;\n  'Components.SetManagement.ItemSelected': string;\n  'Components.SetManagement.ItemsReordered': void;\n  'Components.SetManagement.ItemsFiltered': ItemsFilteredData;\n  'Components.SetManagement.ItemsFetched': { iris: Array<string> };\n}\nconst event: EventMaker<SetManagementEventData> = EventMaker;\n\nexport type SetManagementEvents = typeof SetManagementEvents;\nexport namespace SetManagementEvents {\n  export const SetAdded = event('Components.SetManagement.SetAdded');\n  export const SetRenamed = event('Components.SetManagement.SetRenamed');\n  export const SetRemoved = event('Components.SetManagement.SetRemoved');\n  export const ItemAdded = event('Components.SetManagement.ItemAdded');\n  export const ItemRemoved = event('Components.SetManagement.ItemRemoved');\n  export const ItemSelected = event('Components.SetManagement.ItemSelected');\n  export const ItemsReordered = event('Components.SetManagement.ItemsReordered');\n  export const ItemsFiltered = event('Components.SetManagement.ItemsFiltered');\n  export const ItemsFetched = event('Components.SetManagement.ItemsFetched');\n}\n\nexport type SetManagementEventType = SetManagementEvents[keyof SetManagementEvents];\n\nexport interface ItemsFilteredData {\n  iris?: Array<string>;\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as Kefir from 'kefir';\nimport * as request from 'platform/api/http';\n\nimport { requestAsProperty } from 'platform/api/async';\n\nconst REST_CONFIG_GROUP_URL = '/rest/config';\n\nexport interface ConfigGroup {\n  parameterType: 'string' | 'boolean' | 'integer' | 'stringList';\n  value: string | boolean | number | ReadonlyArray<string> | null;\n  definedByApps: ReadonlyArray<string>;\n  shadowed: boolean;\n}\n\nexport interface ConfigStorageStatus {\n  appId: string;\n  writable: boolean;\n}\n\nexport function getConfigsInGroup(group: string): Kefir.Property<{ [key: string]: ConfigGroup }> {\n  const req = request\n    .get(REST_CONFIG_GROUP_URL + `/${group}`)\n    .type('application/json')\n    .accept('application/json');\n  return requestAsProperty(req).map((res) => res.body);\n}\n\nexport function setConfig(group: string, name: string, values: ReadonlyArray<string>, targetAppId: string) {\n  const req = request\n    .put(REST_CONFIG_GROUP_URL + `/${group}/${name}`)\n    .type('application/json')\n    .query({ targetAppId })\n    .send(values);\n  return requestAsProperty(req).map((res) => res.ok);\n}\n\nexport function deleteConfig(group: string, name: string, targetAppId: string) {\n  const req = request.delete(REST_CONFIG_GROUP_URL + `/${group}/${name}`).query({ targetAppId });\n  return requestAsProperty(req).map((res) => res.ok);\n}\n\nexport function getStorageStatus(): Kefir.Property<ConfigStorageStatus[]> {\n  const req = request\n    .get(REST_CONFIG_GROUP_URL + `/storageStatus`)\n    .type('application/json')\n    .accept('application/json');\n  return requestAsProperty(req).map((res) => res.body);\n}\n\nexport function configValueToArray(value: ConfigGroup['value']) {\n  return Array.isArray(value) ? value : value === null || value === undefined ? [] : [value.toString()];\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { ReactElement, Props, Children } from 'react';\nimport { fromNullable } from 'data.maybe';\n\nimport { ComponentProps, SemanticContext } from 'platform/api/components';\nimport { serialize, deserialize } from 'platform/api/json';\nimport { ComponentClassMetadata } from 'platform/api/module-loader';\nimport { Rdf, ObjectGraph } from 'platform/api/rdf';\nimport { rdf, persist } from 'platform/api/rdf/vocabularies';\nimport { QueryContext } from 'platform/api/sparql';\nimport { TemplateScope, TemplateScopeProps } from 'platform/api/services/template';\n\ninterface RawComponentContext {\n  templateProps: TemplateScopeProps;\n  semanticContext?: QueryContext;\n}\n\n/**\n * Serializes any React DOM element or platform component registered in `component.json`\n * into RDF graph. Component's props must contain only serializable values (primitives,\n * arrays, raw objects).\n *\n * @see ActionSaveComponent\n * @see PersistedComponent\n */\nexport function componentToGraph(params: {\n  /** Serialized component. */\n  component: ReactElement<any>;\n  /** Pointer to root component structure withing the result graph. */\n  componentRoot: Rdf.Node;\n  /**\n   * Effective template scope from outer React context for the component.\n   *\n   * This value is available through `PlatformComponent.appliedTemplateScope` of parent component\n   * and required if the component uses any templates from parent scope.\n   */\n  parentTemplateScope?: TemplateScope;\n  /** Semantic context from outer React context for the component. */\n  semanticContext?: QueryContext;\n}): Rdf.PointedGraph {\n  const { component, componentRoot, parentTemplateScope, semanticContext } = params;\n\n  const htmlTag =\n    typeof component.type === 'string'\n      ? component.type\n      : typeof component.type === 'function'\n      ? (component.type as ComponentClassMetadata).__htmlTag\n      : undefined;\n  if (!htmlTag) {\n    throw new Error('Cannot serialize component with unknown HTML tag');\n  }\n\n  const componentNamespace = Rdf.iri(persist.COMPONENT_TYPE_PREFIX + htmlTag);\n  type CustomComponentProps = Props<any> & ComponentProps;\n  const { markupTemplateScope, children, ...otherProps } = component.props as CustomComponentProps;\n\n  const appliedScope = markupTemplateScope || parentTemplateScope || TemplateScope.default;\n\n  const propsGraph = ObjectGraph.serialize(otherProps, componentNamespace);\n  const result = propsGraph.graph.triples.toArray();\n  result.push(\n    Rdf.triple(componentRoot, rdf.type, persist.PersistedComponent),\n    Rdf.triple(componentRoot, persist.componentType, componentNamespace),\n    Rdf.triple(componentRoot, persist.componentProps, propsGraph.pointer)\n  );\n\n  if (children && Children.count(children) > 0) {\n    const serializedChildren = Children.toArray(children).map((child, index) =>\n      componentToGraph({\n        component: child as any,\n        componentRoot: Rdf.bnode(),\n        parentTemplateScope: appliedScope,\n      })\n    );\n    const childrenGraph = ObjectGraph.serializeArray(serializedChildren, (child) => child);\n    result.push(...childrenGraph.graph.triples.toArray());\n    result.push(Rdf.triple(componentRoot, persist.componentChildren, childrenGraph.pointer));\n  }\n\n  if (isCustomElementTag(htmlTag)) {\n    const rawContext: RawComponentContext = {\n      templateProps: appliedScope.exportProps(),\n      semanticContext,\n    };\n    const contextGraph = ObjectGraph.serialize(serialize(rawContext), persist.componentContext);\n    result.push(...contextGraph.graph.triples.toArray());\n    result.push(Rdf.triple(componentRoot, persist.componentContext, contextGraph.pointer));\n  }\n\n  return Rdf.pg(componentRoot, Rdf.graph(result));\n}\n\nexport interface DeserializedComponent {\n  type: string;\n  props: any;\n  children: DeserializedComponent[];\n}\n\nexport interface DeserializationResult {\n  component: DeserializedComponent;\n  context: SemanticContext;\n}\n\n/**\n * Deserializes a platform component from an RDF graph generated by `componentToGraph()`.\n */\nexport function graphToComponent(root: Rdf.Node, graph: Rdf.Graph): DeserializationResult {\n  const componentTypeTriple = graph.triples\n    .filter((t) => t.s.equals(root) && t.p.equals(persist.componentType))\n    .first();\n  if (!componentTypeTriple) {\n    throw new Error(`Missing componentType for ${root}`);\n  }\n  const componentType = componentTypeTriple.o.value;\n\n  const componentPropsTriple = graph.triples\n    .filter((t) => t.s.equals(root) && t.p.equals(persist.componentProps))\n    .first();\n  if (!componentPropsTriple) {\n    throw new Error(`Missing componentProps for ${root}`);\n  }\n  const componentProps = componentPropsTriple.o;\n\n  const componentChildrenRoot = fromNullable(\n    graph.triples.filter((t) => t.s.equals(root) && t.p.equals(persist.componentChildren)).first()\n  ).map((t) => t.o);\n  const componentContextRoot = fromNullable(\n    graph.triples.filter((t) => t.s.equals(root) && t.p.equals(persist.componentContext)).first()\n  ).map((t) => t.o);\n\n  if (!componentType.startsWith(persist.COMPONENT_TYPE_PREFIX)) {\n    throw new Error(`Invalid componentType <${componentType}> for ${root}`);\n  }\n\n  const type = componentType.substr(persist.COMPONENT_TYPE_PREFIX.length);\n  let props: Props<any> & ComponentProps = ObjectGraph.deserialize(componentProps, graph);\n  let children: DeserializedComponent[] = [];\n  let context: SemanticContext = { semanticContext: {} };\n\n  if (componentChildrenRoot.isJust) {\n    children = ObjectGraph.deserializeArray(componentChildrenRoot.get(), graph, (pointer) => {\n      // discard child's context (it should be empty)\n      const { component } = graphToComponent(pointer, graph);\n      return component;\n    });\n  }\n\n  if (isCustomElementTag(type) && componentContextRoot.isJust) {\n    const { semanticContext, templateProps } = deserialize<RawComponentContext>(\n      ObjectGraph.deserialize(componentContextRoot.get(), graph)\n    );\n    context = { semanticContext };\n    props = {\n      ...props,\n      markupTemplateScope: TemplateScope.create(templateProps),\n    };\n  }\n\n  const component: DeserializedComponent = {\n    type,\n    props: props as any,\n    children,\n  };\n  return { component, context };\n}\n\nfunction isCustomElementTag(tagName: string): boolean {\n  return tagName.indexOf('-') >= 0;\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\n/**\n * @author Mike Kelly <mkelly@britishmuseum.org>\n */\n\nconst h = require('history');\n\nimport { BrowserPersistence } from 'platform/api/persistence';\n\nconst BH_RECENT_PAGES = 'recentPages';\nconst MAX_BH_RECENT_QUERIES = 12;\nlet recentPages = BrowserPersistence.getItem(BH_RECENT_PAGES);\nif (!recentPages || recentPages.toArray().length === 0) {\n  recentPages = [];\n} else {\n  recentPages = recentPages.toArray();\n}\n\n/**\n * Persistent History\n *\n * Use MemoryHistory from the 'history' API to store page changes\n * and persist them to the browser, for use in BrowseHistoryComponent\n */\n\nexport const MemoryHistory = h.createMemoryHistory({\n  initialEntries: recentPages,\n  initialIndex: 0,\n});\n\nexport function init(init, notifyAll) {\n  MemoryHistory.listen((location, action) =>\n    init(location).onValue((mUrl) => mUrl.map((url) => notifyAll({ url: url, action: action })))\n  );\n}\n\nexport function clearPersistedRecentPages() {\n  const noPages = [];\n  BrowserPersistence.setItem(BH_RECENT_PAGES, noPages);\n}\n\nexport function persistRecentPages(newUrl: string): void {\n  let memoryEntries = MemoryHistory.entries.map((entry) => entry.pathname + entry.search);\n  if (memoryEntries.find((entry) => entry === newUrl) === undefined) {\n    MemoryHistory.push(newUrl);\n  } else {\n    MemoryHistory.entries.push(\n      MemoryHistory.entries.splice(\n        MemoryHistory.entries.findIndex((entry) => entry.pathname + entry.search === newUrl),\n        1\n      )[0]\n    );\n  }\n\n  let pages = MemoryHistory.entries.map((location) => location.pathname + location.search);\n  if (pages.length > MAX_BH_RECENT_QUERIES) {\n    pages.pop();\n  }\n  BrowserPersistence.setItem(BH_RECENT_PAGES, pages);\n}\n\nexport function resetMemoryHistory() {\n  MemoryHistory.entries = [];\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { ReactElement, ReactNode, createElement, CSSProperties, ComponentClass } from 'react';\nimport * as D from 'react-dom-factories';\n\nimport * as assign from 'object-assign';\nimport * as _ from 'lodash';\nimport { Set } from 'immutable';\nimport * as React from 'react';\nimport * as render from 'dom-serializer';\nimport * as he from 'he';\nimport { Parser as ToReactParser, ProcessNodeDefinitions, Node, Instruction } from 'html-to-react';\nimport * as Kefir from 'kefir';\n\nimport { ConfigHolder } from 'platform/api/services/config-holder';\nimport * as SecurityService from 'platform/api/services/security';\nimport { TemplateParser, TemplateScope } from 'platform/api/services/template';\nimport { ComponentProps } from 'platform/api/components';\nimport { WrappingError } from 'platform/api/async';\n\nimport { Reparentable } from 'platform/components/utils/Reparentable';\n\nimport { hasComponent, loadComponent } from './ComponentsStore';\nimport { safeReactCreateElement } from './ReactErrorCatcher';\n\nconst processNodeDefinitions = new ProcessNodeDefinitions(React);\n\n/**\n * Holds all natively registered custom elements.\n */\nconst NativeRegistry = Set<string>().asMutable();\n\n/*\n * Intercept calls to customElements.define to track all custom components.\n */\nconst registerElement = customElements.define;\ncustomElements.define = function (name: string, constructor: Function, options?: ElementDefinitionOptions) {\n  NativeRegistry.add(name);\n  return registerElement.bind(customElements)(name, constructor, options);\n};\n\n/**\n * Register react component as a web-component.\n *\n * At rendering time html tag instantiated with corresponding react component.\n * Attributes are propagated as props with some transformations:\n *  1) 'data-' prefix is stripped.\n *  2) names are translated to camel-case se. e.g \"data-event-key\" corresponds\n *     to \"eventKey\" property.\n *  3) attribute value is parsed as JSON.\n *\n * Example:\n *  html:\n *    <bs-tab data-event-key=\"1\" data-title=\"Tab 1\">\n *      Some Content\n *    </bs-tab>\n *\n *  react:\n *    Tab({eventKey: '1', title: 'Tab 1'}, 'Some Content')\n */\nexport function init() {\n  /**/\n}\n\n/**\n * When we parse custom component attributes we save raw style attribute into\n * __style variable,\n * because original style is parsed to be in line with react style syntax.\n * But raw style string can be useful when we want to propagate style to DOM element\n * managed outside React. E.g. CytoscapeNavigator component.\n */\nexport const RAW_STYLE_ATTRIBUTE = '__style';\n\n/**\n * Parse HTML string into ReactElements hierarchy.\n * @param  {string} html\n *         Plain html string to be parsed to React.\n * @return {Array} Array of @ReactElement\n */\nexport function parseHtmlToReact(html: string): Promise<ReactElement<any> | ReactElement<any>[]> {\n  const processingInstructions: Instruction[] = [\n    {\n      shouldProcessNode: isCodeExample,\n      processNode: processCode('mp-code-example'),\n    },\n    {\n      shouldProcessNode: isCode,\n      processNode: processCode('mp-code-highlight'),\n    },\n    {\n      shouldProcessNode: isCodeBlock,\n      processNode: processCode('mp-code-block'),\n    },\n    {\n      shouldProcessNode: isCodeChild,\n      processNode: skipNode,\n    },\n    {\n      shouldProcessNode: isStyle,\n      processNode: processStyle,\n    },\n    {\n      shouldProcessNode: isStyleChild,\n      processNode: skipNode,\n    },\n    {\n      shouldProcessNode: isReactComponent,\n      processNode: processReactComponent,\n    },\n    {\n      shouldProcessNode: isNativeComponent,\n      processNode: processNativeComponent,\n    },\n    {\n      shouldProcessNode: (node) => !TemplateParser.isTemplate(node),\n      processNode: processDefaultNode,\n    },\n  ];\n\n  const htmlToReactParser = new ToReactParser(React, { recognizeCDATA: true });\n\n  /*\n   * Because html-to-react expects html with single root node as an input,\n   * we need to wrap html into artificial div node. After parsing it's children\n   * will correspond to initial html.\n   */\n  return htmlToReactParser\n    .parseWithInstructions(`<div key=\"root\">${html}</div>`, isValidNode, processingInstructions)\n    .then((components) => components.props.children);\n}\n\nexport function isWebComponent(componentTag: string) {\n  return hasComponent(componentTag);\n}\n\n/**\n * Creates ReactElement for corresponding html-tag with\n * provided props, children and templateScope\n */\nexport function renderWebComponent(\n  componentTag: string,\n  props: Record<string, any>,\n  children?: ReactNode[],\n  templateScope?: TemplateScope\n): Promise<ReactElement<any>> {\n  // check if user is permitted to use the component\n  // if not it will not be rendered at all\n  templateScope = templateScope ||\n    TemplateScope.create({scopeTrace: {componentTag, componentId: props.id}});\n  return isComponentPermited(componentTag)\n    .toPromise()\n    .then<ReactElement<any>>((result) => {\n      if (!result) {\n        return null;\n      }\n      return loadComponent(componentTag).then((component) =>\n        createElementWithTemplateScope(component, props, children, templateScope)\n      );\n    });\n}\n\nfunction processDefaultNode(\n  node: Node,\n  children: Array<ReactElement<any>>\n): Promise<ReactElement<any> | Array<ReactElement<any>>> {\n  return Promise.resolve(processNodeDefinitions.processDefaultNode(node, children));\n}\n\nfunction isCode(node: Node): boolean {\n  return node.name === 'code';\n}\n\nfunction isCodeExample(node: Node): boolean {\n  return node.name === 'mp-code-example';\n}\n\nfunction isCodeBlock(node: Node): boolean {\n  return node.name === 'mp-code-block';\n}\n\nfunction isCodeChild(node: Node): boolean {\n  return (\n    node.parent &&\n    (node.parent.name === 'code' || node.parent.name === 'mp-code-example' || node.parent.name === 'mp-code-block')\n  );\n}\n\nfunction isStyle(node: Node): boolean {\n  return node.name === 'style';\n}\n\nfunction isStyleChild(node: Node): boolean {\n  return node.parent && node.parent.name === 'style';\n}\n\nfunction isReactComponent(node: Node): boolean {\n  return hasComponent(node.name);\n}\n\nfunction isNativeComponent(node: Node): boolean {\n  // according to specification name of the custom element must contain dash.\n  // see https://developer.mozilla.org/en-US/docs/Web/API/CustomElementRegistry/define\n  return !hasComponent(node.name) && node.type === 'tag' && node.name.indexOf('-') !== -1;\n}\n/**\n * We simply skip (ignore) empty text nodes here in the processing instructions.\n */\nfunction isValidNode(node: Node): boolean {\n  return node.type === 'text' ? _.trim(node.data) !== '' : true;\n}\n\nfunction processNativeComponent(node: Node, children: Array<ReactNode>): Promise<ReactElement<any>> {\n  return Promise.resolve(\n    D.div({\n      dangerouslySetInnerHTML: {\n        __html: render(node),\n      },\n    })\n  );\n}\n\n/**\n * Properly handle children for code visualization components.\n */\nfunction processCode(codeComponent: 'mp-code-example' | 'mp-code-highlight' | 'mp-code-block') {\n  return function (node: Node, children: Array<React.ReactNode>): Promise<React.ReactElement<any>> {\n    const innerCode = _.trim(he.decode(render(node.children)));\n    const attributes = htmlAttributesToReactProps(node.attribs);\n\n    // remove CDATA wrapper if it is present\n    const codeToHighlight = innerCode.replace('<!--[CDATA[', '').replace(']]-->', '');\n\n    return loadComponent(codeComponent).then((component) =>\n      createElement(component, assign({ codeText: codeToHighlight }, attributes))\n    );\n  };\n}\n\nfunction skipNode(node: Node, children: Array<React.ReactNode>): Promise<React.ReactElement<any>> {\n  return null;\n}\n\nfunction processStyle(node: Node, children: Array<React.ReactNode>): Promise<React.ReactElement<any>> {\n  // return for empty style tags i.e. uBlock browser extension may inject these\n  const styleNode = !node.children[0]\n    ? D.style()\n    : D.style({ dangerouslySetInnerHTML: { __html: node.children[0].data } }, null);\n\n  return Promise.resolve(styleNode);\n}\n\nfunction processReactComponent(node: Node, children: Array<ReactNode>): Promise<React.ReactElement<any>> {\n  let attributes;\n  try {\n    attributes = htmlAttributesToReactProps(node.attribs);\n  } catch (e) {\n    const msg = `Error while processing attributes for component \\\"${node.name}\\\":\n      ' + ${e.message}`;\n    throw new Error(msg);\n  }\n\n  // was previously {key: `component-${index}-${level}`},\n  const computedKey =\n    attributes['key'] && !attributes['fixedKey']\n      ? attributes['key']\n      : attributes['fixedKey']\n      ? attributes['fixedKey']\n      : Math.random().toString(36).slice(2);\n\n  // we propagate attributes as-is, but also put them into special config field\n  let props = assign({ key: computedKey }, attributes);\n\n  // handle nested config for semantic components\n  if (_.startsWith(node.name, 'semantic')) {\n    if (!_.isUndefined(props['config'])) {\n      const nestedProps = _.transform(\n        props['config'],\n        (acc: {}, val: string, key: string) => {\n          acc[attributeName(key)] = val;\n          return acc;\n        },\n        {}\n      );\n      props = assign(props, nestedProps);\n    }\n  }\n\n  let templateScope: TemplateScope = undefined;\n  try {\n    templateScope = extractTemplateScope(node);\n  } catch (error) {\n    throw new WrappingError(`Invalid template markup at <${node.name}>`, error);\n  }\n\n  if (attributes['fixedKey'] && attributes['reparentable']) {\n    delete props.key;\n    return renderWebComponent(node.name, props, children, templateScope).then(el => {\n      return React.createElement(\n        Reparentable, {uid: attributes['fixedKey']}, el\n      );\n    });\n  } else {\n    return renderWebComponent(node.name, props, children, templateScope);\n  }\n}\n\n/**\n * Creates a template scope derived from default one and registers\n * local templates from the node.\n */\nexport function extractTemplateScope(node: Node): TemplateScope | undefined {\n  const templates = TemplateParser.extractTemplates(node);\n  if (templates.length === 0) {\n    return undefined;\n  }\n  return templates\n    .reduce((builder, { id, source }) => {\n      try {\n        builder.registerPartial(id, source);\n      } catch (error) {\n        throw new WrappingError(`Failed to register <template id='${id}'>`, error);\n      }\n      return builder;\n    }, TemplateScope.builder())\n    .build();\n}\n\nconst isAlwaysPermitted = Kefir.constant(true);\n\n/**\n * With default platform configuration all component are enabled by default\n * one need to explicitly enable security check for components in ui.prop\n */\nfunction isComponentPermited(componentName: string): Kefir.Property<boolean> {\n  if (ConfigHolder.getUIConfig().enableUiComponentBasedSecurity) {\n    const right = 'ui:component:view:' + componentName.replace(/-/g, ':');\n    return SecurityService.Util.isPermitted(right);\n  } else {\n    return isAlwaysPermitted;\n  }\n}\n\nfunction createElementWithTemplateScope(\n  component: ComponentClass<any>,\n  componentProps: any,\n  children: ReactNode[],\n  templateScope: TemplateScope\n) {\n  let props = componentProps;\n  if (component.propTypes) {\n    const propTypes = component.propTypes as { [K in keyof ComponentProps]: any };\n    if (propTypes.markupTemplateScope) {\n      // provide template context if component accepts it in props\n      const scopeProps: Partial<ComponentProps> = {\n        markupTemplateScope: templateScope,\n      };\n      props = { ...props, ...scopeProps };\n    }\n  }\n  return safeReactCreateElement.apply(null, [component, props].concat(children));\n}\n\n/**\n * Use helper functions from reactive-elements to convert html attributes to react props.\n */\nfunction htmlAttributesToReactProps(attribs: { [key: string]: string }): {} {\n  return _.transform(\n    attribs,\n    (acc: {}, val: string, key: string) => {\n      acc[attributeName(key)] =\n        key === 'style' ? parseReactStyleFromCss(attributeValue(key, val)) : attributeValue(key, val);\n\n      if (key === 'style') {\n        // save raw style attribute\n        acc[RAW_STYLE_ATTRIBUTE] = attributeValue(key, val);\n      }\n      return acc;\n    },\n    {}\n  );\n}\n\nfunction attributeName(name: string): string {\n  if (name === 'class') {\n    return 'className';\n  }\n  if (name === 'data-flex-layout' || name === 'data-flex-self') {\n    // we need to propagate data-layout and data-layout-self as is to support\n    // styling with https://github.com/StefanKovac/flex-layout-attribute\n    return name;\n  } else {\n    return attributeNameToPropertyName(name);\n  }\n}\n\nfunction attributeNameToPropertyName(attributeName: string): string {\n  return attributeName.replace(/^(x|data)[-_:]/i, '').replace(/[-_:](.)/g, (x, chr) => chr.toUpperCase());\n}\n\nfunction attributeValue(name: string, val: string): any {\n  const decoded = he.decode(val);\n\n  // custom handling for boolean attributes.\n  // replace with something more generic, like https://github.com/YousefED/typescript-json-schema\n  if (decoded === 'true' || decoded === 'false') {\n    return JSON.parse(decoded);\n  } else if (decoded !== '' && !isNaN(+decoded)) {\n    // isNaN returns true for empty string, so we need to check for it \n    // custom handling for number attributes\n    return +decoded;\n  } else {\n    return parseAttributeValue(name, decoded);\n  }\n}\n\nfunction parseAttributeValue(name: string, value) {\n  if (!value) {\n    return null;\n  }\n\n  const jsonRegexp = /^{{1}.*}{1}$/,\n    jsonArrayRegexp = /(^\\[.*\\]$)/;\n\n  // remove all kind of line breaks\n  const valueWithoutLineBreaks = value.replace(/(\\r\\n|\\n|\\r|\\t)/gm, '');\n  const jsonMatches = valueWithoutLineBreaks.match(jsonRegexp) || valueWithoutLineBreaks.match(jsonArrayRegexp);\n  const isEnclosedInDoubleCurlyBraces =\n    valueWithoutLineBreaks.startsWith('{{') && valueWithoutLineBreaks.endsWith('}}');\n\n  if (jsonMatches && !isEnclosedInDoubleCurlyBraces) {\n    try {\n      value = JSON.parse(jsonMatches[0]);\n    } catch (e) {\n      const msg = `Failed to parse value for attribute \\\"${name}\\\" as JSON.\n                      Details: ${e.message}`;\n      throw new Error(msg);\n    }\n  }\n\n  return value;\n}\n\nexport function parseReactStyleFromCss(cssStyle: string | undefined | null): CSSProperties {\n  if (!cssStyle) {\n    return {};\n  }\n  const styles = cssStyle.split(';');\n  const jsonStyles: CSSProperties = {};\n  for (const styleEntry of styles) {\n    const separatorIndex = styleEntry.indexOf(':');\n    if (separatorIndex <= 0 || separatorIndex === styleEntry.length - 1) {\n      continue;\n    }\n    const key = _.camelCase(styleEntry.substring(0, separatorIndex));\n    const value = styleEntry.substring(separatorIndex + 1);\n    jsonStyles[key] = value;\n  }\n  return jsonStyles;\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { serializerFor, deserializerFor } from '../JsonCore';\nimport * as maybe from 'data.maybe';\n\n/**\n * Serializers and deserializers for data.maybe.\n */\nexport function registerSerializersAndDeserializers() {\n  serializerFor({\n    name: 'Data.Maybe',\n    predicate: function (obj) {\n      return obj instanceof maybe;\n    },\n    serializer: function (obj: Data.Maybe<any>) {\n      if (obj.isNothing) {\n        return {};\n      } else {\n        return {\n          value: obj.get(),\n        };\n      }\n    },\n  });\n  deserializerFor({\n    name: 'Data.Maybe',\n    deserializer: function (object: any) {\n      if (object.value) {\n        return maybe.Just(object.value);\n      } else {\n        return maybe.Nothing();\n      }\n    },\n  });\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as moment from 'moment';\n\nimport { serializerFor, deserializerFor } from '../JsonCore';\n\n/**\n * Serializers and deserializers for moment.js.\n */\nexport function registerSerializersAndDeserializers() {\n  serializerFor({\n    name: 'Moment',\n    predicate: function (obj) {\n      return moment.isMoment(obj);\n    },\n    serializer: function (obj: moment.Moment) {\n      return obj.toISOString();\n    },\n  });\n  deserializerFor({\n    name: 'Moment',\n    deserializer: function (object: any) {\n      return moment(object, moment.ISO_8601);\n    },\n  });\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as Rdf from '../core/Rdf';\n\nmodule rdfs {\n  export var _NAMESPACE = 'http://www.w3.org/2000/01/rdf-schema#';\n  export const iri = (s: string) => Rdf.iri(_NAMESPACE + s);\n\n  export const label = iri('label');\n  export const domain = iri('domain');\n  export const range = iri('range');\n  export const comment = iri('comment');\n  export const subClassOf = iri('subClassOf');\n\n  export const Resource = iri('Resource');\n}\n\nexport default rdfs;\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport RDF = require('../core/Rdf');\n\nmodule dc {\n  export var _NAMESPACE = 'http://purl.org/dc/elements/1.1/';\n\n  export var contributor = RDF.iri(_NAMESPACE + 'contributor');\n  export var coverage = RDF.iri(_NAMESPACE + 'coverage');\n  export var creator = RDF.iri(_NAMESPACE + 'creator');\n  export var date = RDF.iri(_NAMESPACE + 'date');\n  export var description = RDF.iri(_NAMESPACE + 'description');\n  export var format = RDF.iri(_NAMESPACE + 'format');\n  export var identifier = RDF.iri(_NAMESPACE + 'identifier');\n  export var language = RDF.iri(_NAMESPACE + 'language');\n  export var publisher = RDF.iri(_NAMESPACE + 'publisher');\n  export var relation = RDF.iri(_NAMESPACE + 'relation');\n  export var rights = RDF.iri(_NAMESPACE + 'rights');\n  export var source = RDF.iri(_NAMESPACE + 'source');\n  export var subject = RDF.iri(_NAMESPACE + 'subject');\n  export var title = RDF.iri(_NAMESPACE + 'title');\n  export var type = RDF.iri(_NAMESPACE + 'type');\n}\n\nexport default dc;\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as Rdf from '../core/Rdf';\n\n/**\n * DCMI Metadata Terms\n */\nmodule dct {\n  export const NAMESPACE = 'http://purl.org/dc/terms/';\n  export const iri = (s: string) => Rdf.iri(NAMESPACE + s);\n\n  export const subject = iri('subject');\n}\n\nexport default dct;\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport RDF = require('../core/Rdf');\n\nmodule sp {\n  export var _NAMESPACE = 'http://spinrdf.org/sp#';\n\n  export var Query = RDF.iri(_NAMESPACE + 'Query');\n  export const Ask = RDF.iri(_NAMESPACE + 'Ask');\n  export const Select = RDF.iri(_NAMESPACE + 'Select');\n  export const Describe = RDF.iri(_NAMESPACE + 'Describe');\n  export const Construct = RDF.iri(_NAMESPACE + 'Construct');\n  export const Update = RDF.iri(_NAMESPACE + 'Update');\n\n  export var text = RDF.iri(_NAMESPACE + 'text');\n}\n\nexport default sp;\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport RDF = require('../core/Rdf');\n\nmodule spl {\n  export const _NAMESPACE = 'http://spinrdf.org/spl#';\n\n  export const optionalProp = RDF.iri(_NAMESPACE + 'optional');\n  export const predicateProp = RDF.iri(_NAMESPACE + 'predicate');\n  export const valueTypeProp = RDF.iri(_NAMESPACE + 'valueType');\n  export const defaultValue = RDF.iri(_NAMESPACE + 'defaultValue');\n  export const Argument = RDF.iri(_NAMESPACE + 'Argument');\n}\n\nexport default spl;\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport RDF = require('../core/Rdf');\n\nmodule spin {\n  export var _NAMESPACE = 'http://spinrdf.org/spin#';\n\n  export const Template = RDF.iri(_NAMESPACE + 'Template');\n  export const SelectTemplate = RDF.iri(_NAMESPACE + 'SelectTemplate');\n  export const ConstructTemplate = RDF.iri(_NAMESPACE + 'ConstructTemplate');\n  export const AskTemplate = RDF.iri(_NAMESPACE + 'AskTemplate');\n  export const UpdateTemplate = RDF.iri(_NAMESPACE + 'UpdateTemplate');\n  export const constraintProp = RDF.iri(_NAMESPACE + 'constraint');\n  export const bodyProp = RDF.iri(_NAMESPACE + 'body');\n\n  export var text = RDF.iri(_NAMESPACE + 'text');\n}\n\nexport default spin;\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as Rdf from '../core/Rdf';\n\nmodule ldp {\n  export const _NAMESPACE = 'http://www.w3.org/ns/ldp#';\n  export const iri = (s: string) => Rdf.iri(_NAMESPACE + s);\n\n  export const Ascending = iri('Ascending');\n  export const BasicContainer = iri('BasicContainer');\n  export const constrainedBy = iri('constrainedBy');\n  export const Container = iri('Container');\n  export const contains = iri('contains');\n  export const Descending = iri('Descending');\n  export const DirectContainer = iri('DirectContainer');\n  export const hasMemberRelation = iri('hasMemberRelation');\n  export const IndirectContainer = iri('IndirectContainer');\n  export const insertedContentRelation = iri('insertedContentRelation');\n  export const isMemberOfRelation = iri('isMemberOfRelation');\n  export const member = iri('member');\n  export const membershipResource = iri('membershipResource');\n  export const MemberSubject = iri('MemberSubject');\n  export const NonRDFSource = iri('NonRDFSource');\n  export const Page = iri('Page');\n  export const pageSequence = iri('pageSequence');\n  export const pageSortCollation = iri('pageSortCollation');\n  export const pageSortCriteria = iri('pageSortCriteria');\n  export const PageSortCriterion = iri('PageSortCriterion');\n  export const pageSortOrder = iri('pageSortOrder');\n  export const pageSortPredicate = iri('pageSortPredicate');\n  export const PreferContainment = iri('PreferContainment');\n  export const PreferEmptyContainer = iri('PreferEmptyContainer');\n  export const PreferMembership = iri('PreferMembership');\n  export const PreferMinimalContainer = iri('PreferMinimalContainer');\n  export const RDFSource = iri('RDFSource');\n  export const Resource = iri('Resource');\n}\n\nexport default ldp;\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport Rdf = require('../core/Rdf');\n\nmodule oa {\n  export const _NAMESPACE = 'http://www.w3.org/ns/oa#';\n\n  export const Annotation = Rdf.iri(_NAMESPACE + 'Annotation');\n  export const SpecificResource = Rdf.iri(_NAMESPACE + 'SpecificResource');\n  export const TextualBody = Rdf.iri(_NAMESPACE + 'TextualBody');\n  export const RangeSelector = Rdf.iri(_NAMESPACE + 'RangeSelector');\n  export const XPathSelector = Rdf.iri(_NAMESPACE + 'XPathSelector');\n  export const TextPositionSelector = Rdf.iri(_NAMESPACE + 'TextPositionSelector');\n\n  export const end = Rdf.iri(_NAMESPACE + 'end');\n  export const hasBody = Rdf.iri(_NAMESPACE + 'hasBody');\n  export const hasEndSelector = Rdf.iri(_NAMESPACE + 'hasEndSelector');\n  export const hasRole = Rdf.iri(_NAMESPACE + 'hasRole');\n  export const hasSelector = Rdf.iri(_NAMESPACE + 'hasSelector');\n  export const hasSource = Rdf.iri(_NAMESPACE + 'hasSource');\n  export const hasStartSelector = Rdf.iri(_NAMESPACE + 'hasStartSelector');\n  export const hasTarget = Rdf.iri(_NAMESPACE + 'hasTarget');\n  export const refinedBy = Rdf.iri(_NAMESPACE + 'refinedBy');\n  export const start = Rdf.iri(_NAMESPACE + 'start');\n  export const text = Rdf.iri(_NAMESPACE + 'text');\n}\n\nexport default oa;\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as Rdf from '../core/Rdf';\n\nmodule field {\n  const NAMESPACE = 'http://www.researchspace.org/resource/system/fields/';\n  const iri = (s: string) => Rdf.iri(NAMESPACE + s);\n\n  /**  TYPES **/\n  export const Field = iri('Field');\n\n  /**  PROPERTIES **/\n  export const insert_pattern = iri('insertPattern');\n  export const select_pattern = iri('selectPattern');\n  export const delete_pattern = iri('deletePattern');\n  export const ask_pattern = iri('askPattern');\n  export const category = iri('category');\n  export const domain = iri('domain');\n  export const xsd_datatype = iri('xsdDatatype');\n  export const range = iri('range');\n  export const min_occurs = iri('minOccurs');\n  export const max_occurs = iri('maxOccurs');\n  export const order = iri('order');\n  export const default_value = iri('defaultValue');\n  export const valueset_pattern = iri('valueSetPattern');\n  export const autosuggestion_pattern = iri('autosuggestionPattern');\n  export const tree_patterns = iri('treePatterns');\n  export const testsubject = iri('testSubject');\n}\n\nexport default field;\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as Rdf from '../core/Rdf';\n\nmodule prov {\n  export const _NAMESPACE = 'http://www.w3.org/ns/prov#';\n  export const iri = (s: string) => Rdf.iri(_NAMESPACE + s);\n\n  export const actedOnBehalfOf = iri('actedOnBehalfOf');\n  export const Activity = iri('Activity');\n  export const activity = iri('activity');\n  export const ActivityInfluence = iri('ActivityInfluence');\n  export const agent = iri('agent');\n  export const Agent = iri('Agent');\n  export const AgentInfluence = iri('AgentInfluence');\n  export const alternateOf = iri('alternateOf');\n  export const aq = iri('aq');\n  export const Association = iri('Association');\n  export const atLocation = iri('atLocation');\n  export const atTime = iri('atTime');\n  export const Attribution = iri('Attribution');\n  export const Bundle = iri('Bundle');\n  export const category = iri('category');\n  export const Collection = iri('Collection');\n  export const Communication = iri('Communication');\n  export const component = iri('component');\n  export const constraints = iri('constraints');\n  export const definition = iri('definition');\n  export const Delegation = iri('Delegation');\n  export const Derivation = iri('Derivation');\n  export const dm = iri('dm');\n  export const editorialNote = iri('editorialNote');\n  export const editorsDefinition = iri('editorsDefinition');\n  export const EmptyCollection = iri('EmptyCollection');\n  export const End = iri('End');\n  export const endedAtTime = iri('endedAtTime');\n  export const Entity = iri('Entity');\n  export const entity = iri('entity');\n  export const EntityInfluence = iri('EntityInfluence');\n  export const generated = iri('generated');\n  export const generatedAtTime = iri('generatedAtTime');\n  export const Generation = iri('Generation');\n  export const hadActivity = iri('hadActivity');\n  export const hadGeneration = iri('hadGeneration');\n  export const hadMember = iri('hadMember');\n  export const hadPlan = iri('hadPlan');\n  export const hadPrimarySource = iri('hadPrimarySource');\n  export const hadRole = iri('hadRole');\n  export const hadUsage = iri('hadUsage');\n  export const Influence = iri('Influence');\n  export const influenced = iri('influenced');\n  export const influencer = iri('influencer');\n  export const InstantaneousEvent = iri('InstantaneousEvent');\n  export const invalidated = iri('invalidated');\n  export const invalidatedAtTime = iri('invalidatedAtTime');\n  export const Invalidation = iri('Invalidation');\n  export const inverse = iri('inverse');\n  export const Location = iri('Location');\n  export const n = iri('n');\n  export const order = iri('order');\n  export const Organization = iri('Organization');\n  export const Person = iri('Person');\n  export const Plan = iri('Plan');\n  export const PrimarySource = iri('PrimarySource');\n  export const qualifiedAssociation = iri('qualifiedAssociation');\n  export const qualifiedAttribution = iri('qualifiedAttribution');\n  export const qualifiedCommunication = iri('qualifiedCommunication');\n  export const qualifiedDelegation = iri('qualifiedDelegation');\n  export const qualifiedDerivation = iri('qualifiedDerivation');\n  export const qualifiedEnd = iri('qualifiedEnd');\n  export const qualifiedForm = iri('qualifiedForm');\n  export const qualifiedGeneration = iri('qualifiedGeneration');\n  export const qualifiedInfluence = iri('qualifiedInfluence');\n  export const qualifiedInvalidation = iri('qualifiedInvalidation');\n  export const qualifiedPrimarySource = iri('qualifiedPrimarySource');\n  export const qualifiedQuotation = iri('qualifiedQuotation');\n  export const qualifiedRevision = iri('qualifiedRevision');\n  export const qualifiedStart = iri('qualifiedStart');\n  export const qualifiedUsage = iri('qualifiedUsage');\n  export const Quotation = iri('Quotation');\n  export const Revision = iri('Revision');\n  export const Role = iri('Role');\n  export const sharesDefinitionWith = iri('sharesDefinitionWith');\n  export const SoftwareAgent = iri('SoftwareAgent');\n  export const specializationOf = iri('specializationOf');\n  export const Start = iri('Start');\n  export const startedAtTime = iri('startedAtTime');\n  export const todo = iri('todo');\n  export const unqualifiedForm = iri('unqualifiedForm');\n  export const Usage = iri('Usage');\n  export const used = iri('used');\n  export const value = iri('value');\n  export const wasAssociatedWith = iri('wasAssociatedWith');\n  export const wasAttributedTo = iri('wasAttributedTo');\n  export const wasDerivedFrom = iri('wasDerivedFrom');\n  export const wasEndedBy = iri('wasEndedBy');\n  export const wasGeneratedBy = iri('wasGeneratedBy');\n  export const wasInfluencedBy = iri('wasInfluencedBy');\n  export const wasInformedBy = iri('wasInformedBy');\n  export const wasInvalidatedBy = iri('wasInvalidatedBy');\n  export const wasQuotedFrom = iri('wasQuotedFrom');\n  export const wasRevisionOf = iri('wasRevisionOf');\n  export const wasStartedBy = iri('wasStartedBy');\n}\n\nexport default prov;\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as Rdf from '../core/Rdf';\n\nnamespace persist {\n  export const NAMESPACE = 'http://www.researchspace.org/ontologies/persist/';\n\n  export const COMPONENT_TYPE_PREFIX = NAMESPACE + 'components/';\n  export const PersistedComponent = Rdf.iri(NAMESPACE + 'PersistedComponent');\n\n  export const componentType = Rdf.iri(NAMESPACE + 'componentType');\n  export const componentProps = Rdf.iri(NAMESPACE + 'componentProps');\n  export const componentChildren = Rdf.iri(NAMESPACE + 'componentChildren');\n  export const componentContext = Rdf.iri(NAMESPACE + 'componentContext');\n\n  export const JsonNull = Rdf.iri(NAMESPACE + 'json/null');\n  export const JsonUndefined = Rdf.iri(NAMESPACE + 'json/undefined');\n}\n\nexport default persist;\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as RDF from '../core/Rdf';\n\nmodule platform {\n  export const _NAMESPACE = 'http://www.researchspace.org/resource/system/';\n\n  export const SyntheticJsonDatatype = RDF.iri(_NAMESPACE + 'syntheticJson');\n\n  // LDP\n  export const UserSetContainer = RDF.iri(_NAMESPACE + 'userSetContainer');\n  export const SetContainer = RDF.iri(_NAMESPACE + 'setContainer');\n  export const VisibilityContainer = RDF.iri(_NAMESPACE + 'visibilityContainer');\n  export const FieldDefinitionContainer = RDF.iri(_NAMESPACE + 'fieldDefinitionContainer');\n  export const FormContainer = RDF.iri(_NAMESPACE + 'formContainer');\n  export const OntodiaDiagramContainer = RDF.iri(_NAMESPACE + 'ontodiaDiagramContainer');\n  export const QueryContainer = RDF.iri(_NAMESPACE + 'queryContainer');\n  export const QueryTemplateContainer = RDF.iri(_NAMESPACE + 'queryTemplateContainer');\n  export const PersistedComponentContainer = RDF.iri(_NAMESPACE + 'persistedComponentContainer');\n  export const WorkflowContainer = RDF.iri(_NAMESPACE + 'workflowContainer');\n  export const WorkflowDefinitionContainer = RDF.iri(_NAMESPACE + 'workflowDefinitionContainer');\n\n  export const Set = RDF.iri(_NAMESPACE + 'Set');\n  export const SetItem = RDF.iri(_NAMESPACE + 'SetItem');\n\n  // SET Container can have set-container of resources\n  export const containerType = RDF.iri(_NAMESPACE + 'containerType');\n  export const setItem = RDF.iri(_NAMESPACE + 'setItem');\n  export const setItemIndex = RDF.iri(_NAMESPACE + 'setItemIndex');\n  export const clipboardItem = RDF.iri(_NAMESPACE + 'clipboardItem');\n  export const visibilityItem = RDF.iri(_NAMESPACE + 'visibilityItem');\n\n  /**\n   * Specifies visibility of the resource.\n   * Possible values are publicVisibility, privateVisibility, sharedVisibility and groupVisibility\n   * from bellow.\n   */\n  export const visibility = RDF.iri(_NAMESPACE + 'visibility');\n\n  /**\n   * Resource can be visible to everyone, including anonymous user.\n   */\n  export const publicVisibility = RDF.iri(_NAMESPACE + 'visibilityPublic');\n\n  /**\n   * Resource can be visible only to the original author.\n   */\n  export const privateVisibility = RDF.iri(_NAMESPACE + 'visibilityPrivate');\n\n  /**\n   * Resource can be visible to any logged-in user.\n   */\n  export const sharedVisibility = RDF.iri(_NAMESPACE + 'visibilityShared');\n\n  /**\n   * Resource can be visible to any groups specified with visibleToGroups predicate.\n   */\n  export const groupVisibility = RDF.iri(_NAMESPACE + 'visibilityGroup');\n\n  /**\n   * Specifies groups that resource is visible to in case of groupVisibility.\n   */\n  export const visibleToGroups = RDF.iri(_NAMESPACE + 'visibleToGroups');\n\n  // property which points to UI state for the saved query\n  export const searchState = RDF.iri(_NAMESPACE + 'searchState');\n  export const searchResultCategory = RDF.iri(_NAMESPACE + 'searchResultCategory');\n\n  /** Resource type for an uplodaded file. */\n  export const File = RDF.iri(_NAMESPACE + 'File');\n  export const fileName = RDF.iri(_NAMESPACE + 'fileName');\n  export const mediaType = RDF.iri(_NAMESPACE + 'mediaType');\n  export const fileContext = RDF.iri(_NAMESPACE + 'fileContext');\n}\n\nexport default platform;\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as Rdf from '../core/Rdf';\n\nmodule workflow {\n  const NAMESPACE = 'http://www.researchspace.org/resource/system/workflow#';\n  const iri = (s: string) => Rdf.iri(NAMESPACE + s);\n\n  /**  TYPES **/\n  export const WorkflowInstantiation = iri('WorkflowInstantiation');\n  export const WorkflowDefinition = iri('WorkflowDefinition');\n  export const WorkflowState = iri('WorkflowState');\n\n  /**  PROPERTIES **/\n  export const hasState = iri('hasState');\n  export const currentState = iri('currentState');\n  export const step = iri('step');\n  export const assignee = iri('assignee');\n  export const startTime = iri('startTime');\n  export const endTime = iri('endTime');\n  export const advancedBy = iri('advancedBy');\n  export const metadata = iri('metadata');\n  export const hasStep = iri('hasStep');\n  export const nextStep = iri('nextStep');\n  export const assigneeQuery = iri('assigneeQuery');\n  export const subject = iri('subject');\n}\n\nexport default workflow;\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as _ from 'lodash';\n\nimport * as Rdf from '../core/Rdf';\nimport { rdf, xsd, persist } from 'platform/api/rdf/vocabularies';\n\nconst { JsonUndefined, JsonNull } = persist;\n\nexport function propertyKeyToIriDefault(keyOrIndex: string | number, propertyNamespace: Rdf.Iri): Rdf.Iri {\n  const encodedKey = typeof keyOrIndex === 'number' ? `_item/${keyOrIndex}` : encodeURIComponent(keyOrIndex);\n  return Rdf.iri(`${propertyNamespace.value}/${encodedKey}`);\n}\n\nexport function iriToPropertyKeyDefault(iri: Rdf.Iri): string {\n  const encodedKey = iri.value.substr(iri.value.lastIndexOf('/') + 1);\n  return decodeURIComponent(encodedKey);\n}\n\n/**\n * Converts JSON-like Javascript object into Rdf.PointedGraph similar to AST of JSON.\n *\n * Arrays are represented as RDF lists:\n * ```\n *   [] -> rdf:nil\n *   [x:xs] -> root rdf:first x ; rdf:rest xs .\n * ```\n *\n * Plain objects are represented by IRIs `<[propertyNamespace] / [path from root] / [key name]>`\n * ```\n *   {\"foo\": bar} -> root <[propertyNamespace]/foo> bar .\n *   [{\"foo\": bar}] -> root\n *     rdf:first [ <[propertyNamespace]/_item/0/foo> bar ] ;\n *     rdf:rest rdf:nil .\n * ```\n *\n * `string`, `boolean` values are represented by literals with corresponding XSD datatype\n * (e.g. numbers by `xsd:double`, `xsd:integer`, etc).\n *\n * `null` value is represented by `persistedComponent:json/null`;\n * `undefined` value is represented by `persistedComponent:json/undefined`.\n *\n * Non-plain objects and functions are treated as if they're undefined.\n * Extra (non-index) array keys and object entries with `undefined` values are discarded.\n */\nexport function serialize(\n  value: any,\n  propertyNamespace: Rdf.Iri,\n  propertyKeyToIri = propertyKeyToIriDefault\n): Rdf.PointedGraph {\n  if (typeof value === undefined) {\n    return Rdf.pg(JsonUndefined, Rdf.EMPTY_GRAPH);\n  } else if (value === null) {\n    return Rdf.pg(JsonNull, Rdf.EMPTY_GRAPH);\n  } else if (typeof value === 'string') {\n    return Rdf.pg(Rdf.literal(value, xsd._string), Rdf.EMPTY_GRAPH);\n  } else if (typeof value === 'boolean') {\n    return Rdf.pg(Rdf.literal(value, xsd.boolean), Rdf.EMPTY_GRAPH);\n  } else if (typeof value === 'number') {\n    if (Math.round(value) === value) {\n      return Rdf.pg(Rdf.literal(value.toString(), xsd.integer), Rdf.EMPTY_GRAPH);\n    } else {\n      return Rdf.pg(Rdf.literal(value.toString(), xsd.double), Rdf.EMPTY_GRAPH);\n    }\n  } else if (Array.isArray(value)) {\n    return serializeArray(value, (item, index) => serialize(item, propertyKeyToIri(index, propertyNamespace)));\n  } else if (_.isPlainObject(value)) {\n    const root = Rdf.bnode();\n    const result: Rdf.Triple[] = [];\n    for (const key in value) {\n      if (!value.hasOwnProperty(key)) {\n        continue;\n      }\n      const nestedNamespace = propertyKeyToIri(key, propertyNamespace);\n      const { graph, pointer } = serialize(value[key], nestedNamespace, propertyKeyToIri);\n      // ignore undefined values in objects\n      if (!pointer.equals(JsonUndefined)) {\n        result.push(...graph.triples.toArray());\n        result.push(Rdf.triple(root, nestedNamespace, pointer));\n      }\n    }\n    return Rdf.pg(root, Rdf.graph(result));\n  } else {\n    // return JsonUndefined for functions and non-plain objects\n    return Rdf.pg(JsonUndefined, Rdf.EMPTY_GRAPH);\n  }\n}\n\nexport function serializeArray<T>(array: T[], mapper: (item: T, index: number) => Rdf.PointedGraph): Rdf.PointedGraph {\n  if (array.length === 0) {\n    return Rdf.pg(rdf.nil, Rdf.EMPTY_GRAPH);\n  }\n\n  let rest: Rdf.Node = rdf.nil;\n  let triples: Rdf.Triple[] = [];\n\n  for (let i = array.length - 1; i >= 0; i--) {\n    const node = Rdf.bnode();\n    const { pointer, graph } = mapper(array[i], i);\n    triples.push(Rdf.triple(node, rdf.first, pointer));\n    triples.push(Rdf.triple(node, rdf.rest, rest));\n    graph.triples.forEach((triple) => triples.push(triple));\n    rest = node;\n  }\n\n  return Rdf.pg(rest, Rdf.graph(triples));\n}\n\nfunction deserializeObjectHelper(root: Rdf.Node, graph: Rdf.Graph, iriToPropertyKey: (iri: Rdf.Iri) => string): object {\n  const isArray = graph.triples.some((t) => t.s.equals(root) && t.p.equals(rdf.first));\n  if (isArray) {\n    return deserializeArray(root, graph, (pointer) => deserialize(pointer, graph, iriToPropertyKey));\n  } else {\n    const result: { [key: string]: any } = {};\n    const outgoing = graph.triples.filter((t) => t.s.equals(root));\n    outgoing.forEach((t) => {\n      const key = iriToPropertyKey(t.p);\n      if (key) {\n        result[key] = deserialize(t.o, graph, iriToPropertyKey);\n      }\n    });\n    return result;\n  }\n}\n\n/**\n * Converts Rdf.PointedGraph generated by `serialize()` back to JSON-like object.\n */\nexport function deserialize(root: Rdf.Node, graph: Rdf.Graph, iriToPropertyKey = iriToPropertyKeyDefault): any {\n  return root.cata<any>(\n    (iri) => {\n      if (iri.equals(rdf.nil)) {\n        return [];\n      } else if (iri.equals(JsonUndefined)) {\n        return undefined;\n      } else if (iri.equals(JsonNull)) {\n        return null;\n      } else {\n        return deserializeObjectHelper(iri, graph, iriToPropertyKey);\n      }\n    },\n    (literal) => {\n      if (literal.datatype.equals(xsd._string)) {\n        return literal.value;\n      } else if (literal.datatype.equals(xsd.boolean)) {\n        return literal.value === 'true';\n      } else if (literal.datatype.equals(xsd.double)) {\n        return parseFloat(literal.value);\n      } else if (literal.datatype.equals(xsd.integer)) {\n        return parseInt(literal.value);\n      }\n    },\n    (bnode) => {\n      return deserializeObjectHelper(bnode, graph, iriToPropertyKey);\n    }\n  );\n}\n\nexport function deserializeArray<T>(root: Rdf.Node, graph: Rdf.Graph, mapper: (pointer: Rdf.Node) => T): T[] {\n  if (root.equals(rdf.nil)) {\n    return [];\n  }\n\n  const { triples } = graph;\n  const items: T[] = [];\n\n  let node = root;\n  while (!node.equals(rdf.nil)) {\n    const first = triples.filter((t) => t.s.equals(node) && t.p.equals(rdf.first)).first();\n    const rest = triples.filter((t) => t.s.equals(node) && t.p.equals(rdf.rest)).first();\n    if (!first) {\n      throw new Error(`Missing rdf:first triple for array ${root} at node ${node}`);\n    }\n    const item = mapper(first.o);\n    items.push(item);\n    node = rest ? rest.o : rdf.nil;\n  }\n\n  return items;\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\n/*\n Based on jsrelaxngvalidator at https://github.com/ndebeiss/jsrelaxngvalidator\n License: Apache License 2.0\n\n @see http://www.w3.org/2001/XMLSchema-datatypes\n\n Extract from <http://www.w3schools.com/Schema/schema_dtypes_date.asp>:\n\n   date        Defines a date value                                      OK\n   dateTime    Defines a date and time value                             OK\n   duration    Defines a time interval                                   OK\n   gDay        Defines a part of a date - the day (DD)                   OK\n   gMonth      Defines a part of a date - the month (MM)                 OK\n   gMonthDay   Defines a part of a date - the month and day (MM-DD)      OK\n   gYear       Defines a part of a date - the year (YYYY)                OK\n   gYearMonth  Defines a part of a date - the year and month (YYYY-MM)   OK\n   time        Defines a time value                                      OK\n\n Extract from <http://www.w3schools.com/Schema/schema_dtypes_numeric.asp>:\n\n   byte                 A signed 8-bit integer                  OK\n   decimal              A decimal value                         OK\n   int                  A signed 32-bit integer                 OK\n   integer              An integer value                        OK\n   long                 A signed 64-bit integer                 OK\n   negativeInteger      An integer containing only negative values ( .., -2, -1.)       OK\n   nonNegativeInteger   An integer containing only non-negative values (0, 1, 2, ..)    OK\n   nonPositiveInteger   An integer containing only non-positive values (.., -2, -1, 0)  OK\n   positiveInteger      An integer containing only positive values (1, 2, ..)           OK\n   short                A signed 16-bit integer                 OK\n   unsignedLong         An unsigned 64-bit integer              OK\n   unsignedInt          An unsigned 32-bit integer              OK\n   unsignedShort        An unsigned 16-bit integer              OK\n   unsignedByte         An unsigned 8-bit integer               OK\n\n Extract from <http://www.w3schools.com/Schema/schema_dtypes_misc.asp>:\n\n   anyURI         does not do any validation\n   base64Binary   OK\n   boolean        OK\n   double         OK\n   float          same as double\n   hexBinary      OK\n\n Extract from <http://www.w3schools.com/Schema/schema_elements_ref.asp>:\n\n   enumeration      Defines a list of acceptable values\n   fractionDigits   Specifies the maximum number of decimal places allowed. Must be equal to or greater than zero             OK\n   length           Specifies the exact number of characters or list items allowed. Must be equal to or greater than zero     OK but not for list and only length of string\n   maxExclusive     Specifies the upper bounds for numeric values (the value must be less than this value)                    OK\n   maxInclusive     Specifies the upper bounds for numeric values (the value must be less than or equal to this value)        OK\n   maxLength        Specifies the maximum number of characters or list items allowed. Must be equal to or greater than zero   OK\n   minExclusive     Specifies the lower bounds for numeric values (the value must be greater than this value)                 OK\n   minInclusive     Specifies the lower bounds for numeric values (the value must be greater than or equal to this value)     OK\n   minLength        Specifies the minimum number of characters or list items allowed. Must be equal to or greater than zero   OK\n   pattern          Defines the exact sequence of characters that are acceptable                                              OK\n   totalDigits      Specifies the exact number of digits allowed. Must be greater than zero                                   OK\n   whiteSpace       Specifies how white space (line feeds, tabs, spaces, and carriage returns) is handled                     KO\n*/\n\nimport * as Rdf from './Rdf';\nimport rdf from '../vocabularies/rdf';\nimport xsd from '../vocabularies/xsd';\n\nconst languageRegExp = new RegExp('^[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*$');\n\nconst whitespaceChar = '\\t\\n\\r';\nconst normalizedStringRegExp = new RegExp('^[^' + whitespaceChar + ']*$');\nconst tokenRegExp = new RegExp(\n  '^([^' + whitespaceChar + ' ](?!.*  )([^' + whitespaceChar + ']*[^' + whitespaceChar + ' ])?)?$'\n);\n\nconst year = '-?([1-9][0-9]*)?[0-9]{4}';\nconst month = '[0-9]{2}';\nconst dayOfMonth = '[0-9]{2}';\nconst time = '[0-9]{2}:[0-9]{2}:[0-9]{2}(\\\\.[0-9]*)?';\nconst timeZone = '(Z|[-+][0-9][0-9]:[0-5][0-9])?';\n\nconst dateRegExp = new RegExp('^' + year + '-' + month + '-' + dayOfMonth + timeZone + '$');\nconst dateTimeRegExp = new RegExp('^' + year + '-' + month + '-' + dayOfMonth + 'T' + time + timeZone + '$');\nconst durationRegExp = new RegExp(\n  '^' + '-?P(?!$)([0-9]+Y)?([0-9]+M)?([0-9]+D)?(T(?!$)([0-9]+H)?([0-9]+M)?([0-9]+(\\\\.[0-9]+)?S)?)?$'\n);\nconst gDayRegExp = new RegExp('^' + '---' + dayOfMonth + timeZone + '$');\nconst gMonthRegExp = new RegExp('^' + '--' + month + timeZone + '$');\nconst gMonthDayRegExp = new RegExp('^' + '--' + month + '-' + dayOfMonth + timeZone + '$');\nconst gYearRegExp = new RegExp('^' + year + timeZone + '$');\nconst gYearMonthRegExp = new RegExp('^' + year + '-' + month + timeZone + '$');\nconst timeRegExp = new RegExp('^' + time + timeZone + '$');\n\nconst LONG_MAX = 9223372036854775807;\nconst LONG_MIN = -9223372036854775808;\nconst INT_MAX = 2147483647;\nconst INT_MIN = -2147483648;\nconst SHORT_MAX = 32767;\nconst SHORT_MIN = -32768;\nconst BYTE_MAX = 127;\nconst BYTE_MIN = -128;\n\nconst UNSIGNED_LONG_MAX = 18446744073709551615;\nconst UNSIGNED_INT_MAX = 4294967295;\nconst UNSIGNED_SHORT_MAX = 65535;\nconst UNSIGNED_BYTE_MAX = 255;\n\nconst integer = '[-+]?[0-9]+';\nconst integerRegExp = new RegExp('^' + integer + '$');\nconst decimal = '[-+]?(?!$)[0-9]*(\\\\.[0-9]*)?';\nconst decimalRegExp = new RegExp('^' + decimal + '$');\n\n/*\n  Base64Binary  ::=\n    ((B64S B64S B64S B64S)*\n    ((B64S B64S B64S B64) |\n     (B64S B64S B16S '=') |\n     (B64S B04S '=' #x20? '=')))?\n\n B64S  ::=  B64 #x20?\n B16S  ::=  B16 #x20?\n B04S  ::=  B04 #x20?\n\n B04  ::=  [AQgw]\n B16  ::=  [AEIMQUYcgkosw048]\n B64  ::=  [A-Za-z0-9+/]\n*/\nconst b64 = '[A-Za-z0-9+/]';\nconst b16 = '[AEIMQUYcgkosw048]';\nconst b04 = '[AQgw]';\nconst b04S = '(' + b04 + ' ?)';\nconst b16S = '(' + b16 + ' ?)';\nconst b64S = '(' + b64 + ' ?)';\n\nconst base64BinaryRegExp = new RegExp(\n  '^((' + b64S + '{4})*((' + b64S + '{3}' + b64 + ')|(' + b64S + '{2}' + b16S + '=)|(' + b64S + b04S + '= ?=)))?$'\n);\nconst booleanRegExp = new RegExp('(^true$)|(^false$)|(^0$)|(^1$)', 'i');\nconst doubleRegExp = new RegExp('(^-?INF$)|(^NaN$)|(^' + decimal + '([Ee]' + integer + ')?$)');\nconst hexBinaryRegExp = new RegExp('^' + '[0-9a-fA-F]*' + '$');\nconst fractionDigits = '\\\\.[0-9]';\n\n// URI regex — reference: http://ftp.davidashen.net/PreTI/RNV/rnv-1.7.8.zip/xsd.c:298\nconst URI_PATTERN =\n  \"^(([a-zA-Z][0-9a-zA-Z+\\\\-.]*:)?/{0,2}[0-9a-zA-Z;/?:@&=+$.\\\\-_!~*'()%]+)?(#[0-9a-zA-Z;/?:@&=+$.\\\\-_!~*'()%]+)?$\";\n\nenum Whitespace {\n  PRESERVE,\n  REPLACE,\n  COLLAPSE,\n}\n\nexport interface Datatype {\n  iri: Rdf.Iri;\n  prefix: string;\n  localName: string;\n}\n\ntype Param =\n  | { whitespace: Whitespace }\n  | { enumeration: string }\n  | { length: string }\n  | { minLength: string }\n  | { maxLength: string }\n  | { minInclusive: string }\n  | { minExclusive: string }\n  | { maxInclusive: string }\n  | { maxExclusive: string }\n  | { totalDigits: string }\n  | { fractionDigits: string }\n  | { pattern: string };\n\nexport interface ValidationResult {\n  success: boolean;\n  message?: string;\n  child?: Datatype | ValidationResult;\n  errorPart?: string;\n}\n\nfunction success(): ValidationResult {\n  return { success: true };\n}\n\nfunction failure(message: string, child: Datatype | ValidationResult, errorPart: string): ValidationResult {\n  return { success: false, message, child, errorPart };\n}\n\nexport function parseXsdDatatype(datatype: Rdf.Iri | string): Datatype {\n  let datatypeIri: Rdf.Iri;\n  if (typeof datatype === 'string') {\n    datatypeIri = Rdf.iri(\n      datatype.replace(/^xsd:(.*)$/, `${xsd._NAMESPACE}$1`).replace(/^rdf:(.*)$/, `${rdf._NAMESPACE}$1`)\n    );\n  } else {\n    datatypeIri = datatype;\n  }\n  const parts = datatypeIri.value.split('#');\n  if (parts.length === 2) {\n    const ns = parts[0] + '#';\n    if (ns === xsd._NAMESPACE || ns === xsd._DATATYPES_NAMESPACE) {\n      return { iri: datatypeIri, prefix: 'xsd', localName: parts[1] };\n    } else if (ns === rdf._NAMESPACE) {\n      return { iri: datatypeIri, prefix: 'rdf', localName: parts[1] };\n    }\n  }\n  return undefined;\n}\n\n/**\n * Replaces XSD datatype aliases with versions from main namespace\n * @see xsd._DATATYPES_NAMESPACE\n */\nexport function replaceDatatypeAliases(datatype: Rdf.Iri): Rdf.Iri {\n  const xsdDatatype = parseXsdDatatype(datatype);\n  return xsdDatatype ? Rdf.iri(xsd._NAMESPACE + xsdDatatype.localName) : datatype;\n}\n\nexport function sameXsdDatatype(datatype1: Rdf.Iri, datatype2: Rdf.Iri): boolean {\n  const type1 = parseXsdDatatype(datatype1);\n  const type2 = parseXsdDatatype(datatype2);\n  if (type1 && type2) {\n    return type1.localName === type2.localName;\n  } else {\n    return datatype1.equals(datatype2);\n  }\n}\n\nexport function datatypeToString(datatype: Rdf.Iri): string {\n  const type = parseXsdDatatype(datatype);\n  return type ? `${type.prefix}:${type.localName}` : datatype.value;\n}\n\nexport function validate(literal: Rdf.Literal, params?: Param[]): ValidationResult {\n  const datatype = parseXsdDatatype(literal.datatype);\n  if (!datatype) {\n    return failure(\n      `Unknown XSD datatype ${datatypeToString(literal.datatype)}`,\n      { iri: literal.datatype, localName: '', prefix: '' },\n      ''\n    );\n  }\n  if (!params) {\n    params = [];\n  }\n  return datatypeAllows(datatype, literal.value, params);\n}\n\nexport function equal(first: Rdf.Literal, second: Rdf.Literal): ValidationResult {\n  const type1 = parseXsdDatatype(first.datatype);\n  const type2 = parseXsdDatatype(second.datatype);\n  if (!type1) {\n    return failure(\n      `Unknown XSD datatype ${datatypeToString(first.datatype)}`,\n      { iri: first.datatype, localName: '', prefix: '' },\n      ''\n    );\n  } else if (!type2) {\n    return failure(\n      `Unknown XSD datatype ${datatypeToString(second.datatype)}`,\n      { iri: first.datatype, localName: '', prefix: '' },\n      ''\n    );\n  } else if (type1.localName !== type2.localName || type1.prefix !== type2.prefix) {\n    return failure(\n      `Datatypes are not equal: ${datatypeToString(first.datatype)} != ` + `${datatypeToString(second.datatype)}`,\n      type1,\n      ''\n    );\n  }\n  return datatypeEqual(type1, first.value, second.value);\n}\n\n/**\n * Performs XSD datatype validation with additional constraints specified in params.\n */\nfunction datatypeAllows(datatype: Datatype, data: string, params: Param[]): ValidationResult {\n  /*\n   * Date and duration checks\n   */\n  if (datatype.localName === 'date') {\n    const value = whitespace(data, Whitespace.COLLAPSE, params);\n    return checkRegExpAndParams(dateRegExp, value, datatype, params);\n  } else if (datatype.localName === 'dateTime') {\n    const value = whitespace(data, Whitespace.COLLAPSE, params);\n    return checkRegExpAndParams(dateTimeRegExp, value, datatype, params);\n  } else if (datatype.localName === 'gDay') {\n    const value = whitespace(data, Whitespace.COLLAPSE, params);\n    return checkRegExpAndParams(gDayRegExp, value, datatype, params);\n  } else if (datatype.localName === 'gMonth') {\n    const value = whitespace(data, Whitespace.COLLAPSE, params);\n    return checkRegExpAndParams(gMonthRegExp, value, datatype, params);\n  } else if (datatype.localName === 'gMonthDay') {\n    const value = whitespace(data, Whitespace.COLLAPSE, params);\n    return checkRegExpAndParams(gMonthDayRegExp, value, datatype, params);\n  } else if (datatype.localName === 'gYear') {\n    const value = whitespace(data, Whitespace.COLLAPSE, params);\n    return checkRegExpAndParams(gYearRegExp, value, datatype, params);\n  } else if (datatype.localName === 'gYearMonth') {\n    const value = whitespace(data, Whitespace.COLLAPSE, params);\n    return checkRegExpAndParams(gYearMonthRegExp, value, datatype, params);\n  } else if (datatype.localName === 'time') {\n    const value = whitespace(data, Whitespace.COLLAPSE, params);\n    return checkRegExpAndParams(timeRegExp, value, datatype, params);\n  } else if (datatype.localName === 'duration') {\n    const value = whitespace(data, Whitespace.COLLAPSE, params);\n    return checkRegExpAndParams(durationRegExp, value, datatype, params);\n    /*\n     * Primitive types\n     */\n  } else if (datatype.localName === 'boolean') {\n    const value = whitespace(data, Whitespace.COLLAPSE, params);\n    return checkRegExpAndParams(booleanRegExp, value, datatype, params);\n  } else if (datatype.localName === 'base64Binary') {\n    const value = whitespace(data, Whitespace.COLLAPSE, params);\n    return checkRegExpAndParams(base64BinaryRegExp, value, datatype, params);\n  } else if (datatype.localName === 'hexBinary') {\n    const value = whitespace(data, Whitespace.COLLAPSE, params);\n    return checkRegExpAndParams(hexBinaryRegExp, value, datatype, params);\n  } else if (datatype.localName === 'float') {\n    const value = whitespace(data, Whitespace.COLLAPSE, params);\n    return checkRegExpAndParams(doubleRegExp, value, datatype, params);\n  } else if (datatype.localName === 'double') {\n    const value = whitespace(data, Whitespace.COLLAPSE, params);\n    return checkRegExpAndParams(doubleRegExp, value, datatype, params);\n  } else if (datatype.localName === 'anyURI') {\n    const value = whitespace(data, Whitespace.COLLAPSE, params);\n    return checkRegExpAndParams(new RegExp(URI_PATTERN), value, datatype, params);\n    /*\n     * Types derived from string\n     */\n  } else if (datatype.localName === 'string' || datatype.localName === 'langString') {\n    const value = whitespace(data, Whitespace.PRESERVE, params);\n    return checkParams(value, datatype, params);\n  } else if (datatype.localName === 'normalizedString') {\n    const value = whitespace(data, Whitespace.PRESERVE, params);\n    return checkRegExpAndParams(normalizedStringRegExp, value, datatype, params);\n  } else if (datatype.localName === 'token') {\n    const value = whitespace(data, Whitespace.PRESERVE, params);\n    return checkRegExpAndParams(tokenRegExp, value, datatype, params);\n  } else if (datatype.localName === 'language') {\n    const value = whitespace(data, Whitespace.PRESERVE, params);\n    return checkRegExpAndParams(languageRegExp, value, datatype, params);\n    /*\n     * Types derived from decimal\n     */\n  } else if (datatype.localName === 'decimal') {\n    const value = whitespace(data, Whitespace.COLLAPSE, params);\n    return checkRegExpAndParams(decimalRegExp, value, datatype, params);\n  } else if (datatype.localName === 'integer') {\n    const value = whitespace(data, Whitespace.COLLAPSE, params);\n    return checkRegExpAndParams(integerRegExp, value, datatype, params);\n  } else if (datatype.localName === 'long') {\n    const value = whitespace(data, Whitespace.COLLAPSE, params);\n    return checkIntegerRange(LONG_MIN, LONG_MAX, value, datatype, params);\n  } else if (datatype.localName === 'int') {\n    const value = whitespace(data, Whitespace.COLLAPSE, params);\n    return checkIntegerRange(INT_MIN, INT_MAX, value, datatype, params);\n  } else if (datatype.localName === 'short') {\n    const value = whitespace(data, Whitespace.COLLAPSE, params);\n    return checkIntegerRange(SHORT_MIN, SHORT_MAX, value, datatype, params);\n  } else if (datatype.localName === 'byte') {\n    const value = whitespace(data, Whitespace.COLLAPSE, params);\n    return checkIntegerRange(BYTE_MIN, BYTE_MAX, value, datatype, params);\n    /*\n     * Integer types\n     */\n  } else if (datatype.localName === 'negativeInteger') {\n    const value = whitespace(data, Whitespace.COLLAPSE, params);\n    return checkIntegerRange(undefined, -1, value, datatype, params);\n  } else if (datatype.localName === 'nonPositiveInteger') {\n    const value = whitespace(data, Whitespace.COLLAPSE, params);\n    return checkIntegerRange(undefined, 0, value, datatype, params);\n  } else if (datatype.localName === 'nonNegativeInteger') {\n    const value = whitespace(data, Whitespace.COLLAPSE, params);\n    return checkIntegerRange(0, undefined, value, datatype, params);\n  } else if (datatype.localName === 'positiveInteger') {\n    const value = whitespace(data, Whitespace.COLLAPSE, params);\n    return checkIntegerRange(1, undefined, value, datatype, params);\n    /*\n     * Signed or unsigned numbers\n     */\n  } else if (datatype.localName === 'unsignedLong') {\n    const value = whitespace(data, Whitespace.COLLAPSE, params);\n    return checkIntegerRange(0, UNSIGNED_LONG_MAX, value, datatype, params);\n  } else if (datatype.localName === 'unsignedInt') {\n    const value = whitespace(data, Whitespace.COLLAPSE, params);\n    return checkIntegerRange(0, UNSIGNED_INT_MAX, value, datatype, params);\n  } else if (datatype.localName === 'unsignedShort') {\n    const value = whitespace(data, Whitespace.COLLAPSE, params);\n    return checkIntegerRange(0, UNSIGNED_SHORT_MAX, value, datatype, params);\n  } else if (datatype.localName === 'unsignedByte') {\n    const value = whitespace(data, Whitespace.COLLAPSE, params);\n    return checkIntegerRange(0, UNSIGNED_BYTE_MAX, value, datatype, params);\n  } else {\n    console.warn(`Unknown XSD datatype ${datatypeToString(datatype.iri)}`);\n    const value = whitespace(data, Whitespace.COLLAPSE, params);\n    return checkParams(value, datatype, params);\n  }\n}\n\n/**\n * Performs equality comparison of two values of specified datatype.\n */\nexport function datatypeEqual(datatype: Datatype, first: string, second: string): ValidationResult {\n  if (datatype.localName === 'boolean') {\n    const value = whitespace(second, Whitespace.COLLAPSE);\n    const patternValue = whitespace(first, Whitespace.COLLAPSE);\n    if (value.toLowerCase() === patternValue.toLowerCase()) {\n      return success();\n    } else {\n      return failure('Invalid value, expected is [' + patternValue + ']', datatype, second);\n    }\n  } else if (datatype.localName === 'float' || datatype.localName === 'double' || datatype.localName === 'decimal') {\n    const value = parseFloat(second);\n    const patternValue = parseFloat(first);\n    if (value === patternValue) {\n      return success();\n    } else {\n      return failure('Invalid value, expected is [' + patternValue + ']', datatype, second);\n    }\n  } else if (\n    datatype.localName === 'integer' ||\n    datatype.localName === 'long' ||\n    datatype.localName === 'int' ||\n    datatype.localName === 'short' ||\n    datatype.localName === 'byte' ||\n    datatype.localName === 'negativeInteger' ||\n    datatype.localName === 'nonPositiveInteger' ||\n    datatype.localName === 'nonNegativeInteger' ||\n    datatype.localName === 'positiveInteger' ||\n    datatype.localName === 'unsignedLong' ||\n    datatype.localName === 'unsignedInt' ||\n    datatype.localName === 'unsignedShort' ||\n    datatype.localName === 'unsignedByte'\n  ) {\n    const value = parseInt(second);\n    const patternValue = parseInt(first);\n    if (value === patternValue) {\n      return success();\n    } else {\n      return failure('Invalid value, expected is [' + patternValue + ']', datatype, second);\n    }\n  } else if (datatype.localName === 'anyURI') {\n    const value = whitespace(second, Whitespace.COLLAPSE);\n    const patternValue = whitespace(first, Whitespace.COLLAPSE);\n    if (value === patternValue) {\n      return success();\n    } else {\n      return failure('Invalid value, expected is [' + patternValue + ']', datatype, second);\n    }\n  } else if (\n    datatype.localName === 'string' ||\n    datatype.localName === 'normalizedString' ||\n    datatype.localName === 'token' ||\n    datatype.localName === 'language'\n  ) {\n    const value = whitespace(second, Whitespace.PRESERVE);\n    const patternValue = whitespace(first, Whitespace.PRESERVE);\n    if (value === patternValue) {\n      return success();\n    } else {\n      return failure('Invalid value, expected is [' + patternValue + ']', datatype, second);\n    }\n  } else if (datatype.localName === 'base64Binary') {\n    const value = second.replace(/ /g, '');\n    const patternValue = first.replace(/ /g, '');\n    if (value === patternValue) {\n      return success();\n    } else {\n      return failure('Invalid value, expected is [' + patternValue + ']', datatype, second);\n    }\n  } else if (datatype.localName === 'hexBinary') {\n    const value = whitespace(second, Whitespace.COLLAPSE);\n    const patternValue = whitespace(first, Whitespace.COLLAPSE);\n    // canonical representation of hexBinary prohibites lower case\n    if (value.toUpperCase() === patternValue.toUpperCase()) {\n      return success();\n    } else {\n      return failure('Invalid value, expected is [' + patternValue + ']', datatype, second);\n    }\n  } else {\n    console.warn(`Unknown XSD datatype ${datatypeToString(datatype.iri)}`);\n    return success();\n  }\n}\n\nfunction whitespace(str: string, defaultWhitespace: Whitespace, params?: Param[]) {\n  let wsParam = defaultWhitespace;\n  if (params) {\n    params.forEach((param) => {\n      if ('whitespace' in param) {\n        wsParam = (param as any).whitespace;\n      }\n    });\n  }\n  if (wsParam === Whitespace.REPLACE) {\n    return str.replace(/[\\t\\n\\r]/g, ' ');\n  } else if (wsParam === Whitespace.COLLAPSE) {\n    const value = str.replace(/[\\t\\n\\r ]+/g, ' ');\n    // removes leading and trailing space\n    return value.replace(/^ /, '').replace(/ $/, '');\n  }\n  return str;\n}\n\nfunction checkIntegerRange(\n  min: number,\n  max: number,\n  str: string,\n  datatype: Datatype,\n  params: Param[]\n): ValidationResult {\n  const checkInteger = checkRegExp(integerRegExp, str, datatype);\n  if (!checkInteger.success) {\n    return checkInteger;\n  }\n  const intValue = parseInt(str);\n  // min can be undefined if condition is just inferior\n  if (min !== undefined) {\n    if (intValue < min) {\n      return failure(\n        'Integer value is too small, minimum is ' + min + ' for datatype ' + datatypeToString(datatype.iri),\n        datatype,\n        str\n      );\n    }\n  }\n  if (max !== undefined) {\n    if (intValue > max) {\n      return failure(\n        'Integer value is too big, maximum is ' + max + ' for datatype ' + datatypeToString(datatype.iri),\n        datatype,\n        str\n      );\n    }\n  }\n  return checkParams(str, datatype, params);\n}\n\nfunction checkRegExpAndParams(regExp: RegExp, str: string, datatype: Datatype, params: Param[]): ValidationResult {\n  const check = checkRegExp(regExp, str, datatype);\n  if (!check.success) {\n    return check;\n  }\n  return checkParams(str, datatype, params);\n}\n\nfunction checkRegExp(regExp: RegExp, str: string, datatype: Datatype): ValidationResult {\n  if (regExp.test(str)) {\n    return success();\n  }\n  return failure(`Invalid ${datatypeToString(datatype.iri)}`, datatype, str);\n}\n\nfunction checkParams(str: string, datatype: Datatype, params: Param[]): ValidationResult {\n  const enumeration: string[] = [];\n  for (const param of params) {\n    for (const paramName in param) {\n      if (!param.hasOwnProperty(paramName)) {\n        continue;\n      }\n      const paramValue = param[paramName] as any;\n      // gathers enumerations before triggering it\n      if (paramName === 'enumeration') {\n        enumeration.push(paramValue);\n      } else if (paramName !== 'whitespace') {\n        const check = checkParam(str, paramName, paramValue, datatype);\n        if (!check.success) {\n          return check;\n        }\n      }\n    }\n  }\n  if (enumeration.length > 0) {\n    const check = checkEnumeration(str, enumeration, datatype);\n    if (!check.success) {\n      return check;\n    }\n  }\n  return success();\n}\n\nfunction checkParam(str: string, paramName: string, paramValue: string, datatype: Datatype): ValidationResult {\n  if (paramName === 'length') {\n    const number = parseInt(paramValue, 10);\n    if (str.length !== number) {\n      return failure('Invalid number of characters, expected ' + number + ', found: ' + str.length, datatype, str);\n    }\n  } else if (paramName === 'minLength') {\n    const number = parseInt(paramValue, 10);\n    if (str.length < number) {\n      return failure('String too small, ' + paramName + ' is ' + number + ', found: ' + str.length, datatype, str);\n    }\n  } else if (paramName === 'maxLength') {\n    const number = parseInt(paramValue, 10);\n    if (str.length > number) {\n      return failure('String too long, ' + paramName + ' is ' + number + ', found: ' + str.length, datatype, str);\n    }\n  } else if (paramName === 'minInclusive') {\n    const number = parseFloat(paramValue);\n    const value = parseFloat(str);\n    if (value < number) {\n      return failure('Value too small, ' + paramName + ' is ' + number + ', found: ' + value, datatype, str);\n    }\n  } else if (paramName === 'minExclusive') {\n    const number = parseFloat(paramValue);\n    const value = parseFloat(str);\n    if (value <= number) {\n      return failure('Value too small, ' + paramName + ' is ' + number + ', found: ' + value, datatype, str);\n    }\n  } else if (paramName === 'maxInclusive') {\n    const number = parseFloat(paramValue);\n    const value = parseFloat(str);\n    if (value > number) {\n      return failure('Value too big, ' + paramName + ' is ' + number + ', found: ' + value, datatype, str);\n    }\n  } else if (paramName === 'maxExclusive') {\n    const number = parseFloat(paramValue);\n    const value = parseFloat(str);\n    if (value >= number) {\n      return failure('Value too big, ' + paramName + ' is ' + number + ', found: ' + value, datatype, str);\n    }\n  } else if (paramName === 'totalDigits') {\n    const number = parseInt(paramValue, 10);\n    const length = str.replace(/\\./, '').length;\n    if (length !== number) {\n      return failure('Invalid number of digits, ' + paramName + ' is ' + number + ', found: ' + length, datatype, str);\n    }\n  } else if (paramName === 'fractionDigits') {\n    const number = parseInt(paramValue, 10);\n    const regExp = new RegExp(fractionDigits + '{' + number + '}$');\n    const check = checkRegExp(regExp, str, datatype);\n    // adds an error message\n    if (!check.success) {\n      return failure('Invalid number of fraction digits, expected: ' + number, check, str);\n    }\n  } else if (paramName === 'pattern') {\n    const escaped = paramValue.replace(/\\\\/gm, '\\\\\\\\');\n    const regExp = new RegExp('^' + escaped + '$');\n    const check = checkRegExp(regExp, str, datatype);\n    // adds an error message\n    if (!check.success) {\n      return failure(`Value ${str} does not respect pattern: ${paramValue}`, check, str);\n    }\n  }\n  return success();\n}\n\nfunction checkEnumeration(str: string, enumeration: string[], datatype: Datatype): ValidationResult {\n  for (let value of enumeration) {\n    const escaped = escapeRegExp(value);\n    const regExp = new RegExp('^' + escaped + '$');\n    const check = checkRegExp(regExp, str, datatype);\n    if (check.success) {\n      return check;\n    }\n  }\n  let msg = `Invalid value ${str}, must be one of [` + enumeration[0];\n  for (let i = 1; i < enumeration.length; i++) {\n    const value = enumeration[i];\n    msg += ',' + value;\n  }\n  msg += ']';\n  return failure(msg, datatype, str);\n}\n\nfunction escapeRegExp(str: string) {\n  return str.replace(/\\\\/gm, '\\\\\\\\').replace(/([\\f\\b\\n\\t\\r\\[\\^$|?*+(){}])/gm, '\\\\$1');\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\n/**\n * @author Alexey Morozov\n */\nexport class WrappingError extends Error {\n  readonly innerError: any;\n\n  constructor(message: string, innerError: any) {\n    super(WrappingError.formatMessage(message, innerError));\n    this.innerError = innerError;\n    Object.setPrototypeOf(this, WrappingError.prototype);\n    if (Error.captureStackTrace) {\n      // if not IE\n      Error.captureStackTrace(this, WrappingError);\n    } else {\n      this.stack = new Error().stack;\n    }\n  }\n\n  static formatMessage(message: string, innerError?: any) {\n    const innerMessage = innerError ? innerError.message : undefined;\n    return message + (innerMessage ? ': \\n' + innerMessage : '');\n  }\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as Kefir from 'kefir';\nimport * as Immutable from 'immutable';\n\ninterface FetchResult<Input, Output> {\n  inputs: Immutable.Set<Input>;\n  batch?: Immutable.Map<Input, Output>;\n  error?: any;\n}\n\nconst DEFAULT_INTERVAL_MS = 20;\nconst DEFAULT_BATCH_SIZE = 100;\n\n/**\n * Combines multiple async request in a single batch by buffering\n * them using {@Kefir.Stream.bufferWithTimeOrCount}.\n *\n * @author Alexey Morozov\n */\nexport class BatchedPool<Input, Output> {\n  private emitter: Kefir.Emitter<Input>;\n  private bufferedStream: Kefir.Stream<FetchResult<Input, Output>>;\n\n  readonly batchSize: number;\n\n  constructor(params: {\n    fetch: (inputs: Immutable.Set<Input>) => Kefir.Property<Immutable.Map<Input, Output>>;\n    batchSize?: number;\n    delayIntervalMs?: number;\n  }) {\n    const { batchSize = DEFAULT_BATCH_SIZE, delayIntervalMs = DEFAULT_INTERVAL_MS } = params;\n\n    this.batchSize = batchSize;\n\n    const stream = Kefir.stream<Input>((emitter) => {\n      this.emitter = emitter;\n    });\n    this.bufferedStream = stream\n      .bufferWithTimeOrCount(delayIntervalMs, batchSize)\n      .filter((inputs) => inputs.length > 0)\n      .flatMap<FetchResult<Input, Output>>((inputArray) => {\n        const inputs = Immutable.Set(inputArray);\n        return params\n          .fetch(inputs)\n          .map((batch) => ({ inputs, batch }))\n          .flatMapErrors<any>((error) => Kefir.constant({ inputs, error }));\n      })\n      .onEnd(() => {\n        /* to activate stream */\n      });\n  }\n\n  query(input: Input): Kefir.Property<Output> {\n    this.emitter.emit(input);\n    return this.bufferedStream\n      .filter((result) => result.inputs.has(input))\n      .flatMap<Output>((result) => {\n        if (result.batch) {\n          return Kefir.constant(result.batch.get(input));\n        } else {\n          return Kefir.constantError<any>(result.error);\n        }\n      })\n      .take(1)\n      .takeErrors(1)\n      .toProperty();\n  }\n}\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as _ from 'lodash';\nimport * as uuidLib from 'uuid';\n\n/**\n * Handlebars doesn't have any meance to use comparison operators in templates.\n * This function provides conditional if function for templates.\n *\n * Ex.:\n * {{#ifCond value \">=\" 0}}<div>some content</div>{{else}}<div>some other content</div>{{/ifCond}}\n */\nfunction checkCondition(v1, operator, v2) {\n  switch (operator) {\n    case '==':\n      // tslint:disable-next-line:triple-equals\n      return v1 == v2;\n    case '===':\n      return v1 === v2;\n    case '!==':\n      return v1 !== v2;\n    case '<':\n      return v1 < v2;\n    case '<=':\n      return v1 <= v2;\n    case '>':\n      return v1 > v2;\n    case '>=':\n      return v1 >= v2;\n    case '&&':\n      return v1 && v2;\n    case '||':\n      return v1 || v2;\n    default:\n      return false;\n  }\n}\n\n/**\n * Generic helper functions for Handlebars templates.\n */\nexport const GenericFunctions = {\n  /**\n   * if operator for handlebars templates.\n   */\n  ifCond: function (v1, operator, v2, options) {\n    return checkCondition(v1, operator, v2) ? options.fn(this) : options.inverse(this);\n  },\n\n  and: function() {\n    return Array.prototype.every.call(arguments, Boolean);\n  },\n\n  eq: (v1, v2) => v1 === v2,\n  not: (v1) => !v1,\n\n  or: function() {\n    return Array.prototype.slice.call(arguments, 0, -1).some(Boolean);\n  },\n\n  /**\n   * switch statement for handlebars templates\n   * Use break=true to skip other cases\n   * Use default for unmatched cases\n   *\n   * @example\n   *\n   * {{#switch type}}\n   *   {{#case \"http://example.com/Organisation\" break=true}}\n   *     <p>Type is Organisation</p>\n   *   {{/case}}\n   *   {{#case \"http://example.com/Person\" break=true}}\n   *     <p>Type is Person</p>\n   *   {{/case}}\n   *   {{#default}}\n   *     <p>Default content here</p>\n   *   {{/default}}\n   * {{/switch}}\n   *\n   */\n  switch: function (value, options) {\n    this.switchValue = value;\n    this.switchBreak = false;\n    let html = options.fn(this);\n    delete this.switchBreak;\n    delete this.switchValue;\n    return html;\n  },\n\n  case: function (value) {\n    let args = Array.prototype.slice.call(arguments);\n    let options = args.pop();\n\n    if (this.switchBreak || args.indexOf(this.switchValue) === -1) {\n      return '';\n    } else {\n      if (options.hash.break === true) {\n        this.switchBreak = true;\n      }\n      return options.fn(this);\n    }\n  },\n\n  default: function (options) {\n    if (!this.switchBreak) {\n      return options.fn(this);\n    }\n  },\n\n  /**\n   *  object length helper for handlebars templates.\n   */\n  objectLength: function (object) {\n    return Object.keys(object).length;\n  },\n\n  /**\n   * Raw block for template escaping.\n   */\n  raw: function (options) {\n    return options.fn(this);\n  },\n\n  getValueByKey(options: Array<{key: string, value: string}>, keys: Array<string>, noMatch: any) {\n    for (let i = 0; i < keys.length; i++) {\n      const value = _.find(options, o => o.key === keys[i]);\n      if (value) {\n        return value.value;\n      }\n    }\n    return noMatch;\n  },\n\n  hasKey(options: Array<string>, key: string) {\n    const has = _.some(options, o => o === key);\n    return has ? true : undefined;\n  },\n\n  stringify(options) {\n    return JSON.stringify(options);\n  },\n\n  /**\n   * generate uuid\n   */\n  uuid() {\n    return uuidLib.v4();\n  }\n};\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport * as moment from 'moment';\n\nexport const DateTimeFunctions = {\n  /**\n   * Date-time formating function. Default format is\n   * \"Month name, day of month, year  - e.g September 4 1986\"\n   * It is possible to use any format supported by moment.js,\n   * see http://momentjs.com/docs/#/displaying/ for more details.\n   */\n  dateTimeFormat: function (dateTime: any, format: any, sourceFormat: any) {\n    if (dateTime === undefined || dateTime === null) {\n      return '';\n    }\n    if (typeof format !== 'string') {\n      format = 'LL';\n    }\n    if (typeof sourceFormat !== 'string') {\n      sourceFormat = undefined;\n    }\n    return moment(dateTime, sourceFormat).format(format);\n  },\n  /**\n   * Returns the current system time. Default format is \"DD.MM.YYYY HH:mm:ss.SSS\"\n   * @example\n   * {{currentDateTime 'MM-DD-YYYY'}}\n   */\n  currentDateTime: function (format: any) {\n    if (typeof format !== 'string') {\n      format = 'DD.MM.YYYY HH:mm:ss.SSS';\n    }\n    return moment().format(format);\n  },\n};\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { Rdf } from 'platform/api/rdf';\n\nexport const RdfFunctions = {\n  isIri: function (value: Rdf.Node) {\n    return value.isIri();\n  },\n\n  isBnode: function (value: Rdf.Node) {\n    return value.isBnode();\n  },\n\n  isLiteral: function (value: Rdf.Node) {\n    return value.isLiteral();\n  },\n};\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nexport const UriComponentFunctions = {\n  /**\n   * Encodes a URI component.\n   * @example\n   * {{encodeUriComponent '?uri=http://example.com'}}\n   */\n  encodeUriComponent: function (uri: string) {\n    return encodeURIComponent(uri);\n  },\n  /**\n   * Decodes a URI component.\n   * @example\n   * {{decodeUriComponent '%3Furi%3Dhttp%3A%2F%2Fexample.com'}}\n   */\n  decodeUriComponent: function (uri: string) {\n    return decodeURIComponent(uri);\n  },\n};\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nexport const NumbersFunctions = {\n  ceil: (number) => Math.ceil(number),\n  floor: (number) => Math.floor(number),\n  round: (number) => Math.round(number),\n  toFixed: (number: number, digits: number) => Number(number).toFixed(digits),\n  plus: (n1: number, n2: number) => Number(n1) + Number(n2),\n  minus: (n1: number, n2: number) => Number(n1) - Number(n2),\n};\n","/**\n * ResearchSpace\n * Copyright (C) 2020, © Trustees of the British Museum\n * Copyright (C) 2015-2019, metaphacts GmbH\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { WrappingError } from 'platform/api/async';\nimport { Rdf } from 'platform/api/rdf';\n\nimport { DefaultHelpers, ContextCapturer, CapturedContext } from './functions';\n\nimport { ParsedTemplate } from './TemplateCommons';\nimport { defaultContextCache } from './TemplateCache';\nimport {\n  fetchRemoteTemplate,\n  parseTemplate,\n  isRemoteReference,\n  createHandlebarsWithIRILookup,\n} from './RemoteTemplateFetcher';\n\nconst EMPTY_TEMPLATE: CompiledTemplate = () => '';\n\nexport type CompiledTemplate = (\n  dataContext?: object,\n  options?: {\n    capturer?: ContextCapturer;\n    parentContext?: CapturedContext;\n  }\n) => string;\n\nexport interface TemplateScopeProps {\n  partials?: { readonly [id: string]: string };\n}\n\nexport interface TemplateScopeTrace {\n  componentTag?: string;\n  componentId?: string;\n  templateId?: string;\n}\n\nexport interface TemplateScopeOptions extends TemplateScopeProps {\n  scopeTrace?: TemplateScopeTrace\n  helpers?: { readonly [id: string]: Function };\n}\n\n/**\n * Represents an isolated Handlebars compiler instance acting as a container\n * for partials and helpers with an ability to clone it.\n *\n * Cloned scope doesn't depend on it's parent, e.g. registering a helper or a\n * partial on a parent scope won't affect cloned scope.\n *\n * @example\n * // compile template with default global partials and helpers\n * TemplateScope.default.compile('<div>{{foo}}</div>')\n *   .then(template => { ... });\n *\n * // create an isolated scope with partials using `create()` or `builder()`\n * const isolateScopeWithCreate = TemplateScope.create({\n *   partials: {\n *     foo: '<span>{{> @partial-block}}<span>',\n *   }\n * });\n * const isolatedScopeWithBuilder = TemplateScope.builder()\n *  .registerPartial('foo', '<span>{{> @partial-block}}<span>')\n *  .build();\n *\n * // use either local partials or remote ones\n * // (by specifying IRI as a partial name)\n * clonedScope.compile('{{#> foo}} {{> platform:someTemplate}} {{/foo}}')\n *   .then(template => { ... });\n */\nexport class TemplateScope {\n  static readonly default = new TemplateScope(DefaultHelpers, null, null, defaultContextCache);\n  /** DO NOT USE. For testing purposes only. */\n  static _fetchRemoteTemplate = fetchRemoteTemplate;\n\n  private readonly handlebars = createHandlebarsWithIRILookup();\n  private readonly compiledCache;\n\n  private readonly partials: ReadonlyMap<string, ParsedTemplate>;\n\n  private constructor(\n    private readonly helpers: { readonly [id: string]: Function },\n    private readonly scopeTrace?: TemplateScopeTrace,\n    partials?: ReadonlyMap<string, ParsedTemplate>,\n    cache?: Map<string, HandlebarsTemplateDelegate>,\n  ) {\n    this.compiledCache = cache || new Map<string, HandlebarsTemplateDelegate>();\n    for (const helperId in helpers) {\n      if (!helpers.hasOwnProperty(helperId)) {\n        continue;\n      }\n      this.handlebars.registerHelper(helperId, helpers[helperId]);\n    }\n\n    this.partials = partials || new Map<string, ParsedTemplate>();\n    this.partials.forEach((body, id) => {\n      this.handlebars.registerPartial(id, body.ast);\n    });\n  }\n\n  clearCache() {\n    this.compiledCache.clear();\n  }\n\n  getPartial(name: string): ParsedTemplate {\n    return this.partials.get(name);\n  }\n\n  static builder(options: TemplateScopeOptions = {}): TemplateScopeBuilder {\n    const helpers = { ...DefaultHelpers, ...options.helpers };\n    return new TemplateScopeBuilder(\n      options, (partials) => new TemplateScope(helpers, options.scopeTrace, partials)\n    );\n  }\n\n  static create(options: TemplateScopeOptions = {}) {\n    return TemplateScope.builder(options).build();\n  }\n\n  exportProps(): TemplateScopeProps {\n    const partials: { [id: string]: string } = {};\n    this.partials.forEach((partial, id) => (partials[id] = partial.source));\n    return { partials };\n  }\n\n  compile(template: string): Promise<CompiledTemplate> {\n    if (template === undefined || template === null) {\n      return Promise.resolve(EMPTY_TEMPLATE);\n    }\n    const fromCache = this.compiledCache.get(template);\n    if (fromCache) {\n      return Promise.resolve(fromCache);\n    }\n    return this.resolve(template).then((resolved) => {\n      const withParentContext: CompiledTemplate = (local, { capturer, parentContext } = {}) =>\n        resolved(local, {\n          data: {\n            [ContextCapturer.DATA_KEY]: capturer,\n            [CapturedContext.DATA_KEY]: parentContext,\n          },\n        });\n      this.compiledCache.set(template, withParentContext);\n      return withParentContext;\n    });\n  }\n\n  /**\n   * Synchronously compiles template without resolving remote template references.\n   * @deprecated\n   */\n  compileWithoutRemote(template: string): CompiledTemplate {\n    if (template === undefined || template === null) {\n      return EMPTY_TEMPLATE;\n    }\n    const fromCache = this.compiledCache.get(template);\n    if (fromCache) {\n      return fromCache;\n    }\n    const compiled = this.handlebars.compile(template);\n    const withParentContext: CompiledTemplate = (local, { capturer, parentContext } = {}) =>\n      compiled(local, {\n        data: {\n          [ContextCapturer.DATA_KEY]: capturer,\n          [CapturedContext.DATA_KEY]: parentContext,\n        },\n      });\n    this.compiledCache.set(template, withParentContext);\n    return withParentContext;\n  }\n\n  private resolve(templateBody: string): Promise<HandlebarsTemplateDelegate> {\n    return Promise.resolve(templateBody)\n      .then(parseTemplate)\n      .then((parsed) => {\n        const dependencies = new Map<string, ParsedTemplate>();\n        return recursiveResolve(parsed, dependencies, this.loadByReference)\n          .then(() => {\n            dependencies.forEach((dependency, iri) => {\n              if (!this.partials.has(iri)) {\n                this.handlebars.registerPartial(iri, dependency.ast);\n              }\n            });\n          })\n          .then(() => this.handlebars.compile(parsed.ast));\n      });\n  }\n\n  /** Loads partial by local name or remote reference. */\n  private loadByReference = (reference: string): Promise<ParsedTemplate | null> => {\n    if (this.partials.has(reference)) {\n      return Promise.resolve(this.partials.get(reference));\n    } else if (isRemoteReference(reference)) {\n      return TemplateScope._fetchRemoteTemplate(Rdf.iri(reference));\n    } else {\n      // if we can't find partial then we just return null\n      // to resort to handlebars default resolution logic.\n      // It gives us the ability to use partial failover mechanism.\n      // see https://handlebarsjs.com/guide/partials.html#partial-blocks\n      return Promise.resolve(null);\n    }\n  };\n}\n\nexport class TemplateScopeBuilder {\n  private partials = new Map<string, ParsedTemplate>();\n\n  constructor(\n    options: TemplateScopeOptions,\n    private createScope: (partials: Map<string, ParsedTemplate>) => TemplateScope\n  ) {\n    const { partials = {} } = options;\n    for (const id in partials) {\n      if (!partials.hasOwnProperty(id)) {\n        continue;\n      }\n      const partialText = partials[id];\n      if (typeof partialText === 'string') {\n        this.registerPartial(id, partialText);\n      }\n    }\n  }\n\n  registerPartial(id: string, partial: string | ParsedTemplate): this {\n    if (this.partials.has(id)) {\n      throw new Error(`Template partial '${id}' already registered`);\n    }\n    const parsedTemplate = typeof partial === 'string' ? parseTemplate(partial) : partial;\n    this.partials.set(id, parsedTemplate);\n    return this;\n  }\n\n  build(): TemplateScope {\n    return this.createScope(this.partials);\n  }\n}\n\nasync function recursiveResolve(\n  parsedTemplate: ParsedTemplate,\n  dependencies: Map<string, ParsedTemplate>,\n  load: (reference: string) => Promise<ParsedTemplate>\n): Promise<{}> {\n  const body = await Promise.resolve(parsedTemplate);\n  const referencesToLoad = parsedTemplate.references.filter((reference) => !dependencies.has(reference));\n  for (const reference of referencesToLoad) {\n    // mark dependency to prevent multiple loading\n    dependencies.set(reference, null);\n  }\n\n  const fetchedDependencies = [];\n  for (const reference of referencesToLoad) {\n    const loaded = await load(reference);\n    if (loaded != null) {\n      fetchedDependencies.push({ reference, template: loaded });\n    } else {\n      dependencies.delete(reference);\n    }\n  }\n\n  const fetched = await Promise.all(fetchedDependencies);\n  for (const { reference, template } of fetched) {\n    dependencies.set(reference, template);\n  }\n  return Promise.all(\n    fetched.map(({ reference, template }) =>\n      recursiveResolve(template, dependencies, load).catch((error) => {\n        throw new WrappingError(`Error while resolving dependencies of template '${reference}'`, error);\n      })\n    )\n  );\n}\n"],"sourceRoot":""}