push v0.8 to master

# Conflicts:
#	README.md

doc/export-import.md

@@ -0,0 +1,99 @@
+## Import / Export (In-Memory)
+
+> Persistent-Indexes and Worker-Indexes don't support Import/Export.
+
+Export an `Index` or `Document-Index` to the folder `/export/`:
+
+```js
+import { promises as fs } from "fs";
+
+await index.export(async function(key, data){
+  await fs.writeFile("./export/" + key, data, "utf8");
+});
+```
+
+Import from folder `/export/` into an `Index` or `Document-Index`:
+
+```js
+const index = new Index({/* keep old config and place it here */});
+
+const files = await fs.readdir("./export/");
+for(let i = 0; i < files.length; i++){
+  const data = await fs.readFile("./export/" + files[i], "utf8");
+  await index.import(files[i], data);
+}
+```
+
+> You'll need to use the same configuration as you used before the export. Any changes on the configuration needs to be re-indexed.
+
+## Fast-Boot Serialization for Server-Side-Rendering (PHP, Python, Ruby, Rust, Java, Go, Node.js, ...)
+
+> This is an experimental feature with limited support which probably might drop in future release. You're welcome to give some feedback.
+
+When using Server-Side-Rendering you can create a different export which instantly boot up. Especially when using Server-side rendered content, this could help to restore a __<u>static</u>__ index on page load. Document-Indexes aren't supported yet for this method.
+
+> When your index is too large you should use the default export/import mechanism.
+
+As the first step populate the FlexSearch index with your contents.
+
+You have two options:
+
+### 1. Create a function as string
+
+```js
+const fn_string = index.serialize();
+```
+
+The contents of `fn_string` is a valid Javascript-Function declared as `inject(index)`. Store it or place this somewhere in your code.
+
+This function basically looks like:
+
+```js
+function inject(index){
+    index.reg = new Set([/* ... */]);
+    index.map = new Map([/* ... */]);
+    index.ctx = new Map([/* ... */]);
+}
+```
+
+You can save this function by e.g. `fs.writeFileSync("inject.js", fn_string);` or place it as string in your SSR-generated markup.
+
+After creating the index on client side just call the inject method like:
+
+```js
+const index = new Index({/* use same configuration! */});
+inject(index);
+```
+
+That's it.
+
+> You'll need to use the same configuration as you used before the export. Any changes on the configuration needs to be re-indexed.
+
+### 2. Create just a function body as string
+
+Alternatively you can use lazy function declaration by passing `false` to the serialize function:
+
+```js
+const fn_body = index.serialize(false);
+```
+
+You will get just the function body which looks like:
+
+```js
+index.reg = new Set([/* ... */]);
+index.map = new Map([/* ... */]);
+index.ctx = new Map([/* ... */]);
+```
+
+Now you can place this in your code directly (name your index as `index`), or you can also create an inject function from it, e.g.:
+
+```js
+const inject = new Function("index", fn_body);
+```
+
+This function is callable like the above example:
+
+```js
+const index = new Index();
+inject(index);
+```