diff --git a/config.go b/config.go
index 71d5f5d..8d89255 100644
--- a/config.go
+++ b/config.go
@@ -24,6 +24,10 @@ type Config struct {
 		Secret     string
 		ExpireDays int
 	}
+
+	Storage struct {
+		Files string
+	}
 }
 
 func readConfig(fname string) (err error) {
diff --git a/file.go b/file.go
index 9ad8457..6dd1c75 100644
--- a/file.go
+++ b/file.go
@@ -5,35 +5,47 @@ import (
 	"github.com/jmoiron/sqlx"
 
 	// Standard
+	"fmt"
+	"os"
+	"path"
 	"time"
 )
 
 type File struct {
-	ID       int
-	UserID   int `db:"user_id"`
-	NodeID   int `db:"node_id"`
-	Filename string
-	Size     int64
-	MIME     string
-	MD5      string
-	Uploaded time.Time
+	ID             int
+	UUID           string
+	UserID         int    `db:"user_id"`
+	Name           string `db:"name"`
+	Size           int
+	Type           string `db:"type"`
+	Modified       time.Time
+	UploadComplete bool `db:"upload_complete"`
 }
 
-func AddFile(userID int, file *File) (err error) { // {{{
+var (
+	fileUUIDCache map[string]int
+)
+
+func init() {
+	fileUUIDCache = make(map[string]int)
+}
+
+func AddFileToDb(userID int, file *File) (err error) { // {{{
 	file.UserID = userID
 
 	var rows *sqlx.Rows
 	rows, err = db.Queryx(`
-		INSERT INTO file(user_id, node_id, filename, size, mime, md5)
-		VALUES($1, $2, $3, $4, $5, $6)
+		INSERT INTO public.file(user_id, uuid, name, size, type, modified, upload_complete)
+		VALUES($1, $2, $3, $4, $5, $6, false)
+		ON CONFLICT (user_id, uuid) DO UPDATE set name = public.file.name
 		RETURNING id
 		`,
 		file.UserID,
-		file.NodeID,
-		file.Filename,
+		file.UUID,
+		file.Name,
 		file.Size,
-		file.MIME,
-		file.MD5,
+		file.Type,
+		file.Modified,
 	)
 	if err != nil {
 		return
@@ -76,5 +88,101 @@ func Files(userID int, nodeUUID string, fileID int) (files []File, err error) {
 
 	return
 } // }}}
+func FileIDToPath(id int) (string, string) { // {{{
+	str := fmt.Sprintf("%012d", id)
+	dir := path.Join(config.Storage.Files, str[0:4], str[4:8])
+	fpath := path.Join(config.Storage.Files, str[0:4], str[4:8], str[8:12])
+	return dir, fpath
+} // }}}
+
+func FileWriteData(userID int, dbID int, data []byte, create bool) (err error) { // {{{
+	dir, fpath := FileIDToPath(dbID)
+	err = os.MkdirAll(dir, 0700)
+	if err != nil {
+		Log.Error("file", "error", err)
+		return
+	}
+
+	var f *os.File
+	if create {
+		f, err = os.OpenFile(fpath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0644)
+	} else {
+		f, err = os.OpenFile(fpath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
+	}
+	if err != nil {
+		Log.Error("file", "error", err)
+		return
+	}
+	defer f.Close()
+
+	_, err = f.Write(data)
+	if err != nil {
+		Log.Error("file", "error", err)
+		return
+	}
+
+	return
+} // }}}
+
+func FileCountForUser(userID int) (count int, err error) { // {{{
+	row := db.QueryRowx(`SELECT COUNT(*) FROM public.file WHERE user_id = $1`, userID)
+	err = row.Scan(&count)
+	return
+} // }}}
+func FileServerUUIDsForUser(userID, page int) (uuids []string, more bool, err error) { // {{{
+	uuids = []string{}
+
+	var rows *sqlx.Rows
+	rows, err = db.Queryx(`
+		SELECT
+			uuid
+		FROM public.file
+		WHERE
+			user_id = $1
+		ORDER BY
+			uuid ASC
+		LIMIT $2 OFFSET $3
+		`,
+		userID,
+		SYNC_PAGINATION+1,
+		page*SYNC_PAGINATION,
+	)
+	if err != nil {
+		return
+	}
+	defer rows.Close()
+
+	var uuid string
+	for rows.Next() {
+		err = rows.Scan(&uuid)
+		if err != nil {
+			return
+		}
+		uuids = append(uuids, uuid)
+	}
+
+	more = len(uuids) > SYNC_PAGINATION
+	uuids = uuids[0:min(SYNC_PAGINATION, len(uuids))]
+
+	return
+} // }}}
+func FileMetadata(userID int, uuid string) (f File, err error) { // {{{
+	row := db.QueryRowx(`SELECT * FROM public.file WHERE user_id = $1 AND "uuid" = $2`, userID, uuid)
+	err = row.StructScan(&f)
+	return
+
+} // }}}
+func FileForUser(userID int, uuid string) (f *os.File, md File, err error) { // {{{
+	row := db.QueryRowx(`SELECT * FROM public.file WHERE user_id = $1 AND "uuid" = $2`, userID, uuid)
+	err = row.StructScan(&md)
+	if err != nil {
+		return
+	}
+
+	_, fpath := FileIDToPath(md.ID)
+	f, err = os.OpenFile(fpath, os.O_RDONLY, 0600)
+	return
+
+} // }}}
 
 // vim: foldmethod=marker
diff --git a/main.go b/main.go
index 6e3cf94..ff935ad 100644
--- a/main.go
+++ b/main.go
@@ -5,7 +5,6 @@ import (
 	"notes2/authentication"
 	"notes2/html_template"
 	appUser "notes2/user"
-	"os"
 
 	// Standard
 	"bufio"
@@ -17,14 +16,16 @@ import (
 	"io"
 	"log/slog"
 	"net/http"
+	"os"
 	"path"
 	"regexp"
 	"strconv"
 	"strings"
 	"text/template"
+	"time"
 )
 
-const VERSION = "v29"
+const VERSION = "v30"
 const CONTEXT_USER = 1
 const SYNC_PAGINATION = 200
 
@@ -71,7 +72,7 @@ func init() { // {{{
 } // }}}
 func initLog() { // {{{
 	opts := slog.HandlerOptions{}
-	opts.Level = slog.LevelDebug
+	opts.Level = slog.LevelInfo
 	Log = slog.New(slog.NewJSONHandler(os.Stdout, &opts))
 } // }}}
 func main() { // {{{
@@ -141,11 +142,17 @@ func main() { // {{{
 	http.HandleFunc("/sync/from_server/count/{sequence}", authenticated(actionSyncFromServerCount))
 	http.HandleFunc("/sync/from_server/{sequence}/{offset}", authenticated(actionSyncFromServer))
 	http.HandleFunc("/sync/to_server", authenticated(actionSyncToServer))
+	http.HandleFunc("/sync/file/upload/{uuid}", authenticated(actionSyncFileUpload))
 
 	http.HandleFunc("/node/retrieve/{uuid}", authenticated(actionNodeRetrieve))
 	http.HandleFunc("/node/history/retrieve/{uuid}/{offset}", authenticated(actionNodeHistoryRetrieve))
 	http.HandleFunc("/node/history/count/{uuid}", authenticated(actionNodeHistoryCount))
 
+	http.HandleFunc("/file/count", authenticated(actionFileCount))
+	http.HandleFunc("/file/server_uuids/{offset}", authenticated(actionFileServerUUIDs))
+	http.HandleFunc("/file/uuid/{uuid}", authenticated(actionFile))
+	http.HandleFunc("/file/uuid/{uuid}/metadata", authenticated(actionFileMetadata))
+
 	http.HandleFunc("/service_worker.js", pageServiceWorker)
 
 	listen := fmt.Sprintf("%s:%d", config.Network.Address, config.Network.Port)
@@ -166,6 +173,11 @@ func authenticated(fn func(http.ResponseWriter, *http.Request)) func(http.Respon
 
 		// The Bearer token is extracted.
 		authHeader := r.Header.Get("Authorization")
+
+		if authHeader == "" {
+			authHeader = "Bearer " + r.URL.Query().Get("jwt")
+		}
+
 		authParts := RxpBearerToken.FindStringSubmatch(authHeader)
 		if len(authParts) != 2 {
 			failed(fmt.Errorf("Authorization missing or invalid"))
@@ -391,6 +403,63 @@ func actionSyncToServer(w http.ResponseWriter, r *http.Request) { // {{{
 		"OK": true,
 	})
 } // }}}
+func actionSyncFileUpload(w http.ResponseWriter, r *http.Request) { // {{{
+	uuid := r.PathValue("uuid")
+	session := getUserSession(r)
+
+	sentBytes, _ := strconv.Atoi(r.Header.Get("X-File-Sent-Bytes"))
+	totalBytes, _ := strconv.Atoi(r.Header.Get("X-File-Total-Bytes"))
+
+	// First block comes with file metadata.
+	file := File{}
+	if sentBytes == 0 {
+		file.UUID = uuid
+		file.Name = r.Header.Get("X-File-Name")
+		file.Size, _ = strconv.Atoi(r.Header.Get("X-File-Size"))
+		file.Type = r.Header.Get("X-File-Type")
+		modded, _ := strconv.ParseInt(r.Header.Get("X-File-Modified"), 10, 64)
+		file.Modified = time.UnixMilli(modded)
+		err := AddFileToDb(session.UserID, &file)
+		if err != nil {
+			Log.Error("upload", "op", "AddFileToDB", "error", err)
+			httpError(w, err)
+			return
+		}
+		fileUUIDCache[uuid] = file.ID
+	}
+
+	data, _ := io.ReadAll(r.Body)
+	var err error
+
+	switch sentBytes {
+	case 0:
+		// First block of data.
+		Log.Info("file_upload", "status", "new", "user", session.UserID, "uuid", uuid, "total", totalBytes)
+		id := fileUUIDCache[uuid]
+		err = FileWriteData(session.UserID, id, data, true)
+
+	case totalBytes:
+		// Last block of data - sent with 0 length data.
+		Log.Info("file_upload", "status", "done", "user", session.UserID, "uuid", uuid, "total", totalBytes)
+		id := fileUUIDCache[uuid]
+		delete(fileUUIDCache, uuid)
+		_, err = db.Exec(`UPDATE public.file SET upload_complete = true WHERE id = $1`, id) 
+
+	default:
+		id := fileUUIDCache[uuid]
+		err = FileWriteData(session.UserID, id, data, false)
+	}
+
+	if err != nil {
+		Log.Error("upload", "error", err)
+		httpError(w, err)
+		return
+	}
+
+	responseData(w, map[string]any{
+		"OK": true,
+	})
+} // }}}
 
 func actionUserGetPreferences(w http.ResponseWriter, r *http.Request) { // {{{
 	user := getUserSession(r)
@@ -433,6 +502,65 @@ func actionUserSetPreferences(w http.ResponseWriter, r *http.Request) { // {{{
 	})
 } // }}}
 
+func actionFileCount(w http.ResponseWriter, r *http.Request) {// {{{
+	session := getUserSession(r)
+	count, err := FileCountForUser(session.UserID)
+	if err != nil {
+		Log.Error("file_count", "error", err)
+		httpError(w, err)
+		return
+	}
+
+	responseData(w, map[string]any{
+		"OK": true,
+		"Count": count,
+	})
+}// }}}
+func actionFileServerUUIDs(w http.ResponseWriter, r *http.Request) {// {{{
+	session := getUserSession(r)
+	offset, _ := strconv.Atoi(r.PathValue("offset"))
+	uuids, more, err := FileServerUUIDsForUser(session.UserID, offset)
+	if err != nil {
+		Log.Error("file_server_uuids", "error", err)
+		httpError(w, err)
+		return
+	}
+
+	responseData(w, map[string]any{
+		"OK": true,
+		"UUIDs": uuids,
+		"MoreRowsExist": more,
+	})
+}// }}}
+func actionFile(w http.ResponseWriter, r *http.Request) {// {{{
+	uuid := r.PathValue("uuid")
+	session := getUserSession(r)
+	f, md, err := FileForUser(session.UserID, uuid)
+	if err != nil {
+		Log.Error("file_metadata", "error", err)
+		httpError(w, err)
+		return
+	}
+
+	http.ServeContent(w, r, md.Name, md.Modified, f)
+}// }}}
+func actionFileMetadata(w http.ResponseWriter, r *http.Request) {// {{{
+	uuid := r.PathValue("uuid")
+	session := getUserSession(r)
+	md, err := FileMetadata(session.UserID, uuid)
+
+	if err != nil {
+		Log.Error("file_metadata", "error", err)
+		httpError(w, err)
+		return
+	}
+
+	responseData(w, map[string]any{
+		"OK": true,
+		"Metadata": md,
+	})
+}// }}}
+
 func createNewUser(username string) { // {{{
 	reader := bufio.NewReader(os.Stdin)
 
diff --git a/node.go b/node.go
index a25c771..15f277b 100644
--- a/node.go
+++ b/node.go
@@ -57,67 +57,6 @@ type Node struct {
 	Special          bool
 }
 
-func NodeTree(userID, offset int, synced uint64) (nodes []TreeNode, maxSeq uint64, moreRowsExist bool, err error) { // {{{
-	const LIMIT = 100
-	var rows *sqlx.Rows
-	rows, err = db.Queryx(`
-		SELECT
-			uuid,
-			COALESCE(parent_uuid, '') AS parent_uuid,
-			name,
-			created,
-			updated,
-			deleted IS NOT NULL AS deleted,
-			created_seq,
-			updated_seq,
-			deleted_seq
-		FROM
-			public.node
-		WHERE
-			user_id = $1 AND 
-			(
-				created_seq > $4 OR
-				updated_seq > $4 OR
-				deleted_seq > $4
-			)
-		ORDER BY
-			created ASC
-		LIMIT $2 OFFSET $3
-		`,
-		userID,
-		LIMIT+1,
-		offset,
-		synced,
-	)
-	if err != nil {
-		return
-	}
-	defer rows.Close()
-
-	nodes = []TreeNode{}
-	numNodes := 0
-	for rows.Next() {
-		// Query selects up to one more row than the decided limit.
-		// Saves one SQL query for row counting.
-		// Thus if numNodes is larger than the limit, more rows exist for the next call.
-		numNodes++
-		if numNodes > LIMIT {
-			moreRowsExist = true
-			return
-		}
-
-		node := TreeNode{}
-		if err = rows.StructScan(&node); err != nil {
-			return
-		}
-		nodes = append(nodes, node)
-
-		// DeletedSeq will be 0 if invalid, and thus not be a problem for the max function.
-		maxSeq = max(maxSeq, node.CreatedSeq, node.UpdatedSeq, uint64(node.DeletedSeq.Int64))
-	}
-
-	return
-} // }}}
 func Nodes(userID, offset int, synced uint64, clientUUID string) (nodes []Node, maxSeq uint64, moreRowsExist bool, err error) { // {{{
 	var rows *sqlx.Rows
 	rows, err = db.Queryx(`
diff --git a/sql/00011.sql b/sql/00011.sql
new file mode 100644
index 0000000..f9efdbb
--- /dev/null
+++ b/sql/00011.sql
@@ -0,0 +1,13 @@
+CREATE TABLE public.file (
+	id serial NOT NULL,
+	user_id int4 NOT NULL,
+	uuid uuid NOT NULL,
+	name varchar DEFAULT '' NOT NULL,
+	"size" int DEFAULT 0 NOT NULL,
+	"type" varchar DEFAULT 'application/octet-stream' NOT NULL,
+	modified timestamptz DEFAULT NOW() NOT NULL,
+	CONSTRAINT file_pk PRIMARY KEY (id),
+	CONSTRAINT file_user_fk FOREIGN KEY (user_id) REFERENCES public."user"(id) ON DELETE RESTRICT ON UPDATE RESTRICT
+);
+
+ALTER TABLE public.file ADD CONSTRAINT file_user_uuid_unique UNIQUE (user_id,"uuid");
diff --git a/sql/00012.sql b/sql/00012.sql
new file mode 100644
index 0000000..422d2cf
--- /dev/null
+++ b/sql/00012.sql
@@ -0,0 +1 @@
+ALTER TABLE public.file ADD upload_complete bool DEFAULT false NOT NULL;
diff --git a/sql/00013.sql b/sql/00013.sql
new file mode 100644
index 0000000..ef7e72c
--- /dev/null
+++ b/sql/00013.sql
@@ -0,0 +1,171 @@
+-- file_node_links Keeps tracks of the files referenced by each node.
+CREATE TABLE public.file_node_links (
+	file_uuid uuid NOT NULL,
+	node_uuid uuid NOT NULL,
+	user_id int4 NOT NULL,
+	CONSTRAINT file_node_pk PRIMARY KEY (file_uuid,node_uuid,user_id),
+	CONSTRAINT file_node_user_fk FOREIGN KEY (user_id) REFERENCES public."user"(id) ON DELETE CASCADE ON UPDATE CASCADE,
+	CONSTRAINT file_node_node_fk FOREIGN KEY (user_id,node_uuid) REFERENCES public.node(user_id,"uuid") ON DELETE CASCADE ON UPDATE CASCADE,
+	CONSTRAINT file_node_file_fk FOREIGN KEY (user_id,file_uuid) REFERENCES public.file(user_id,"uuid") ON DELETE CASCADE ON UPDATE CASCADE
+);
+
+-- add_nodes needs to call the new manage_node_file_links procedure.
+CREATE OR REPLACE PROCEDURE public.add_nodes(IN p_user_id integer, IN p_client_uuid uuid, IN p_nodes jsonb)
+ LANGUAGE plpgsql
+AS $procedure$
+
+DECLARE
+	node_data         jsonb;
+	node_updated      timestamptz;
+	db_updated        timestamptz;
+	db_uuid           uuid;
+	db_client         uuid;
+	db_history_uuid   uuid;
+	node_uuid         uuid;
+	node_parent_uuid  uuid;
+	node_history_uuid uuid;
+
+BEGIN
+	FOR node_data IN SELECT * FROM jsonb_array_elements(p_nodes)
+	LOOP
+		node_uuid         = (node_data->>'UUID')::uuid;
+		node_history_uuid = (node_data->>'HistoryUUID')::uuid;
+		node_updated      = (node_data->>'Updated')::timestamptz;
+
+
+
+		-- Frontend is using an all-zero UUID to define the root node.
+		-- Database is using NULL.
+		IF node_data->>'ParentUUID' = '00000000-0000-0000-0000-000000000000' OR node_data->>'ParentUUID' = '' THEN
+			node_parent_uuid = NULL;
+		ELSE
+			node_parent_uuid = (node_data->>'ParentUUID')::uuid;
+		END IF;
+
+		-- Safeguard against being your own parent.
+		IF node_uuid = node_parent_uuid THEN
+			RAISE EXCEPTION 'Node UUID is same as node parent UUID.' USING ERRCODE = 'XPRNT';
+		END IF;
+
+
+		-- Every jode has a new history UUID to keep the history entry uniquely identifiable
+		-- across clients. A history entry could potentially be sent again, but should be
+		-- safe to ignore as every change to a node should have a new history UUID.
+		--
+		-- The current node is also stored as history.
+		INSERT INTO node_history(
+			user_id, "uuid", "history_uuid", parents, created, updated,
+			"name", "content", "content_encrypted",
+			client
+		)
+		VALUES(
+			p_user_id, -- combined key
+			node_uuid, -- combined key
+			node_history_uuid, -- combined key
+			(jsonb_populate_record(null::json_ancestor_array, node_data))."Ancestors",
+			COALESCE((node_data->>'Created')::timestamptz, NOW()),
+			COALESCE((node_data->>'Updated')::timestamptz, NOW()),
+			(node_data->>'Name')::varchar,
+			(node_data->>'Content')::text,
+			'', /* content_encrypted */
+			p_client_uuid
+		)
+		ON CONFLICT ("user_id", "uuid", "history_uuid")
+		DO NOTHING;
+
+
+
+		-- Retrieve the current modified timestamp for this node from the database.
+		SELECT
+			uuid, updated, client
+		INTO
+			db_uuid, db_updated, db_client
+		FROM public."node"
+		WHERE
+			user_id = p_user_id AND
+			uuid::uuid = node_uuid::uuid;
+
+
+
+		-- Is the node not in database? It needs to be created.
+		IF db_uuid IS NULL THEN
+			RAISE NOTICE '01 New node %', node_uuid;
+
+			INSERT INTO public."node" (
+				user_id, "uuid", parent_uuid, created, updated,
+				"name", "content", "content_encrypted",
+				client
+			)
+			VALUES(
+				p_user_id,
+				node_uuid,
+				node_parent_uuid,
+				COALESCE((node_data->>'Created')::timestamptz, NOW()),
+				COALESCE((node_data->>'Updated')::timestamptz, NOW()),
+				(node_data->>'Name')::varchar,
+				(node_data->>'Content')::text,
+				'', /* content_encrypted */
+				p_client_uuid
+			);
+
+			-- Remove/insert file links for the newest content of this node.
+			CALL manage_node_file_links(p_user_id, node_uuid, (node_data->>'Content')::text);
+
+			CONTINUE;
+		END IF;
+
+
+
+		-- Update the public node as well if it was older than incoming node.
+		IF node_updated > db_updated THEN
+			UPDATE public."node"
+			SET
+				updated = (node_data->>'Updated')::timestamptz,
+				updated_seq = nextval('node_updates'),
+				parent_uuid = node_parent_uuid,
+				name = (node_data->>'Name')::varchar,
+				content = (node_data->>'Content')::text,
+				client = p_client_uuid
+			WHERE
+				user_id = p_user_id AND
+				uuid::uuid = node_uuid::uuid;
+
+			-- Remove/insert file links for the newest content of this node.
+			CALL manage_node_file_links(p_user_id, node_uuid, (node_data->>'Content')::text);
+		END IF;
+
+	END LOOP;
+END
+$procedure$
+;
+
+CREATE OR REPLACE PROCEDURE public.manage_node_file_links(IN p_user_id integer, IN p_node_uuid uuid, IN p_node_content text)
+LANGUAGE plpgsql
+AS $fn$
+BEGIN
+
+	-- Old file links are purged to get rid of deleted ones.
+	-- New links will be added from latest node update.
+	DELETE FROM file_node_links
+	WHERE
+		user_id = p_user_id AND
+		node_uuid = p_node_uuid;
+
+	-- db:// URLs are extracted from the content to manage them in a separate table.
+	WITH file_uuids AS (
+		SELECT regexp_matches(
+			p_node_content,
+			'db://([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})',
+			'g'
+		) AS file_uuid
+	) 
+	INSERT INTO file_node_links(user_id, node_uuid, file_uuid)
+	SELECT
+		p_user_id,
+		p_node_uuid,
+		(file_uuid[1])::uuid
+	FROM file_uuids;
+
+END
+$fn$
+;
diff --git a/static/images/icon_storage.svg b/static/images/icon_storage.svg
new file mode 100644
index 0000000..563d355
--- /dev/null
+++ b/static/images/icon_storage.svg
@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   width="21.333317"
+   height="24"
+   viewBox="0 0 5.64444 6.35"
+   version="1.1"
+   id="svg1"
+   inkscape:version="1.4.4 (dcaf3e7d9e, 2026-05-05)"
+   sodipodi:docname="icon_storage.svg"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <sodipodi:namedview
+     id="namedview1"
+     pagecolor="#ffffff"
+     bordercolor="#000000"
+     borderopacity="0.25"
+     inkscape:showpageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     inkscape:deskcolor="#d1d1d1"
+     inkscape:document-units="px"
+     inkscape:zoom="1"
+     inkscape:cx="-56"
+     inkscape:cy="-9.5"
+     inkscape:window-width="2190"
+     inkscape:window-height="1401"
+     inkscape:window-x="1463"
+     inkscape:window-y="0"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="layer1" />
+  <defs
+     id="defs1" />
+  <g
+     inkscape:label="Layer 1"
+     inkscape:groupmode="layer"
+     id="layer1"
+     transform="translate(-288.92499,-115.8875)">
+    <title
+       id="title1">database</title>
+    <path
+       d="m 291.74722,115.8875 c -1.55928,0 -2.82223,0.63146 -2.82223,1.4111 0,0.77964 1.26295,1.41112 2.82223,1.41112 1.55927,0 2.82221,-0.63148 2.82221,-1.41112 0,-0.77964 -1.26294,-1.4111 -2.82221,-1.4111 m -2.82223,2.11666 v 1.05834 c 0,0.77964 1.26295,1.4111 2.82223,1.4111 1.55927,0 2.82221,-0.63146 2.82221,-1.4111 v -1.05834 c 0,0.77964 -1.26294,1.41111 -2.82221,1.41111 -1.55928,0 -2.82223,-0.63147 -2.82223,-1.41111 m 0,1.7639 v 1.05833 c 0,0.77964 1.26295,1.41111 2.82223,1.41111 1.55927,0 2.82221,-0.63147 2.82221,-1.41111 v -1.05833 c 0,0.77964 -1.26294,1.4111 -2.82221,1.4111 -1.55928,0 -2.82223,-0.63146 -2.82223,-1.4111 z"
+       id="path1"
+       style="stroke-width:0.264583" />
+  </g>
+</svg>
diff --git a/static/js/api.mjs b/static/js/api.mjs
index 26a19de..9b53cbf 100644
--- a/static/js/api.mjs
+++ b/static/js/api.mjs
@@ -15,18 +15,61 @@ export class API {
 			const res = await fetch(path, { method, headers, body })
 			// An HTTP communication level error occured.
 			if (!res.ok || res.status != 200)
-				throw new Error('HTTP error', { cause: { type: 'http', error: res, }})
+				throw new Error('HTTP error', { cause: { type: 'http', error: res, } })
 
 			// Application level response are handled here.
 			const json = await res.json()
 			if (!json.OK)
-				throw new Error(json.Error, { cause: { type: 'application', application: json, }})
+				throw new Error(json.Error, { cause: { type: 'application', application: json, } })
+
+			return json
+		} catch (err) {
+			// Catch any other errors from fetch.
+			throw new Error(err.message, { cause: { type: 'http', error: err, } })
+		}
+	}
+
+	// Sends a block of binary data to server.
+	static async upload(uuid, data, sentBytes, metadata) {
+		try {
+			const path = `/sync/file/upload/${uuid}`
+			const headers = {
+				'X-File-Sent-Bytes': sentBytes,
+				'X-File-Total-Bytes': metadata.size,
+			}
+
+			// Metadata is needed for the database.
+			// No need to send it every block.
+			if (sentBytes === 0) {
+				headers['X-File-Name'] = metadata.name
+				headers['X-File-Size'] = metadata.size
+				headers['X-File-Type'] = metadata.type
+				headers['X-File-Modified'] = metadata.modified
+			}
+
+			// Authentication is done with a bearer token.
+			// Here provided to the backend if set.
+			const token = localStorage.getItem('token')
+			if (token) {
+				headers.Authorization = `Bearer ${token}`
+			}
+
+			const res = await fetch(path, { method: 'POST', headers, body: data })
+			// An HTTP communication level error occured.
+			if (!res.ok || res.status != 200)
+				throw new Error('HTTP error', { cause: { type: 'http', error: res, } })
+
+			// Application level response are handled here.
+			const json = await res.json()
+			if (!json.OK)
+				throw new Error(json.Error, { cause: { type: 'application', application: json, } })
 
 			return json
 
 		} catch (err) {
 			// Catch any other errors from fetch.
-			throw new Error(err.message, { cause: { type: 'http', error: err, }})
+			console.error(err)
+			throw new Error(err, { cause: { type: 'http', error: err } })
 		}
 	}
 
diff --git a/static/js/app.mjs b/static/js/app.mjs
index 90bad39..e44eabd 100644
--- a/static/js/app.mjs
+++ b/static/js/app.mjs
@@ -1,7 +1,6 @@
-import { ROOT_NODE } from 'node_store'
+import { ROOT_NODE, Node } from 'node_store'
 import { CustomHTMLElement } from './lib/custom_html_element.mjs'
 import { N2Sidebar } from 'sidebar'
-import { Node } from 'node'
 import { N2PreferenceSet } from './page_preferences.mjs'
 
 export class App {
@@ -66,11 +65,10 @@ export class App {
 
 		_mbus.subscribe('DEVICE_PREFERENCE_SET_UPDATED', ()=>{
 			this.preferences = this.getPreferences()
-			console.log(this.preferences.data)
 		})
 
-		window.addEventListener('keydown', event => this.keyHandler(event))
-		window.addEventListener('popstate', event => this.popState(event))
+		globalThis.addEventListener('keydown', event => this.keyHandler(event))
+		globalThis.addEventListener('popstate', event => this.popState(event))
 		document.getElementById('notes2').addEventListener('click', event => {
 			if (event.target.id === 'notes2')
 				document.getElementById('node-content')?.focus()
@@ -81,12 +79,12 @@ export class App {
 
 		_mbus.dispatch('SHOW_PAGE', { page: 'node' })
 
-		window._sync = new Sync()
+		globalThis._sync = new Sync()
 
 		// I think it is uncomfortable having the sync running as soon as the page load.
 		// I haven't gotten the time to look at the page before stuff jumps around.
 		// There a slight delay to initiate sync seems reasonable.
-		setTimeout(() => window._sync.run(), 1000)
+		setTimeout(() => globalThis._sync.run(), 1000)
 	}// }}}
 	keyHandler(event) {//{{{
 		let handled = true
diff --git a/static/js/crypto.mjs b/static/js/crypto.mjs
deleted file mode 100644
index 9aab255..0000000
--- a/static/js/crypto.mjs
+++ /dev/null
@@ -1,72 +0,0 @@
-export default class Crypto {
-	constructor(key) {//{{{
-		if(key === null)
-			throw new Error("No key provided")
-
-		if(typeof key === 'string')
-			this.key = sjcl.codec.base64.toBits(base64_key)
-		else
-			this.key = key
-
-		this.aes = new sjcl.cipher.aes(this.key)
-	}//}}}
-
-	static generate_key() {//{{{
-		return sjcl.random.randomWords(8)
-	}//}}}
-	static pass_to_key(pass, salt = null) {//{{{
-		if(salt === null)
-			salt = sjcl.random.randomWords(4) // 128 bits (16 bytes)
-		let key = sjcl.misc.pbkdf2(pass, salt, 10000)
-
-		return {
-			salt,
-			key,
-		}
-	}//}}}
-
-	encrypt(plaintext_data_in_bits, counter, return_encoded = true) {//{{{
-		// 8 bytes of random data, (1 word = 4 bytes) * 2
-		// with 8 bytes of byte encoded counter is used as
-		// IV to guarantee a non-repeated IV (which is a catastrophe).
-		// Assumes counter value is kept unique. Counter is taken from
-		// Postgres sequence.
-		let random_bits = sjcl.random.randomWords(2)
-		let iv_bytes = sjcl.codec.bytes.fromBits(random_bits)
-		for (let i = 0; i < 8; ++i) {
-			let mask = 0xffn << BigInt(i*8)
-			let counter_i_byte = (counter & mask) >> BigInt(i*8)
-			iv_bytes[15-i] = Number(counter_i_byte)
-		}
-		let iv = sjcl.codec.bytes.toBits(iv_bytes)
-
-		let encrypted = sjcl.mode['ccm'].encrypt(
-			this.aes,
-			plaintext_data_in_bits,
-			iv,
-		)
-
-		// Returning 16 bytes (4 words) IV + encrypted data.
-		if(return_encoded)
-			return sjcl.codec.base64.fromBits(
-				iv.concat(encrypted)
-			)
-		else
-			return iv.concat(encrypted)
-	}//}}}
-	decrypt(encrypted_base64_data) {//{{{
-		try {
-			let encoded = sjcl.codec.base64.toBits(encrypted_base64_data)
-			let iv = encoded.slice(0, 4) // in words (4 bytes), not bytes
-			let encrypted_data = encoded.slice(4)
-			return sjcl.mode['ccm'].decrypt(this.aes, encrypted_data, iv)
-		} catch(err) {
-			if(err.message == `ccm: tag doesn't match`)
-				throw('Decryption failed')
-			else
-				throw(err)
-		}
-	}//}}}
-}
-
-// vim: foldmethod=marker
diff --git a/static/js/file.mjs b/static/js/file.mjs
index 4322218..8e3bb94 100644
--- a/static/js/file.mjs
+++ b/static/js/file.mjs
@@ -1,7 +1,8 @@
 import { CustomHTMLElement } from "./lib/custom_html_element.mjs";
+import { API } from 'api'
 
 export class N2File extends CustomHTMLElement {
-	static {
+	static {// {{{
 		this.tmpl = document.createElement('template')
 		this.tmpl.innerHTML = `
 			<style>
@@ -30,24 +31,64 @@ export class N2File extends CustomHTMLElement {
 			<img data-el="image" src="/images/${_VERSION}/file_icons/generic.svg">
 			<div data-el="filename"></div>
 		`
-	}
-	constructor() {
+	}// }}}
+	constructor() {// {{{
 		super(true)
 
+		this.streamLocalFile = false
+		this.uuid = null
+
 		this.addEventListener('click', event => {
 			event.preventDefault()
 			event.stopPropagation()
 
-			window.open(
-				URL.createObjectURL(this.file),
-				(event.ctrlKey || event.shiftKey) ? '_blank' : '_self',
-			)
+			// Download to disk.
+			if (event.shiftKey) {
+				this.downloadToDisk()
+				return
+			}
+
+			// Open in browser.
+			this.openInBrowser(event)
 		})
 
 		this.render()
-	}
+	}// }}}
+	openInBrowser(event) {// {{{
+		if (this.streamLocalFile)
+			window.open(
+				`/stream-local?uuid=${this.metadata.UUID}`,
+				event.ctrlKey ? '_blank' : '_self',
+			)
+		else {
+			const jwt = localStorage.getItem('token')
+			window.open(
+				`/file/uuid/${this.uuid}?jwt=${jwt}`,
+				event.ctrlKey ? '_blank' : '_self',
+			)
+		}
+	}// }}}
+	async downloadToDisk() {// {{{
+		try {
+			// TODO: implement download of remote content.
+			if (this.streamLocalFile === false)
+				throw new Error('This file is only available online. Download not implemented yet.')
 
-	async render() {
+			const handle = await window.showSaveFilePicker({
+				suggestedName: this.metadata.name,
+			})
+
+			const writable = await handle.createWritable()
+			const blobStream = await globalThis.nodeStore.fileSegments.getStream(this.uuid)
+			await blobStream.pipeTo(writable)
+		} catch (err) {
+			if (err.name == 'AbortError')
+				return
+			console.error(err)
+			alert(err.message)
+		}
+	}// }}}
+	async render() {// {{{
 		const src = this.getAttribute('src')
 
 		// N2's db:// URLs are fetched from IndexedDB.
@@ -56,26 +97,62 @@ export class N2File extends CustomHTMLElement {
 			// while Marked lib has to be returned a string when exiting this function.
 			// populateImg makes sure this returned img element exists and then populates it
 			// with the image from IndexedDB.
-			const file = await globalThis.nodeStore.files.get(src.slice(5))
-			if (!file)
-				return
-			this.file = file.file
+			const fileUUID = src.slice(5)
 
-			if (file.file.type.startsWith('image/'))
-				this.elImage.src = URL.createObjectURL(file.file)
-			else {
-				// Check for and use an existing MIME type icon.
-				// Place them in static/images/file_icons/ and replace the slash with an underscore.
-				const url = `/images/${_VERSION}/file_icons/${file.file.type.replaceAll('/', '_')}.svg`
-				const res = await fetch(url)
-				if (res.ok)
-					this.elImage.src = url
+			this.uuid = fileUUID
+			const md = await globalThis.nodeStore.filesMetadata.get(fileUUID)
 
-				this.elFilename.innerText = file.file.name
-				this.elFilename.style.display = 'block'
+			if (md) {
+				this.metadata = md
+				this.streamLocalFile = true
+				this.renderLocalFile(md)
+			} else {
+				/* <file> can be undefined when a node is retrieved but files aren't synced.
+				 * Try to show from server.
+				 *
+				 * Metadata is needed to know whether to display an image or the file representation. */
+				try {
+					const res = await API.query('GET', `/file/uuid/${fileUUID}/metadata`)
+					this.renderRemoteFile(res.Metadata)
+				} catch (err) {
+					console.error(err)
+				}
 			}
+
 		} else
+			// Probably an external URL.
 			this.elImage.src = src
-	}
+	}// }}}
+	async renderLocalFile(fileMetadata) {// {{{
+		if (fileMetadata.type.startsWith('image/'))
+			this.elImage.src = `/stream-local?uuid=${fileMetadata.UUID}`
+		else {
+			// Check for and use an existing MIME type icon.
+			// Place them in static/images/file_icons/ and replace the slash with an underscore.
+			const url = `/images/${_VERSION}/file_icons/${fileMetadata.type.replaceAll('/', '_')}.svg`
+			const res = await fetch(url)
+			if (res.ok)
+				this.elImage.src = url
+
+			this.elFilename.innerText = fileMetadata.name
+			this.elFilename.style.display = 'block'
+		}
+	}// }}}
+	async renderRemoteFile(md) {// {{{
+		if (md.Type.startsWith('image/')) {
+			const jwt = localStorage.getItem('token')
+			this.elImage.src = `/file/uuid/${md.UUID}?jwt=${jwt}`
+		} else {
+			// Check for and use an existing MIME type icon.
+			// Place them in static/images/file_icons/ and replace the slash with an underscore.
+			const url = `/images/${_VERSION}/file_icons/${md.Type.replaceAll('/', '_')}.svg`
+			const res = await fetch(url)
+			if (res.ok)
+				this.elImage.src = url
+
+			this.elFilename.innerText = md.Name
+			this.elFilename.style.display = 'block'
+		}
+	}// }}}
 }
 customElements.define('n2-file', N2File)
diff --git a/static/js/key.mjs b/static/js/key.mjs
deleted file mode 100644
index 1f8c40f..0000000
--- a/static/js/key.mjs
+++ /dev/null
@@ -1,240 +0,0 @@
-import { h, Component } from 'preact'
-import htm from 'htm'
-import Crypto from 'crypto'
-const html = htm.bind(h)
-
-export class Keys extends Component {
-	constructor(props) {//{{{
-		super(props)
-		this.state = {
-			create: false,
-		}
-
-		props.nodeui.retrieveKeys()
-	}//}}}
-	render({ nodeui }, { create }) {//{{{
-		let keys = nodeui.keys.value
-			.sort((a,b)=>{
-				if(a.description < b.description) return -1
-				if(a.description > b.description) return  1
-				return 0
-			})
-			.map(key=>
-				html`<${KeyComponent} key=${`key-${key.ID}`} model=${key} />`
-			)
-
-		let createButton = ''
-		let createComponents = ''
-		if(create) {
-			createComponents = html`
-			<div id="key-create">
-				<h2>New key</h2>
-
-				<div class="fields">
-					<input type="text" id="key-description" placeholder="Name" />
-
-					<input type="password" id="key-pass1" placeholder="Password" />
-					<input type="password" id="key-pass2" placeholder="Repeat password" />
-
-					<textarea id="key-key" placeholder="Key"></textarea>
-
-					<div>
-						<button class="generate" onclick=${()=>this.generateKey()}>Generate</button>
-						<button class="create" onclick=${()=>this.createKey()}>Create</button>
-					</div>
-				</div>
-			</div>
-			`
-		} else {
-			createButton = html`<div style="margin-top: 16px;"><button onclick=${()=>this.setState({ create: true })}>Create new key</button></div>`
-		}
-
-		return html`
-			<div id="keys">
-				<h1>Encryption keys</h1>
-				<p>
-					Unlock a key by clicking its name. Lock it by clicking it again.
-				</p>
-
-				<p>
-					Copy the key and store it in a very secure place to have a way to access notes
-					in case the password is forgotten, or database is corrupted.
-				</p>
-
-				<p>Click "View key" after unlocking it.</p>
-
-				${createButton}
-				${createComponents}
-
-				<h2>Keys</h2>
-				<div class="key-list">
-					${keys}
-				</div>
-			</div>`
-	}//}}}
-
-	generateKey() {//{{{
-		let keyTextarea = document.getElementById('key-key')
-		let key = sjcl.codec.hex.fromBits(Crypto.generate_key()).replace(/(....)/g, '$1 ').trim()
-		keyTextarea.value = key
-	}//}}}
-	validateNewKey() {//{{{
-		let keyDescription = document.getElementById('key-description').value
-		let keyTextarea = document.getElementById('key-key').value
-		let pass1 = document.getElementById('key-pass1').value
-		let pass2 = document.getElementById('key-pass2').value
-
-		if(keyDescription.trim() == '')
-			throw new Error('The key has to have a description')
-
-		if(pass1.trim() == '' || pass1.length < 4)
-			throw new Error('The password has to be at least 4 characters long.')
-
-		if(pass1 != pass2)
-			throw new Error(`Passwords doesn't match`)
-
-		let cleanKey = keyTextarea.replace(/\s+/g, '')
-		if(!cleanKey.match(/^[0-9a-f]{64}$/i))
-			throw new Error('Invalid key - has to be 64 characters of 0-9 and A-F')
-	}//}}}
-	createKey() {//{{{
-		try {
-			this.validateNewKey()
-
-			let description = document.getElementById('key-description').value
-			let keyAscii = document.getElementById('key-key').value
-			let pass1 = document.getElementById('key-pass1').value
-
-			// Key in hex taken from user.
-			let actual_key = sjcl.codec.hex.toBits(keyAscii.replace(/\s+/g, ''))
-
-			// Key generated from password, used to encrypt the actual key.
-			let pass_gen = Crypto.pass_to_key(pass1)
-
-			let crypto = new Crypto(pass_gen.key)
-			let encrypted_actual_key = crypto.encrypt(actual_key, 0x1n, false)
-
-			// Database value is salt + actual key, needed to generate the same key from the password.
-			let db_encoded = sjcl.codec.hex.fromBits(
-				pass_gen.salt.concat(encrypted_actual_key)
-			)
-
-			// Create on server.
-			window._app.current.request('/key/create', {
-				description,
-				key: db_encoded,
-			})
-			.then(res=>{
-				let key = new Key(res.Key, this.props.nodeui.keyCounter)
-				this.props.nodeui.keys.value = this.props.nodeui.keys.value.concat(key)
-			})
-			.catch(window._app.current.responseError)
-		} catch(err) {
-			alert(err.message)
-			return
-		}
-	}//}}}
-}
-
-export class Key {
-	constructor(data, counter_callback) {//{{{
-		this.ID           = data.ID
-		this.description  = data.Description
-		this.encryptedKey = data.Key
-		this.key          = null
-
-		this._counter_cbk = counter_callback
-
-		let hex_key = window.sessionStorage.getItem(`key-${this.ID}`)
-		if(hex_key)
-			this.key = sjcl.codec.hex.toBits(hex_key)
-	}//}}}
-	status() {//{{{
-		if(this.key === null)
-			return 'locked'
-		return 'unlocked'
-	}//}}}
-	lock() {//{{{
-		this.key = null
-		window.sessionStorage.removeItem(`key-${this.ID}`)
-	}//}}}
-	unlock(password) {//{{{
-		let db = sjcl.codec.hex.toBits(this.encryptedKey)
-		let salt = db.slice(0, 4)
-		let pass_key = Crypto.pass_to_key(password, salt)
-		let crypto = new Crypto(pass_key.key)
-		this.key = crypto.decrypt(sjcl.codec.base64.fromBits(db.slice(4)))
-		window.sessionStorage.setItem(`key-${this.ID}`, sjcl.codec.hex.fromBits(this.key))
-	}//}}}
-	async counter() {//{{{
-		return this._counter_cbk()
-	}//}}}
-}
-
-export class KeyComponent extends Component {
-	constructor({ model }) {//{{{
-		super({ model })
-		this.state = {
-			show_key: false,
-		}
-	}//}}}
-	render({ model }, { show_key }) {//{{{
-		let status = ''
-		switch(model.status()) {
-			case 'locked':
-				status = html`<div class="status locked"><img src="/images/${window._VERSION}/padlock-closed.svg" /></div>`
-				break
-
-			case 'unlocked':
-				status = html`<div class="status unlocked"><img src="/images/${window._VERSION}/padlock-open.svg" /></div>`
-				break
-		}
-
-		let hex_key = ''
-		if(show_key) {
-			if(model.status() == 'locked')
-				hex_key = html`<div class="hex-key">Unlock key first</div>`
-			else {
-				let key = sjcl.codec.hex.fromBits(model.key)
-				key = key.replace(/(....)/g, "$1 ").trim()
-				hex_key = html`<div class="hex-key">${key}</div>`
-			}
-		}
-
-		let unlocked = model.status()=='unlocked'
-
-		return html`
-			<div class="status" onclick=${()=>this.toggle()}>${status}</div>
-			<div class="description" onclick=${()=>this.toggle()}>${model.description}</div>
-			<div class="view" onclick=${()=>this.toggleViewKey()}>${unlocked ? 'View key' : ''}</div>
-			${hex_key}
-		`
-	}//}}}
-	toggle() {//{{{
-		if(this.props.model.status() == 'locked')
-			this.unlock()
-		else
-			this.lock()
-	}//}}}
-	lock() {//{{{
-		this.props.model.lock()
-		this.forceUpdate()
-	}//}}}
-	unlock() {//{{{
-		let pass = prompt("Password")
-		if(!pass)
-			return
-
-		try {
-			this.props.model.unlock(pass)
-			this.forceUpdate()
-		} catch(err) {
-			alert(err)
-		}
-	}//}}}
-	toggleViewKey() {//{{{
-		this.setState({ show_key: !this.state.show_key })
-	}//}}}
-}
-
-// vim: foldmethod=marker
diff --git a/static/js/lib/sjcl.js b/static/js/lib/sjcl.js
deleted file mode 100644
index b5a1021..0000000
--- a/static/js/lib/sjcl.js
+++ /dev/null
@@ -1,2574 +0,0 @@
-/** @fileOverview Javascript cryptography implementation.
- *
- * Crush to remove comments, shorten variable names and
- * generally reduce transmission size.
- *
- * @author Emily Stark
- * @author Mike Hamburg
- * @author Dan Boneh
- */
-
-"use strict";
-/*jslint indent: 2, bitwise: false, nomen: false, plusplus: false, white: false, regexp: false */
-/*global document, window, escape, unescape, module, require, Uint32Array */
-
-/**
- * The Stanford Javascript Crypto Library, top-level namespace.
- * @namespace
- */
-var sjcl = {
-  /**
-   * Symmetric ciphers.
-   * @namespace
-   */
-  cipher: {},
-
-  /**
-   * Hash functions.  Right now only SHA256 is implemented.
-   * @namespace
-   */
-  hash: {},
-
-  /**
-   * Key exchange functions.  Right now only SRP is implemented.
-   * @namespace
-   */
-  keyexchange: {},
-  
-  /**
-   * Cipher modes of operation.
-   * @namespace
-   */
-  mode: {},
-
-  /**
-   * Miscellaneous.  HMAC and PBKDF2.
-   * @namespace
-   */
-  misc: {},
-  
-  /**
-   * Bit array encoders and decoders.
-   * @namespace
-   *
-   * @description
-   * The members of this namespace are functions which translate between
-   * SJCL's bitArrays and other objects (usually strings).  Because it
-   * isn't always clear which direction is encoding and which is decoding,
-   * the method names are "fromBits" and "toBits".
-   */
-  codec: {},
-  
-  /**
-   * Exceptions.
-   * @namespace
-   */
-  exception: {
-    /**
-     * Ciphertext is corrupt.
-     * @constructor
-     */
-    corrupt: function(message) {
-      this.toString = function() { return "CORRUPT: "+this.message; };
-      this.message = message;
-    },
-    
-    /**
-     * Invalid parameter.
-     * @constructor
-     */
-    invalid: function(message) {
-      this.toString = function() { return "INVALID: "+this.message; };
-      this.message = message;
-    },
-    
-    /**
-     * Bug or missing feature in SJCL.
-     * @constructor
-     */
-    bug: function(message) {
-      this.toString = function() { return "BUG: "+this.message; };
-      this.message = message;
-    },
-
-    /**
-     * Something isn't ready.
-     * @constructor
-     */
-    notReady: function(message) {
-      this.toString = function() { return "NOT READY: "+this.message; };
-      this.message = message;
-    }
-  }
-};
-/** @fileOverview Low-level AES implementation.
- *
- * This file contains a low-level implementation of AES, optimized for
- * size and for efficiency on several browsers.  It is based on
- * OpenSSL's aes_core.c, a public-domain implementation by Vincent
- * Rijmen, Antoon Bosselaers and Paulo Barreto.
- *
- * An older version of this implementation is available in the public
- * domain, but this one is (c) Emily Stark, Mike Hamburg, Dan Boneh,
- * Stanford University 2008-2010 and BSD-licensed for liability
- * reasons.
- *
- * @author Emily Stark
- * @author Mike Hamburg
- * @author Dan Boneh
- */
-
-/**
- * Schedule out an AES key for both encryption and decryption.  This
- * is a low-level class.  Use a cipher mode to do bulk encryption.
- *
- * @constructor
- * @param {Array} key The key as an array of 4, 6 or 8 words.
- */
-sjcl.cipher.aes = function (key) {
-  if (!this._tables[0][0][0]) {
-    this._precompute();
-  }
-  
-  var i, j, tmp,
-    encKey, decKey,
-    sbox = this._tables[0][4], decTable = this._tables[1],
-    keyLen = key.length, rcon = 1;
-  
-  if (keyLen !== 4 && keyLen !== 6 && keyLen !== 8) {
-    throw new sjcl.exception.invalid("invalid aes key size");
-  }
-  
-  this._key = [encKey = key.slice(0), decKey = []];
-  
-  // schedule encryption keys
-  for (i = keyLen; i < 4 * keyLen + 28; i++) {
-    tmp = encKey[i-1];
-    
-    // apply sbox
-    if (i%keyLen === 0 || (keyLen === 8 && i%keyLen === 4)) {
-      tmp = sbox[tmp>>>24]<<24 ^ sbox[tmp>>16&255]<<16 ^ sbox[tmp>>8&255]<<8 ^ sbox[tmp&255];
-      
-      // shift rows and add rcon
-      if (i%keyLen === 0) {
-        tmp = tmp<<8 ^ tmp>>>24 ^ rcon<<24;
-        rcon = rcon<<1 ^ (rcon>>7)*283;
-      }
-    }
-    
-    encKey[i] = encKey[i-keyLen] ^ tmp;
-  }
-  
-  // schedule decryption keys
-  for (j = 0; i; j++, i--) {
-    tmp = encKey[j&3 ? i : i - 4];
-    if (i<=4 || j<4) {
-      decKey[j] = tmp;
-    } else {
-      decKey[j] = decTable[0][sbox[tmp>>>24      ]] ^
-                  decTable[1][sbox[tmp>>16  & 255]] ^
-                  decTable[2][sbox[tmp>>8   & 255]] ^
-                  decTable[3][sbox[tmp      & 255]];
-    }
-  }
-};
-
-sjcl.cipher.aes.prototype = {
-  // public
-  /* Something like this might appear here eventually
-  name: "AES",
-  blockSize: 4,
-  keySizes: [4,6,8],
-  */
-  
-  /**
-   * Encrypt an array of 4 big-endian words.
-   * @param {Array} data The plaintext.
-   * @return {Array} The ciphertext.
-   */
-  encrypt:function (data) { return this._crypt(data,0); },
-  
-  /**
-   * Decrypt an array of 4 big-endian words.
-   * @param {Array} data The ciphertext.
-   * @return {Array} The plaintext.
-   */
-  decrypt:function (data) { return this._crypt(data,1); },
-  
-  /**
-   * The expanded S-box and inverse S-box tables.  These will be computed
-   * on the client so that we don't have to send them down the wire.
-   *
-   * There are two tables, _tables[0] is for encryption and
-   * _tables[1] is for decryption.
-   *
-   * The first 4 sub-tables are the expanded S-box with MixColumns.  The
-   * last (_tables[01][4]) is the S-box itself.
-   *
-   * @private
-   */
-  _tables: [[[],[],[],[],[]],[[],[],[],[],[]]],
-
-  /**
-   * Expand the S-box tables.
-   *
-   * @private
-   */
-  _precompute: function () {
-   var encTable = this._tables[0], decTable = this._tables[1],
-       sbox = encTable[4], sboxInv = decTable[4],
-       i, x, xInv, d=[], th=[], x2, x4, x8, s, tEnc, tDec;
-
-    // Compute double and third tables
-   for (i = 0; i < 256; i++) {
-     th[( d[i] = i<<1 ^ (i>>7)*283 )^i]=i;
-   }
-   
-   for (x = xInv = 0; !sbox[x]; x ^= x2 || 1, xInv = th[xInv] || 1) {
-     // Compute sbox
-     s = xInv ^ xInv<<1 ^ xInv<<2 ^ xInv<<3 ^ xInv<<4;
-     s = s>>8 ^ s&255 ^ 99;
-     sbox[x] = s;
-     sboxInv[s] = x;
-     
-     // Compute MixColumns
-     x8 = d[x4 = d[x2 = d[x]]];
-     tDec = x8*0x1010101 ^ x4*0x10001 ^ x2*0x101 ^ x*0x1010100;
-     tEnc = d[s]*0x101 ^ s*0x1010100;
-     
-     for (i = 0; i < 4; i++) {
-       encTable[i][x] = tEnc = tEnc<<24 ^ tEnc>>>8;
-       decTable[i][s] = tDec = tDec<<24 ^ tDec>>>8;
-     }
-   }
-   
-   // Compactify.  Considerable speedup on Firefox.
-   for (i = 0; i < 5; i++) {
-     encTable[i] = encTable[i].slice(0);
-     decTable[i] = decTable[i].slice(0);
-   }
-  },
-  
-  /**
-   * Encryption and decryption core.
-   * @param {Array} input Four words to be encrypted or decrypted.
-   * @param dir The direction, 0 for encrypt and 1 for decrypt.
-   * @return {Array} The four encrypted or decrypted words.
-   * @private
-   */
-  _crypt:function (input, dir) {
-    if (input.length !== 4) {
-      throw new sjcl.exception.invalid("invalid aes block size");
-    }
-    
-    var key = this._key[dir],
-        // state variables a,b,c,d are loaded with pre-whitened data
-        a = input[0]           ^ key[0],
-        b = input[dir ? 3 : 1] ^ key[1],
-        c = input[2]           ^ key[2],
-        d = input[dir ? 1 : 3] ^ key[3],
-        a2, b2, c2,
-        
-        nInnerRounds = key.length/4 - 2,
-        i,
-        kIndex = 4,
-        out = [0,0,0,0],
-        table = this._tables[dir],
-        
-        // load up the tables
-        t0    = table[0],
-        t1    = table[1],
-        t2    = table[2],
-        t3    = table[3],
-        sbox  = table[4];
- 
-    // Inner rounds.  Cribbed from OpenSSL.
-    for (i = 0; i < nInnerRounds; i++) {
-      a2 = t0[a>>>24] ^ t1[b>>16 & 255] ^ t2[c>>8 & 255] ^ t3[d & 255] ^ key[kIndex];
-      b2 = t0[b>>>24] ^ t1[c>>16 & 255] ^ t2[d>>8 & 255] ^ t3[a & 255] ^ key[kIndex + 1];
-      c2 = t0[c>>>24] ^ t1[d>>16 & 255] ^ t2[a>>8 & 255] ^ t3[b & 255] ^ key[kIndex + 2];
-      d  = t0[d>>>24] ^ t1[a>>16 & 255] ^ t2[b>>8 & 255] ^ t3[c & 255] ^ key[kIndex + 3];
-      kIndex += 4;
-      a=a2; b=b2; c=c2;
-    }
-        
-    // Last round.
-    for (i = 0; i < 4; i++) {
-      out[dir ? 3&-i : i] =
-        sbox[a>>>24      ]<<24 ^ 
-        sbox[b>>16  & 255]<<16 ^
-        sbox[c>>8   & 255]<<8  ^
-        sbox[d      & 255]     ^
-        key[kIndex++];
-      a2=a; a=b; b=c; c=d; d=a2;
-    }
-    
-    return out;
-  }
-};
-
-/** @fileOverview Arrays of bits, encoded as arrays of Numbers.
- *
- * @author Emily Stark
- * @author Mike Hamburg
- * @author Dan Boneh
- */
-
-/**
- * Arrays of bits, encoded as arrays of Numbers.
- * @namespace
- * @description
- * <p>
- * These objects are the currency accepted by SJCL's crypto functions.
- * </p>
- *
- * <p>
- * Most of our crypto primitives operate on arrays of 4-byte words internally,
- * but many of them can take arguments that are not a multiple of 4 bytes.
- * This library encodes arrays of bits (whose size need not be a multiple of 8
- * bits) as arrays of 32-bit words.  The bits are packed, big-endian, into an
- * array of words, 32 bits at a time.  Since the words are double-precision
- * floating point numbers, they fit some extra data.  We use this (in a private,
- * possibly-changing manner) to encode the number of bits actually  present
- * in the last word of the array.
- * </p>
- *
- * <p>
- * Because bitwise ops clear this out-of-band data, these arrays can be passed
- * to ciphers like AES which want arrays of words.
- * </p>
- */
-sjcl.bitArray = {
-  /**
-   * Array slices in units of bits.
-   * @param {bitArray} a The array to slice.
-   * @param {Number} bstart The offset to the start of the slice, in bits.
-   * @param {Number} bend The offset to the end of the slice, in bits.  If this is undefined,
-   * slice until the end of the array.
-   * @return {bitArray} The requested slice.
-   */
-  bitSlice: function (a, bstart, bend) {
-    a = sjcl.bitArray._shiftRight(a.slice(bstart/32), 32 - (bstart & 31)).slice(1);
-    return (bend === undefined) ? a : sjcl.bitArray.clamp(a, bend-bstart);
-  },
-
-  /**
-   * Extract a number packed into a bit array.
-   * @param {bitArray} a The array to slice.
-   * @param {Number} bstart The offset to the start of the slice, in bits.
-   * @param {Number} blength The length of the number to extract.
-   * @return {Number} The requested slice.
-   */
-  extract: function(a, bstart, blength) {
-    // FIXME: this Math.floor is not necessary at all, but for some reason
-    // seems to suppress a bug in the Chromium JIT.
-    var x, sh = Math.floor((-bstart-blength) & 31);
-    if ((bstart + blength - 1 ^ bstart) & -32) {
-      // it crosses a boundary
-      x = (a[bstart/32|0] << (32 - sh)) ^ (a[bstart/32+1|0] >>> sh);
-    } else {
-      // within a single word
-      x = a[bstart/32|0] >>> sh;
-    }
-    return x & ((1<<blength) - 1);
-  },
-
-  /**
-   * Concatenate two bit arrays.
-   * @param {bitArray} a1 The first array.
-   * @param {bitArray} a2 The second array.
-   * @return {bitArray} The concatenation of a1 and a2.
-   */
-  concat: function (a1, a2) {
-    if (a1.length === 0 || a2.length === 0) {
-      return a1.concat(a2);
-    }
-    
-    var last = a1[a1.length-1], shift = sjcl.bitArray.getPartial(last);
-    if (shift === 32) {
-      return a1.concat(a2);
-    } else {
-      return sjcl.bitArray._shiftRight(a2, shift, last|0, a1.slice(0,a1.length-1));
-    }
-  },
-
-  /**
-   * Find the length of an array of bits.
-   * @param {bitArray} a The array.
-   * @return {Number} The length of a, in bits.
-   */
-  bitLength: function (a) {
-    var l = a.length, x;
-    if (l === 0) { return 0; }
-    x = a[l - 1];
-    return (l-1) * 32 + sjcl.bitArray.getPartial(x);
-  },
-
-  /**
-   * Truncate an array.
-   * @param {bitArray} a The array.
-   * @param {Number} len The length to truncate to, in bits.
-   * @return {bitArray} A new array, truncated to len bits.
-   */
-  clamp: function (a, len) {
-    if (a.length * 32 < len) { return a; }
-    a = a.slice(0, Math.ceil(len / 32));
-    var l = a.length;
-    len = len & 31;
-    if (l > 0 && len) {
-      a[l-1] = sjcl.bitArray.partial(len, a[l-1] & 0x80000000 >> (len-1), 1);
-    }
-    return a;
-  },
-
-  /**
-   * Make a partial word for a bit array.
-   * @param {Number} len The number of bits in the word.
-   * @param {Number} x The bits.
-   * @param {Number} [_end=0] Pass 1 if x has already been shifted to the high side.
-   * @return {Number} The partial word.
-   */
-  partial: function (len, x, _end) {
-    if (len === 32) { return x; }
-    return (_end ? x|0 : x << (32-len)) + len * 0x10000000000;
-  },
-
-  /**
-   * Get the number of bits used by a partial word.
-   * @param {Number} x The partial word.
-   * @return {Number} The number of bits used by the partial word.
-   */
-  getPartial: function (x) {
-    return Math.round(x/0x10000000000) || 32;
-  },
-
-  /**
-   * Compare two arrays for equality in a predictable amount of time.
-   * @param {bitArray} a The first array.
-   * @param {bitArray} b The second array.
-   * @return {boolean} true if a == b; false otherwise.
-   */
-  equal: function (a, b) {
-    if (sjcl.bitArray.bitLength(a) !== sjcl.bitArray.bitLength(b)) {
-      return false;
-    }
-    var x = 0, i;
-    for (i=0; i<a.length; i++) {
-      x |= a[i]^b[i];
-    }
-    return (x === 0);
-  },
-
-  /** Shift an array right.
-   * @param {bitArray} a The array to shift.
-   * @param {Number} shift The number of bits to shift.
-   * @param {Number} [carry=0] A byte to carry in
-   * @param {bitArray} [out=[]] An array to prepend to the output.
-   * @private
-   */
-  _shiftRight: function (a, shift, carry, out) {
-    var i, last2=0, shift2;
-    if (out === undefined) { out = []; }
-    
-    for (; shift >= 32; shift -= 32) {
-      out.push(carry);
-      carry = 0;
-    }
-    if (shift === 0) {
-      return out.concat(a);
-    }
-    
-    for (i=0; i<a.length; i++) {
-      out.push(carry | a[i]>>>shift);
-      carry = a[i] << (32-shift);
-    }
-    last2 = a.length ? a[a.length-1] : 0;
-    shift2 = sjcl.bitArray.getPartial(last2);
-    out.push(sjcl.bitArray.partial(shift+shift2 & 31, (shift + shift2 > 32) ? carry : out.pop(),1));
-    return out;
-  },
-  
-  /** xor a block of 4 words together.
-   * @private
-   */
-  _xor4: function(x,y) {
-    return [x[0]^y[0],x[1]^y[1],x[2]^y[2],x[3]^y[3]];
-  },
-
-  /** byteswap a word array inplace.
-   * (does not handle partial words)
-   * @param {sjcl.bitArray} a word array
-   * @return {sjcl.bitArray} byteswapped array
-   */
-  byteswapM: function(a) {
-    var i, v, m = 0xff00;
-    for (i = 0; i < a.length; ++i) {
-      v = a[i];
-      a[i] = (v >>> 24) | ((v >>> 8) & m) | ((v & m) << 8) | (v << 24);
-    }
-    return a;
-  }
-};
-/** @fileOverview Bit array codec implementations.
- *
- * @author Emily Stark
- * @author Mike Hamburg
- * @author Dan Boneh
- */
-
-/**
- * UTF-8 strings
- * @namespace
- */
-sjcl.codec.utf8String = {
-  /** Convert from a bitArray to a UTF-8 string. */
-  fromBits: function (arr) {
-    var out = "", bl = sjcl.bitArray.bitLength(arr), i, tmp;
-    for (i=0; i<bl/8; i++) {
-      if ((i&3) === 0) {
-        tmp = arr[i/4];
-      }
-      out += String.fromCharCode(tmp >>> 8 >>> 8 >>> 8);
-      tmp <<= 8;
-    }
-    return decodeURIComponent(escape(out));
-  },
-
-  /** Convert from a UTF-8 string to a bitArray. */
-  toBits: function (str) {
-    str = unescape(encodeURIComponent(str));
-    var out = [], i, tmp=0;
-    for (i=0; i<str.length; i++) {
-      tmp = tmp << 8 | str.charCodeAt(i);
-      if ((i&3) === 3) {
-        out.push(tmp);
-        tmp = 0;
-      }
-    }
-    if (i&3) {
-      out.push(sjcl.bitArray.partial(8*(i&3), tmp));
-    }
-    return out;
-  }
-};
-/** @fileOverview Bit array codec implementations.
- *
- * @author Emily Stark
- * @author Mike Hamburg
- * @author Dan Boneh
- */
-
-/**
- * Hexadecimal
- * @namespace
- */
-sjcl.codec.hex = {
-  /** Convert from a bitArray to a hex string. */
-  fromBits: function (arr) {
-    var out = "", i;
-    for (i=0; i<arr.length; i++) {
-      out += ((arr[i]|0)+0xF00000000000).toString(16).substr(4);
-    }
-    return out.substr(0, sjcl.bitArray.bitLength(arr)/4);//.replace(/(.{8})/g, "$1 ");
-  },
-  /** Convert from a hex string to a bitArray. */
-  toBits: function (str) {
-    var i, out=[], len;
-    str = str.replace(/\s|0x/g, "");
-    len = str.length;
-    str = str + "00000000";
-    for (i=0; i<str.length; i+=8) {
-      out.push(parseInt(str.substr(i,8),16)^0);
-    }
-    return sjcl.bitArray.clamp(out, len*4);
-  }
-};
-
-/** @fileOverview Bit array codec implementations.
- *
- * @author Nils Kenneweg
- */
-
-/**
- * Base32 encoding/decoding
- * @namespace
- */
-sjcl.codec.base32 = {
-  /** The base32 alphabet.
-   * @private
-   */
-  _chars: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567",
-  _hexChars: "0123456789ABCDEFGHIJKLMNOPQRSTUV",
-
-  /* bits in an array */
-  BITS: 32,
-  /* base to encode at (2^x) */
-  BASE: 5,
-  /* bits - base */
-  REMAINING: 27,
-
-  /** Convert from a bitArray to a base32 string. */
-  fromBits: function (arr, _noEquals, _hex) {
-    var BITS = sjcl.codec.base32.BITS, BASE = sjcl.codec.base32.BASE, REMAINING = sjcl.codec.base32.REMAINING;
-    var out = "", i, bits=0, c = sjcl.codec.base32._chars, ta=0, bl = sjcl.bitArray.bitLength(arr);
-
-    if (_hex) {
-      c = sjcl.codec.base32._hexChars;
-    }
-
-    for (i=0; out.length * BASE < bl; ) {
-      out += c.charAt((ta ^ arr[i]>>>bits) >>> REMAINING);
-      if (bits < BASE) {
-        ta = arr[i] << (BASE-bits);
-        bits += REMAINING;
-        i++;
-      } else {
-        ta <<= BASE;
-        bits -= BASE;
-      }
-    }
-    while ((out.length & 7) && !_noEquals) { out += "="; }
-
-    return out;
-  },
-
-  /** Convert from a base32 string to a bitArray */
-  toBits: function(str, _hex) {
-    str = str.replace(/\s|=/g,'').toUpperCase();
-    var BITS = sjcl.codec.base32.BITS, BASE = sjcl.codec.base32.BASE, REMAINING = sjcl.codec.base32.REMAINING;
-    var out = [], i, bits=0, c = sjcl.codec.base32._chars, ta=0, x, format="base32";
-
-    if (_hex) {
-      c = sjcl.codec.base32._hexChars;
-      format = "base32hex";
-    }
-
-    for (i=0; i<str.length; i++) {
-      x = c.indexOf(str.charAt(i));
-      if (x < 0) {
-        // Invalid character, try hex format
-        if (!_hex) {
-          try {
-            return sjcl.codec.base32hex.toBits(str);
-          }
-          catch (e) {}
-        }
-        throw new sjcl.exception.invalid("this isn't " + format + "!");
-      }
-      if (bits > REMAINING) {
-        bits -= REMAINING;
-        out.push(ta ^ x>>>bits);
-        ta  = x << (BITS-bits);
-      } else {
-        bits += BASE;
-        ta ^= x << (BITS-bits);
-      }
-    }
-    if (bits&56) {
-      out.push(sjcl.bitArray.partial(bits&56, ta, 1));
-    }
-    return out;
-  }
-};
-
-sjcl.codec.base32hex = {
-  fromBits: function (arr, _noEquals) { return sjcl.codec.base32.fromBits(arr,_noEquals,1); },
-  toBits: function (str) { return sjcl.codec.base32.toBits(str,1); }
-};
-/** @fileOverview Bit array codec implementations.
- *
- * @author Emily Stark
- * @author Mike Hamburg
- * @author Dan Boneh
- */
-
-/**
- * Base64 encoding/decoding 
- * @namespace
- */
-sjcl.codec.base64 = {
-  /** The base64 alphabet.
-   * @private
-   */
-  _chars: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
-  
-  /** Convert from a bitArray to a base64 string. */
-  fromBits: function (arr, _noEquals, _url) {
-    var out = "", i, bits=0, c = sjcl.codec.base64._chars, ta=0, bl = sjcl.bitArray.bitLength(arr);
-    if (_url) {
-      c = c.substr(0,62) + '-_';
-    }
-    for (i=0; out.length * 6 < bl; ) {
-      out += c.charAt((ta ^ arr[i]>>>bits) >>> 26);
-      if (bits < 6) {
-        ta = arr[i] << (6-bits);
-        bits += 26;
-        i++;
-      } else {
-        ta <<= 6;
-        bits -= 6;
-      }
-    }
-    while ((out.length & 3) && !_noEquals) { out += "="; }
-    return out;
-  },
-  
-  /** Convert from a base64 string to a bitArray */
-  toBits: function(str, _url) {
-    str = str.replace(/\s|=/g,'');
-    var out = [], i, bits=0, c = sjcl.codec.base64._chars, ta=0, x;
-    if (_url) {
-      c = c.substr(0,62) + '-_';
-    }
-    for (i=0; i<str.length; i++) {
-      x = c.indexOf(str.charAt(i));
-      if (x < 0) {
-        throw new sjcl.exception.invalid("this isn't base64!");
-      }
-      if (bits > 26) {
-        bits -= 26;
-        out.push(ta ^ x>>>bits);
-        ta  = x << (32-bits);
-      } else {
-        bits += 6;
-        ta ^= x << (32-bits);
-      }
-    }
-    if (bits&56) {
-      out.push(sjcl.bitArray.partial(bits&56, ta, 1));
-    }
-    return out;
-  }
-};
-
-sjcl.codec.base64url = {
-  fromBits: function (arr) { return sjcl.codec.base64.fromBits(arr,1,1); },
-  toBits: function (str) { return sjcl.codec.base64.toBits(str,1); }
-};
-/** @fileOverview Bit array codec implementations.
- *
- * @author Emily Stark
- * @author Mike Hamburg
- * @author Dan Boneh
- */
-
-/**
- * Arrays of bytes
- * @namespace
- */
-sjcl.codec.bytes = {
-  /** Convert from a bitArray to an array of bytes. */
-  fromBits: function (arr) {
-    var out = [], bl = sjcl.bitArray.bitLength(arr), i, tmp;
-    for (i=0; i<bl/8; i++) {
-      if ((i&3) === 0) {
-        tmp = arr[i/4];
-      }
-      out.push(tmp >>> 24);
-      tmp <<= 8;
-    }
-    return out;
-  },
-  /** Convert from an array of bytes to a bitArray. */
-  toBits: function (bytes) {
-    var out = [], i, tmp=0;
-    for (i=0; i<bytes.length; i++) {
-      tmp = tmp << 8 | bytes[i];
-      if ((i&3) === 3) {
-        out.push(tmp);
-        tmp = 0;
-      }
-    }
-    if (i&3) {
-      out.push(sjcl.bitArray.partial(8*(i&3), tmp));
-    }
-    return out;
-  }
-};
-/** @fileOverview Javascript SHA-256 implementation.
- *
- * An older version of this implementation is available in the public
- * domain, but this one is (c) Emily Stark, Mike Hamburg, Dan Boneh,
- * Stanford University 2008-2010 and BSD-licensed for liability
- * reasons.
- *
- * Special thanks to Aldo Cortesi for pointing out several bugs in
- * this code.
- *
- * @author Emily Stark
- * @author Mike Hamburg
- * @author Dan Boneh
- */
-
-/**
- * Context for a SHA-256 operation in progress.
- * @constructor
- */
-sjcl.hash.sha256 = function (hash) {
-  if (!this._key[0]) { this._precompute(); }
-  if (hash) {
-    this._h = hash._h.slice(0);
-    this._buffer = hash._buffer.slice(0);
-    this._length = hash._length;
-  } else {
-    this.reset();
-  }
-};
-
-/**
- * Hash a string or an array of words.
- * @static
- * @param {bitArray|String} data the data to hash.
- * @return {bitArray} The hash value, an array of 16 big-endian words.
- */
-sjcl.hash.sha256.hash = function (data) {
-  return (new sjcl.hash.sha256()).update(data).finalize();
-};
-
-sjcl.hash.sha256.prototype = {
-  /**
-   * The hash's block size, in bits.
-   * @constant
-   */
-  blockSize: 512,
-   
-  /**
-   * Reset the hash state.
-   * @return this
-   */
-  reset:function () {
-    this._h = this._init.slice(0);
-    this._buffer = [];
-    this._length = 0;
-    return this;
-  },
-  
-  /**
-   * Input several words to the hash.
-   * @param {bitArray|String} data the data to hash.
-   * @return this
-   */
-  update: function (data) {
-    if (typeof data === "string") {
-      data = sjcl.codec.utf8String.toBits(data);
-    }
-    var i, b = this._buffer = sjcl.bitArray.concat(this._buffer, data),
-        ol = this._length,
-        nl = this._length = ol + sjcl.bitArray.bitLength(data);
-    if (nl > 9007199254740991){
-      throw new sjcl.exception.invalid("Cannot hash more than 2^53 - 1 bits");
-    }
-
-    if (typeof Uint32Array !== 'undefined') {
-	var c = new Uint32Array(b);
-    	var j = 0;
-    	for (i = 512+ol - ((512+ol) & 511); i <= nl; i+= 512) {
-      	    this._block(c.subarray(16 * j, 16 * (j+1)));
-      	    j += 1;
-    	}
-    	b.splice(0, 16 * j);
-    } else {
-	for (i = 512+ol - ((512+ol) & 511); i <= nl; i+= 512) {
-      	    this._block(b.splice(0,16));
-      	}
-    }
-    return this;
-  },
-  
-  /**
-   * Complete hashing and output the hash value.
-   * @return {bitArray} The hash value, an array of 8 big-endian words.
-   */
-  finalize:function () {
-    var i, b = this._buffer, h = this._h;
-
-    // Round out and push the buffer
-    b = sjcl.bitArray.concat(b, [sjcl.bitArray.partial(1,1)]);
-    
-    // Round out the buffer to a multiple of 16 words, less the 2 length words.
-    for (i = b.length + 2; i & 15; i++) {
-      b.push(0);
-    }
-    
-    // append the length
-    b.push(Math.floor(this._length / 0x100000000));
-    b.push(this._length | 0);
-
-    while (b.length) {
-      this._block(b.splice(0,16));
-    }
-
-    this.reset();
-    return h;
-  },
-
-  /**
-   * The SHA-256 initialization vector, to be precomputed.
-   * @private
-   */
-  _init:[],
-  /*
-  _init:[0x6a09e667,0xbb67ae85,0x3c6ef372,0xa54ff53a,0x510e527f,0x9b05688c,0x1f83d9ab,0x5be0cd19],
-  */
-  
-  /**
-   * The SHA-256 hash key, to be precomputed.
-   * @private
-   */
-  _key:[],
-  /*
-  _key:
-    [0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
-     0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
-     0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
-     0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
-     0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
-     0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
-     0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
-     0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2],
-  */
-
-
-  /**
-   * Function to precompute _init and _key.
-   * @private
-   */
-  _precompute: function () {
-    var i = 0, prime = 2, factor, isPrime;
-
-    function frac(x) { return (x-Math.floor(x)) * 0x100000000 | 0; }
-
-    for (; i<64; prime++) {
-      isPrime = true;
-      for (factor=2; factor*factor <= prime; factor++) {
-        if (prime % factor === 0) {
-          isPrime = false;
-          break;
-        }
-      }
-      if (isPrime) {
-        if (i<8) {
-          this._init[i] = frac(Math.pow(prime, 1/2));
-        }
-        this._key[i] = frac(Math.pow(prime, 1/3));
-        i++;
-      }
-    }
-  },
-  
-  /**
-   * Perform one cycle of SHA-256.
-   * @param {Uint32Array|bitArray} w one block of words.
-   * @private
-   */
-  _block:function (w) {  
-    var i, tmp, a, b,
-      h = this._h,
-      k = this._key,
-      h0 = h[0], h1 = h[1], h2 = h[2], h3 = h[3],
-      h4 = h[4], h5 = h[5], h6 = h[6], h7 = h[7];
-
-    /* Rationale for placement of |0 :
-     * If a value can overflow is original 32 bits by a factor of more than a few
-     * million (2^23 ish), there is a possibility that it might overflow the
-     * 53-bit mantissa and lose precision.
-     *
-     * To avoid this, we clamp back to 32 bits by |'ing with 0 on any value that
-     * propagates around the loop, and on the hash state h[].  I don't believe
-     * that the clamps on h4 and on h0 are strictly necessary, but it's close
-     * (for h4 anyway), and better safe than sorry.
-     *
-     * The clamps on h[] are necessary for the output to be correct even in the
-     * common case and for short inputs.
-     */
-    for (i=0; i<64; i++) {
-      // load up the input word for this round
-      if (i<16) {
-        tmp = w[i];
-      } else {
-        a   = w[(i+1 ) & 15];
-        b   = w[(i+14) & 15];
-        tmp = w[i&15] = ((a>>>7  ^ a>>>18 ^ a>>>3  ^ a<<25 ^ a<<14) + 
-                         (b>>>17 ^ b>>>19 ^ b>>>10 ^ b<<15 ^ b<<13) +
-                         w[i&15] + w[(i+9) & 15]) | 0;
-      }
-      
-      tmp = (tmp + h7 + (h4>>>6 ^ h4>>>11 ^ h4>>>25 ^ h4<<26 ^ h4<<21 ^ h4<<7) +  (h6 ^ h4&(h5^h6)) + k[i]); // | 0;
-      
-      // shift register
-      h7 = h6; h6 = h5; h5 = h4;
-      h4 = h3 + tmp | 0;
-      h3 = h2; h2 = h1; h1 = h0;
-
-      h0 = (tmp +  ((h1&h2) ^ (h3&(h1^h2))) + (h1>>>2 ^ h1>>>13 ^ h1>>>22 ^ h1<<30 ^ h1<<19 ^ h1<<10)) | 0;
-    }
-
-    h[0] = h[0]+h0 | 0;
-    h[1] = h[1]+h1 | 0;
-    h[2] = h[2]+h2 | 0;
-    h[3] = h[3]+h3 | 0;
-    h[4] = h[4]+h4 | 0;
-    h[5] = h[5]+h5 | 0;
-    h[6] = h[6]+h6 | 0;
-    h[7] = h[7]+h7 | 0;
-  }
-};
-
-
-/** @fileOverview CCM mode implementation.
- *
- * Special thanks to Roy Nicholson for pointing out a bug in our
- * implementation.
- *
- * @author Emily Stark
- * @author Mike Hamburg
- * @author Dan Boneh
- */
-
-/**
- * CTR mode with CBC MAC.
- * @namespace
- */
-sjcl.mode.ccm = {
-  /** The name of the mode.
-   * @constant
-   */
-  name: "ccm",
-  
-  _progressListeners: [],
-
-  listenProgress: function (cb) {
-    sjcl.mode.ccm._progressListeners.push(cb);
-  },
-
-  unListenProgress: function (cb) {
-    var index = sjcl.mode.ccm._progressListeners.indexOf(cb);
-    if (index > -1) {
-      sjcl.mode.ccm._progressListeners.splice(index, 1);
-    }
-  },
-
-  _callProgressListener: function (val) {
-    var p = sjcl.mode.ccm._progressListeners.slice(), i;
-
-    for (i = 0; i < p.length; i += 1) {
-      p[i](val);
-    }
-  },
-
-  /** Encrypt in CCM mode.
-   * @static
-   * @param {Object} prf The pseudorandom function.  It must have a block size of 16 bytes.
-   * @param {bitArray} plaintext The plaintext data.
-   * @param {bitArray} iv The initialization value.
-   * @param {bitArray} [adata=[]] The authenticated data.
-   * @param {Number} [tlen=64] the desired tag length, in bits.
-   * @return {bitArray} The encrypted data, an array of bytes.
-   */
-  encrypt: function(prf, plaintext, iv, adata, tlen) {
-    var L, out = plaintext.slice(0), tag, w=sjcl.bitArray, ivl = w.bitLength(iv) / 8, ol = w.bitLength(out) / 8;
-    tlen = tlen || 64;
-    adata = adata || [];
-    
-    if (ivl < 7) {
-      throw new sjcl.exception.invalid("ccm: iv must be at least 7 bytes");
-    }
-    
-    // compute the length of the length
-    for (L=2; L<4 && ol >>> 8*L; L++) {}
-    if (L < 15 - ivl) { L = 15-ivl; }
-    iv = w.clamp(iv,8*(15-L));
-    
-    // compute the tag
-    tag = sjcl.mode.ccm._computeTag(prf, plaintext, iv, adata, tlen, L);
-    
-    // encrypt
-    out = sjcl.mode.ccm._ctrMode(prf, out, iv, tag, tlen, L);
-    
-    return w.concat(out.data, out.tag);
-  },
-  
-  /** Decrypt in CCM mode.
-   * @static
-   * @param {Object} prf The pseudorandom function.  It must have a block size of 16 bytes.
-   * @param {bitArray} ciphertext The ciphertext data.
-   * @param {bitArray} iv The initialization value.
-   * @param {bitArray} [adata=[]] adata The authenticated data.
-   * @param {Number} [tlen=64] tlen the desired tag length, in bits.
-   * @return {bitArray} The decrypted data.
-   */
-  decrypt: function(prf, ciphertext, iv, adata, tlen) {
-    tlen = tlen || 64;
-    adata = adata || [];
-    var L,
-        w=sjcl.bitArray,
-        ivl = w.bitLength(iv) / 8,
-        ol = w.bitLength(ciphertext), 
-        out = w.clamp(ciphertext, ol - tlen),
-        tag = w.bitSlice(ciphertext, ol - tlen), tag2;
-    
-
-    ol = (ol - tlen) / 8;
-        
-    if (ivl < 7) {
-      throw new sjcl.exception.invalid("ccm: iv must be at least 7 bytes");
-    }
-    
-    // compute the length of the length
-    for (L=2; L<4 && ol >>> 8*L; L++) {}
-    if (L < 15 - ivl) { L = 15-ivl; }
-    iv = w.clamp(iv,8*(15-L));
-    
-    // decrypt
-    out = sjcl.mode.ccm._ctrMode(prf, out, iv, tag, tlen, L);
-    
-    // check the tag
-    tag2 = sjcl.mode.ccm._computeTag(prf, out.data, iv, adata, tlen, L);
-    if (!w.equal(out.tag, tag2)) {
-      throw new sjcl.exception.corrupt("ccm: tag doesn't match");
-    }
-    
-    return out.data;
-  },
-
-  _macAdditionalData: function (prf, adata, iv, tlen, ol, L) {
-    var mac, tmp, i, macData = [], w=sjcl.bitArray, xor = w._xor4;
-
-    // mac the flags
-    mac = [w.partial(8, (adata.length ? 1<<6 : 0) | (tlen-2) << 2 | L-1)];
-
-    // mac the iv and length
-    mac = w.concat(mac, iv);
-    mac[3] |= ol;
-    mac = prf.encrypt(mac);
-  
-    if (adata.length) {
-      // mac the associated data.  start with its length...
-      tmp = w.bitLength(adata)/8;
-      if (tmp <= 0xFEFF) {
-        macData = [w.partial(16, tmp)];
-      } else if (tmp <= 0xFFFFFFFF) {
-        macData = w.concat([w.partial(16,0xFFFE)], [tmp]);
-      } // else ...
-    
-      // mac the data itself
-      macData = w.concat(macData, adata);
-      for (i=0; i<macData.length; i += 4) {
-        mac = prf.encrypt(xor(mac, macData.slice(i,i+4).concat([0,0,0])));
-      }
-    }
-
-    return mac;
-  },
-
-  /* Compute the (unencrypted) authentication tag, according to the CCM specification
-   * @param {Object} prf The pseudorandom function.
-   * @param {bitArray} plaintext The plaintext data.
-   * @param {bitArray} iv The initialization value.
-   * @param {bitArray} adata The authenticated data.
-   * @param {Number} tlen the desired tag length, in bits.
-   * @return {bitArray} The tag, but not yet encrypted.
-   * @private
-   */
-  _computeTag: function(prf, plaintext, iv, adata, tlen, L) {
-    // compute B[0]
-    var mac, i, w=sjcl.bitArray, xor = w._xor4;
-
-    tlen /= 8;
-  
-    // check tag length and message length
-    if (tlen % 2 || tlen < 4 || tlen > 16) {
-      throw new sjcl.exception.invalid("ccm: invalid tag length");
-    }
-  
-    if (adata.length > 0xFFFFFFFF || plaintext.length > 0xFFFFFFFF) {
-      // I don't want to deal with extracting high words from doubles.
-      throw new sjcl.exception.bug("ccm: can't deal with 4GiB or more data");
-    }
-
-    mac = sjcl.mode.ccm._macAdditionalData(prf, adata, iv, tlen, w.bitLength(plaintext)/8, L);
-
-    // mac the plaintext
-    for (i=0; i<plaintext.length; i+=4) {
-      mac = prf.encrypt(xor(mac, plaintext.slice(i,i+4).concat([0,0,0])));
-    }
-
-    return w.clamp(mac, tlen * 8);
-  },
-
-  /** CCM CTR mode.
-   * Encrypt or decrypt data and tag with the prf in CCM-style CTR mode.
-   * May mutate its arguments.
-   * @param {Object} prf The PRF.
-   * @param {bitArray} data The data to be encrypted or decrypted.
-   * @param {bitArray} iv The initialization vector.
-   * @param {bitArray} tag The authentication tag.
-   * @param {Number} tlen The length of th etag, in bits.
-   * @param {Number} L The CCM L value.
-   * @return {Object} An object with data and tag, the en/decryption of data and tag values.
-   * @private
-   */
-  _ctrMode: function(prf, data, iv, tag, tlen, L) {
-    var enc, i, w=sjcl.bitArray, xor = w._xor4, ctr, l = data.length, bl=w.bitLength(data), n = l/50, p = n;
-
-    // start the ctr
-    ctr = w.concat([w.partial(8,L-1)],iv).concat([0,0,0]).slice(0,4);
-    
-    // en/decrypt the tag
-    tag = w.bitSlice(xor(tag,prf.encrypt(ctr)), 0, tlen);
-  
-    // en/decrypt the data
-    if (!l) { return {tag:tag, data:[]}; }
-    
-    for (i=0; i<l; i+=4) {
-      if (i > n) {
-        sjcl.mode.ccm._callProgressListener(i/l);
-        n += p;
-      }
-      ctr[3]++;
-      enc = prf.encrypt(ctr);
-      data[i]   ^= enc[0];
-      data[i+1] ^= enc[1];
-      data[i+2] ^= enc[2];
-      data[i+3] ^= enc[3];
-    }
-    return { tag:tag, data:w.clamp(data,bl) };
-  }
-};
-/** @fileOverview OCB 2.0 implementation
- *
- * @author Emily Stark
- * @author Mike Hamburg
- * @author Dan Boneh
- */
-
-/** 
- * Phil Rogaway's Offset CodeBook mode, version 2.0.
- * May be covered by US and international patents.
- *
- * @namespace
- * @author Emily Stark
- * @author Mike Hamburg
- * @author Dan Boneh
- */
-sjcl.mode.ocb2 = {
-  /** The name of the mode.
-   * @constant
-   */
-  name: "ocb2",
-  
-  /** Encrypt in OCB mode, version 2.0.
-   * @param {Object} prp The block cipher.  It must have a block size of 16 bytes.
-   * @param {bitArray} plaintext The plaintext data.
-   * @param {bitArray} iv The initialization value.
-   * @param {bitArray} [adata=[]] The authenticated data.
-   * @param {Number} [tlen=64] the desired tag length, in bits.
-   * @param {boolean} [premac=false] true if the authentication data is pre-macced with PMAC.
-   * @return The encrypted data, an array of bytes.
-   * @throws {sjcl.exception.invalid} if the IV isn't exactly 128 bits.
-   */
-  encrypt: function(prp, plaintext, iv, adata, tlen, premac) {
-    if (sjcl.bitArray.bitLength(iv) !== 128) {
-      throw new sjcl.exception.invalid("ocb iv must be 128 bits");
-    }
-    var i,
-        times2 = sjcl.mode.ocb2._times2,
-        w = sjcl.bitArray,
-        xor = w._xor4,
-        checksum = [0,0,0,0],
-        delta = times2(prp.encrypt(iv)),
-        bi, bl,
-        output = [],
-        pad;
-        
-    adata = adata || [];
-    tlen  = tlen || 64;
-  
-    for (i=0; i+4 < plaintext.length; i+=4) {
-      /* Encrypt a non-final block */
-      bi = plaintext.slice(i,i+4);
-      checksum = xor(checksum, bi);
-      output = output.concat(xor(delta,prp.encrypt(xor(delta, bi))));
-      delta = times2(delta);
-    }
-    
-    /* Chop out the final block */
-    bi = plaintext.slice(i);
-    bl = w.bitLength(bi);
-    pad = prp.encrypt(xor(delta,[0,0,0,bl]));
-    bi = w.clamp(xor(bi.concat([0,0,0]),pad), bl);
-    
-    /* Checksum the final block, and finalize the checksum */
-    checksum = xor(checksum,xor(bi.concat([0,0,0]),pad));
-    checksum = prp.encrypt(xor(checksum,xor(delta,times2(delta))));
-    
-    /* MAC the header */
-    if (adata.length) {
-      checksum = xor(checksum, premac ? adata : sjcl.mode.ocb2.pmac(prp, adata));
-    }
-    
-    return output.concat(w.concat(bi, w.clamp(checksum, tlen)));
-  },
-  
-  /** Decrypt in OCB mode.
-   * @param {Object} prp The block cipher.  It must have a block size of 16 bytes.
-   * @param {bitArray} ciphertext The ciphertext data.
-   * @param {bitArray} iv The initialization value.
-   * @param {bitArray} [adata=[]] The authenticated data.
-   * @param {Number} [tlen=64] the desired tag length, in bits.
-   * @param {boolean} [premac=false] true if the authentication data is pre-macced with PMAC.
-   * @return The decrypted data, an array of bytes.
-   * @throws {sjcl.exception.invalid} if the IV isn't exactly 128 bits.
-   * @throws {sjcl.exception.corrupt} if if the message is corrupt.
-   */
-  decrypt: function(prp, ciphertext, iv, adata, tlen, premac) {
-    if (sjcl.bitArray.bitLength(iv) !== 128) {
-      throw new sjcl.exception.invalid("ocb iv must be 128 bits");
-    }
-    tlen  = tlen || 64;
-    var i,
-        times2 = sjcl.mode.ocb2._times2,
-        w = sjcl.bitArray,
-        xor = w._xor4,
-        checksum = [0,0,0,0],
-        delta = times2(prp.encrypt(iv)),
-        bi, bl,
-        len = sjcl.bitArray.bitLength(ciphertext) - tlen,
-        output = [],
-        pad;
-        
-    adata = adata || [];
-  
-    for (i=0; i+4 < len/32; i+=4) {
-      /* Decrypt a non-final block */
-      bi = xor(delta, prp.decrypt(xor(delta, ciphertext.slice(i,i+4))));
-      checksum = xor(checksum, bi);
-      output = output.concat(bi);
-      delta = times2(delta);
-    }
-    
-    /* Chop out and decrypt the final block */
-    bl = len-i*32;
-    pad = prp.encrypt(xor(delta,[0,0,0,bl]));
-    bi = xor(pad, w.clamp(ciphertext.slice(i),bl).concat([0,0,0]));
-    
-    /* Checksum the final block, and finalize the checksum */
-    checksum = xor(checksum, bi);
-    checksum = prp.encrypt(xor(checksum, xor(delta, times2(delta))));
-    
-    /* MAC the header */
-    if (adata.length) {
-      checksum = xor(checksum, premac ? adata : sjcl.mode.ocb2.pmac(prp, adata));
-    }
-    
-    if (!w.equal(w.clamp(checksum, tlen), w.bitSlice(ciphertext, len))) {
-      throw new sjcl.exception.corrupt("ocb: tag doesn't match");
-    }
-    
-    return output.concat(w.clamp(bi,bl));
-  },
-  
-  /** PMAC authentication for OCB associated data.
-   * @param {Object} prp The block cipher.  It must have a block size of 16 bytes.
-   * @param {bitArray} adata The authenticated data.
-   */
-  pmac: function(prp, adata) {
-    var i,
-        times2 = sjcl.mode.ocb2._times2,
-        w = sjcl.bitArray,
-        xor = w._xor4,
-        checksum = [0,0,0,0],
-        delta = prp.encrypt([0,0,0,0]),
-        bi;
-        
-    delta = xor(delta,times2(times2(delta)));
- 
-    for (i=0; i+4<adata.length; i+=4) {
-      delta = times2(delta);
-      checksum = xor(checksum, prp.encrypt(xor(delta, adata.slice(i,i+4))));
-    }
-    
-    bi = adata.slice(i);
-    if (w.bitLength(bi) < 128) {
-      delta = xor(delta,times2(delta));
-      bi = w.concat(bi,[0x80000000|0,0,0,0]);
-    }
-    checksum = xor(checksum, bi);
-    return prp.encrypt(xor(times2(xor(delta,times2(delta))), checksum));
-  },
-  
-  /** Double a block of words, OCB style.
-   * @private
-   */
-  _times2: function(x) {
-    return [x[0]<<1 ^ x[1]>>>31,
-            x[1]<<1 ^ x[2]>>>31,
-            x[2]<<1 ^ x[3]>>>31,
-            x[3]<<1 ^ (x[0]>>>31)*0x87];
-  }
-};
-/** @fileOverview GCM mode implementation.
- *
- * @author Juho Vähä-Herttua
- */
-
-/**
- * Galois/Counter mode.
- * @namespace
- */ 
-sjcl.mode.gcm = {
-  /**
-   * The name of the mode.
-   * @constant
-   */
-  name: "gcm",
-  
-  /** Encrypt in GCM mode.
-   * @static
-   * @param {Object} prf The pseudorandom function.  It must have a block size of 16 bytes.
-   * @param {bitArray} plaintext The plaintext data.
-   * @param {bitArray} iv The initialization value.
-   * @param {bitArray} [adata=[]] The authenticated data.
-   * @param {Number} [tlen=128] The desired tag length, in bits.
-   * @return {bitArray} The encrypted data, an array of bytes.
-   */
-  encrypt: function (prf, plaintext, iv, adata, tlen) {
-    var out, data = plaintext.slice(0), w=sjcl.bitArray;
-    tlen = tlen || 128;
-    adata = adata || [];
-
-    // encrypt and tag
-    out = sjcl.mode.gcm._ctrMode(true, prf, data, adata, iv, tlen);
-
-    return w.concat(out.data, out.tag);
-  },
-  
-  /** Decrypt in GCM mode.
-   * @static
-   * @param {Object} prf The pseudorandom function.  It must have a block size of 16 bytes.
-   * @param {bitArray} ciphertext The ciphertext data.
-   * @param {bitArray} iv The initialization value.
-   * @param {bitArray} [adata=[]] The authenticated data.
-   * @param {Number} [tlen=128] The desired tag length, in bits.
-   * @return {bitArray} The decrypted data.
-   */
-  decrypt: function (prf, ciphertext, iv, adata, tlen) {
-    var out, data = ciphertext.slice(0), tag, w=sjcl.bitArray, l=w.bitLength(data);
-    tlen = tlen || 128;
-    adata = adata || [];
-
-    // Slice tag out of data
-    if (tlen <= l) {
-      tag = w.bitSlice(data, l-tlen);
-      data = w.bitSlice(data, 0, l-tlen);
-    } else {
-      tag = data;
-      data = [];
-    }
-
-    // decrypt and tag
-    out = sjcl.mode.gcm._ctrMode(false, prf, data, adata, iv, tlen);
-
-    if (!w.equal(out.tag, tag)) {
-      throw new sjcl.exception.corrupt("gcm: tag doesn't match");
-    }
-    return out.data;
-  },
-
-  /* Compute the galois multiplication of X and Y
-   * @private
-   */
-  _galoisMultiply: function (x, y) {
-    var i, j, xi, Zi, Vi, lsb_Vi, w=sjcl.bitArray, xor=w._xor4;
-
-    Zi = [0,0,0,0];
-    Vi = y.slice(0);
-
-    // Block size is 128 bits, run 128 times to get Z_128
-    for (i=0; i<128; i++) {
-      xi = (x[Math.floor(i/32)] & (1 << (31-i%32))) !== 0;
-      if (xi) {
-        // Z_i+1 = Z_i ^ V_i
-        Zi = xor(Zi, Vi);
-      }
-
-      // Store the value of LSB(V_i)
-      lsb_Vi = (Vi[3] & 1) !== 0;
-
-      // V_i+1 = V_i >> 1
-      for (j=3; j>0; j--) {
-        Vi[j] = (Vi[j] >>> 1) | ((Vi[j-1]&1) << 31);
-      }
-      Vi[0] = Vi[0] >>> 1;
-
-      // If LSB(V_i) is 1, V_i+1 = (V_i >> 1) ^ R
-      if (lsb_Vi) {
-        Vi[0] = Vi[0] ^ (0xe1 << 24);
-      }
-    }
-    return Zi;
-  },
-
-  _ghash: function(H, Y0, data) {
-    var Yi, i, l = data.length;
-
-    Yi = Y0.slice(0);
-    for (i=0; i<l; i+=4) {
-      Yi[0] ^= 0xffffffff&data[i];
-      Yi[1] ^= 0xffffffff&data[i+1];
-      Yi[2] ^= 0xffffffff&data[i+2];
-      Yi[3] ^= 0xffffffff&data[i+3];
-      Yi = sjcl.mode.gcm._galoisMultiply(Yi, H);
-    }
-    return Yi;
-  },
-
-  /** GCM CTR mode.
-   * Encrypt or decrypt data and tag with the prf in GCM-style CTR mode.
-   * @param {Boolean} encrypt True if encrypt, false if decrypt.
-   * @param {Object} prf The PRF.
-   * @param {bitArray} data The data to be encrypted or decrypted.
-   * @param {bitArray} iv The initialization vector.
-   * @param {bitArray} adata The associated data to be tagged.
-   * @param {Number} tlen The length of the tag, in bits.
-   */
-  _ctrMode: function(encrypt, prf, data, adata, iv, tlen) {
-    var H, J0, S0, enc, i, ctr, tag, last, l, bl, abl, ivbl, w=sjcl.bitArray;
-
-    // Calculate data lengths
-    l = data.length;
-    bl = w.bitLength(data);
-    abl = w.bitLength(adata);
-    ivbl = w.bitLength(iv);
-
-    // Calculate the parameters
-    H = prf.encrypt([0,0,0,0]);
-    if (ivbl === 96) {
-      J0 = iv.slice(0);
-      J0 = w.concat(J0, [1]);
-    } else {
-      J0 = sjcl.mode.gcm._ghash(H, [0,0,0,0], iv);
-      J0 = sjcl.mode.gcm._ghash(H, J0, [0,0,Math.floor(ivbl/0x100000000),ivbl&0xffffffff]);
-    }
-    S0 = sjcl.mode.gcm._ghash(H, [0,0,0,0], adata);
-
-    // Initialize ctr and tag
-    ctr = J0.slice(0);
-    tag = S0.slice(0);
-
-    // If decrypting, calculate hash
-    if (!encrypt) {
-      tag = sjcl.mode.gcm._ghash(H, S0, data);
-    }
-
-    // Encrypt all the data
-    for (i=0; i<l; i+=4) {
-       ctr[3]++;
-       enc = prf.encrypt(ctr);
-       data[i]   ^= enc[0];
-       data[i+1] ^= enc[1];
-       data[i+2] ^= enc[2];
-       data[i+3] ^= enc[3];
-    }
-    data = w.clamp(data, bl);
-
-    // If encrypting, calculate hash
-    if (encrypt) {
-      tag = sjcl.mode.gcm._ghash(H, S0, data);
-    }
-
-    // Calculate last block from bit lengths, ugly because bitwise operations are 32-bit
-    last = [
-      Math.floor(abl/0x100000000), abl&0xffffffff,
-      Math.floor(bl/0x100000000), bl&0xffffffff
-    ];
-
-    // Calculate the final tag block
-    tag = sjcl.mode.gcm._ghash(H, tag, last);
-    enc = prf.encrypt(J0);
-    tag[0] ^= enc[0];
-    tag[1] ^= enc[1];
-    tag[2] ^= enc[2];
-    tag[3] ^= enc[3];
-
-    return { tag:w.bitSlice(tag, 0, tlen), data:data };
-  }
-};
-/** @fileOverview HMAC implementation.
- *
- * @author Emily Stark
- * @author Mike Hamburg
- * @author Dan Boneh
- */
-
-/** HMAC with the specified hash function.
- * @constructor
- * @param {bitArray} key the key for HMAC.
- * @param {Object} [Hash=sjcl.hash.sha256] The hash function to use.
- */
-sjcl.misc.hmac = function (key, Hash) {
-  this._hash = Hash = Hash || sjcl.hash.sha256;
-  var exKey = [[],[]], i,
-      bs = Hash.prototype.blockSize / 32;
-  this._baseHash = [new Hash(), new Hash()];
-
-  if (key.length > bs) {
-    key = Hash.hash(key);
-  }
-  
-  for (i=0; i<bs; i++) {
-    exKey[0][i] = key[i]^0x36363636;
-    exKey[1][i] = key[i]^0x5C5C5C5C;
-  }
-  
-  this._baseHash[0].update(exKey[0]);
-  this._baseHash[1].update(exKey[1]);
-  this._resultHash = new Hash(this._baseHash[0]);
-};
-
-/** HMAC with the specified hash function.  Also called encrypt since it's a prf.
- * @param {bitArray|String} data The data to mac.
- */
-sjcl.misc.hmac.prototype.encrypt = sjcl.misc.hmac.prototype.mac = function (data) {
-  if (!this._updated) {
-    this.update(data);
-    return this.digest(data);
-  } else {
-    throw new sjcl.exception.invalid("encrypt on already updated hmac called!");
-  }
-};
-
-sjcl.misc.hmac.prototype.reset = function () {
-  this._resultHash = new this._hash(this._baseHash[0]);
-  this._updated = false;
-};
-
-sjcl.misc.hmac.prototype.update = function (data) {
-  this._updated = true;
-  this._resultHash.update(data);
-};
-
-sjcl.misc.hmac.prototype.digest = function () {
-  var w = this._resultHash.finalize(), result = new (this._hash)(this._baseHash[1]).update(w).finalize();
-
-  this.reset();
-
-  return result;
-};
-/** @fileOverview Password-based key-derivation function, version 2.0.
- *
- * @author Emily Stark
- * @author Mike Hamburg
- * @author Dan Boneh
- */
-
-/** Password-Based Key-Derivation Function, version 2.0.
- *
- * Generate keys from passwords using PBKDF2-HMAC-SHA256.
- *
- * This is the method specified by RSA's PKCS #5 standard.
- *
- * @param {bitArray|String} password  The password.
- * @param {bitArray|String} salt The salt.  Should have lots of entropy.
- * @param {Number} [count=1000] The number of iterations.  Higher numbers make the function slower but more secure.
- * @param {Number} [length] The length of the derived key.  Defaults to the
-                            output size of the hash function.
- * @param {Object} [Prff=sjcl.misc.hmac] The pseudorandom function family.
- * @return {bitArray} the derived key.
- */
-sjcl.misc.pbkdf2 = function (password, salt, count, length, Prff) {
-  count = count || 10000;
-  
-  if (length < 0 || count < 0) {
-    throw new sjcl.exception.invalid("invalid params to pbkdf2");
-  }
-  
-  if (typeof password === "string") {
-    password = sjcl.codec.utf8String.toBits(password);
-  }
-  
-  if (typeof salt === "string") {
-    salt = sjcl.codec.utf8String.toBits(salt);
-  }
-  
-  Prff = Prff || sjcl.misc.hmac;
-  
-  var prf = new Prff(password),
-      u, ui, i, j, k, out = [], b = sjcl.bitArray;
-
-  for (k = 1; 32 * out.length < (length || 1); k++) {
-    u = ui = prf.encrypt(b.concat(salt,[k]));
-    
-    for (i=1; i<count; i++) {
-      ui = prf.encrypt(ui);
-      for (j=0; j<ui.length; j++) {
-        u[j] ^= ui[j];
-      }
-    }
-    
-    out = out.concat(u);
-  }
-
-  if (length) { out = b.clamp(out, length); }
-
-  return out;
-};
-/** @fileOverview Random number generator.
- *
- * @author Emily Stark
- * @author Mike Hamburg
- * @author Dan Boneh
- * @author Michael Brooks
- * @author Steve Thomas
- */
-
-/** 
- * @class Random number generator
- * @description
- * <b>Use sjcl.random as a singleton for this class!</b>
- * <p>
- * This random number generator is a derivative of Ferguson and Schneier's
- * generator Fortuna.  It collects entropy from various events into several
- * pools, implemented by streaming SHA-256 instances.  It differs from
- * ordinary Fortuna in a few ways, though.
- * </p>
- *
- * <p>
- * Most importantly, it has an entropy estimator.  This is present because
- * there is a strong conflict here between making the generator available
- * as soon as possible, and making sure that it doesn't "run on empty".
- * In Fortuna, there is a saved state file, and the system is likely to have
- * time to warm up.
- * </p>
- *
- * <p>
- * Second, because users are unlikely to stay on the page for very long,
- * and to speed startup time, the number of pools increases logarithmically:
- * a new pool is created when the previous one is actually used for a reseed.
- * This gives the same asymptotic guarantees as Fortuna, but gives more
- * entropy to early reseeds.
- * </p>
- *
- * <p>
- * The entire mechanism here feels pretty klunky.  Furthermore, there are
- * several improvements that should be made, including support for
- * dedicated cryptographic functions that may be present in some browsers;
- * state files in local storage; cookies containing randomness; etc.  So
- * look for improvements in future versions.
- * </p>
- * @constructor
- */
-sjcl.prng = function(defaultParanoia) {
-  
-  /* private */
-  this._pools                   = [new sjcl.hash.sha256()];
-  this._poolEntropy             = [0];
-  this._reseedCount             = 0;
-  this._robins                  = {};
-  this._eventId                 = 0;
-  
-  this._collectorIds            = {};
-  this._collectorIdNext         = 0;
-  
-  this._strength                = 0;
-  this._poolStrength            = 0;
-  this._nextReseed              = 0;
-  this._key                     = [0,0,0,0,0,0,0,0];
-  this._counter                 = [0,0,0,0];
-  this._cipher                  = undefined;
-  this._defaultParanoia         = defaultParanoia;
-  
-  /* event listener stuff */
-  this._collectorsStarted       = false;
-  this._callbacks               = {progress: {}, seeded: {}};
-  this._callbackI               = 0;
-  
-  /* constants */
-  this._NOT_READY               = 0;
-  this._READY                   = 1;
-  this._REQUIRES_RESEED         = 2;
-
-  this._MAX_WORDS_PER_BURST     = 65536;
-  this._PARANOIA_LEVELS         = [0,48,64,96,128,192,256,384,512,768,1024];
-  this._MILLISECONDS_PER_RESEED = 30000;
-  this._BITS_PER_RESEED         = 80;
-};
- 
-sjcl.prng.prototype = {
-  /** Generate several random words, and return them in an array.
-   * A word consists of 32 bits (4 bytes)
-   * @param {Number} nwords The number of words to generate.
-   */
-  randomWords: function (nwords, paranoia) {
-    var out = [], i, readiness = this.isReady(paranoia), g;
-  
-    if (readiness === this._NOT_READY) {
-      throw new sjcl.exception.notReady("generator isn't seeded");
-    } else if (readiness & this._REQUIRES_RESEED) {
-      this._reseedFromPools(!(readiness & this._READY));
-    }
-  
-    for (i=0; i<nwords; i+= 4) {
-      if ((i+1) % this._MAX_WORDS_PER_BURST === 0) {
-        this._gate();
-      }
-   
-      g = this._gen4words();
-      out.push(g[0],g[1],g[2],g[3]);
-    }
-    this._gate();
-  
-    return out.slice(0,nwords);
-  },
-  
-  setDefaultParanoia: function (paranoia, allowZeroParanoia) {
-    if (paranoia === 0 && allowZeroParanoia !== "Setting paranoia=0 will ruin your security; use it only for testing") {
-      throw new sjcl.exception.invalid("Setting paranoia=0 will ruin your security; use it only for testing");
-    }
-
-    this._defaultParanoia = paranoia;
-  },
-  
-  /**
-   * Add entropy to the pools.
-   * @param data The entropic value.  Should be a 32-bit integer, array of 32-bit integers, or string
-   * @param {Number} estimatedEntropy The estimated entropy of data, in bits
-   * @param {String} source The source of the entropy, eg "mouse"
-   */
-  addEntropy: function (data, estimatedEntropy, source) {
-    source = source || "user";
-  
-    var id,
-      i, tmp,
-      t = (new Date()).valueOf(),
-      robin = this._robins[source],
-      oldReady = this.isReady(), err = 0, objName;
-      
-    id = this._collectorIds[source];
-    if (id === undefined) { id = this._collectorIds[source] = this._collectorIdNext ++; }
-      
-    if (robin === undefined) { robin = this._robins[source] = 0; }
-    this._robins[source] = ( this._robins[source] + 1 ) % this._pools.length;
-  
-    switch(typeof(data)) {
-      
-    case "number":
-      if (estimatedEntropy === undefined) {
-        estimatedEntropy = 1;
-      }
-      this._pools[robin].update([id,this._eventId++,1,estimatedEntropy,t,1,data|0]);
-      break;
-      
-    case "object":
-      objName = Object.prototype.toString.call(data);
-      if (objName === "[object Uint32Array]") {
-        tmp = [];
-        for (i = 0; i < data.length; i++) {
-          tmp.push(data[i]);
-        }
-        data = tmp;
-      } else {
-        if (objName !== "[object Array]") {
-          err = 1;
-        }
-        for (i=0; i<data.length && !err; i++) {
-          if (typeof(data[i]) !== "number") {
-            err = 1;
-          }
-        }
-      }
-      if (!err) {
-        if (estimatedEntropy === undefined) {
-          /* horrible entropy estimator */
-          estimatedEntropy = 0;
-          for (i=0; i<data.length; i++) {
-            tmp= data[i];
-            while (tmp>0) {
-              estimatedEntropy++;
-              tmp = tmp >>> 1;
-            }
-          }
-        }
-        this._pools[robin].update([id,this._eventId++,2,estimatedEntropy,t,data.length].concat(data));
-      }
-      break;
-      
-    case "string":
-      if (estimatedEntropy === undefined) {
-       /* English text has just over 1 bit per character of entropy.
-        * But this might be HTML or something, and have far less
-        * entropy than English...  Oh well, let's just say one bit.
-        */
-       estimatedEntropy = data.length;
-      }
-      this._pools[robin].update([id,this._eventId++,3,estimatedEntropy,t,data.length]);
-      this._pools[robin].update(data);
-      break;
-      
-    default:
-      err=1;
-    }
-    if (err) {
-      throw new sjcl.exception.bug("random: addEntropy only supports number, array of numbers or string");
-    }
-  
-    /* record the new strength */
-    this._poolEntropy[robin] += estimatedEntropy;
-    this._poolStrength += estimatedEntropy;
-  
-    /* fire off events */
-    if (oldReady === this._NOT_READY) {
-      if (this.isReady() !== this._NOT_READY) {
-        this._fireEvent("seeded", Math.max(this._strength, this._poolStrength));
-      }
-      this._fireEvent("progress", this.getProgress());
-    }
-  },
-  
-  /** Is the generator ready? */
-  isReady: function (paranoia) {
-    var entropyRequired = this._PARANOIA_LEVELS[ (paranoia !== undefined) ? paranoia : this._defaultParanoia ];
-  
-    if (this._strength && this._strength >= entropyRequired) {
-      return (this._poolEntropy[0] > this._BITS_PER_RESEED && (new Date()).valueOf() > this._nextReseed) ?
-        this._REQUIRES_RESEED | this._READY :
-        this._READY;
-    } else {
-      return (this._poolStrength >= entropyRequired) ?
-        this._REQUIRES_RESEED | this._NOT_READY :
-        this._NOT_READY;
-    }
-  },
-  
-  /** Get the generator's progress toward readiness, as a fraction */
-  getProgress: function (paranoia) {
-    var entropyRequired = this._PARANOIA_LEVELS[ paranoia ? paranoia : this._defaultParanoia ];
-  
-    if (this._strength >= entropyRequired) {
-      return 1.0;
-    } else {
-      return (this._poolStrength > entropyRequired) ?
-        1.0 :
-        this._poolStrength / entropyRequired;
-    }
-  },
-  
-  /** start the built-in entropy collectors */
-  startCollectors: function () {
-    if (this._collectorsStarted) { return; }
-  
-    this._eventListener = {
-      loadTimeCollector: this._bind(this._loadTimeCollector),
-      mouseCollector: this._bind(this._mouseCollector),
-      keyboardCollector: this._bind(this._keyboardCollector),
-      accelerometerCollector: this._bind(this._accelerometerCollector),
-      touchCollector: this._bind(this._touchCollector)
-    };
-
-    if (window.addEventListener) {
-      window.addEventListener("load", this._eventListener.loadTimeCollector, false);
-      window.addEventListener("mousemove", this._eventListener.mouseCollector, false);
-      window.addEventListener("keypress", this._eventListener.keyboardCollector, false);
-      window.addEventListener("devicemotion", this._eventListener.accelerometerCollector, false);
-      window.addEventListener("touchmove", this._eventListener.touchCollector, false);
-    } else if (document.attachEvent) {
-      document.attachEvent("onload", this._eventListener.loadTimeCollector);
-      document.attachEvent("onmousemove", this._eventListener.mouseCollector);
-      document.attachEvent("keypress", this._eventListener.keyboardCollector);
-    } else {
-      throw new sjcl.exception.bug("can't attach event");
-    }
-  
-    this._collectorsStarted = true;
-  },
-  
-  /** stop the built-in entropy collectors */
-  stopCollectors: function () {
-    if (!this._collectorsStarted) { return; }
-  
-    if (window.removeEventListener) {
-      window.removeEventListener("load", this._eventListener.loadTimeCollector, false);
-      window.removeEventListener("mousemove", this._eventListener.mouseCollector, false);
-      window.removeEventListener("keypress", this._eventListener.keyboardCollector, false);
-      window.removeEventListener("devicemotion", this._eventListener.accelerometerCollector, false);
-      window.removeEventListener("touchmove", this._eventListener.touchCollector, false);
-    } else if (document.detachEvent) {
-      document.detachEvent("onload", this._eventListener.loadTimeCollector);
-      document.detachEvent("onmousemove", this._eventListener.mouseCollector);
-      document.detachEvent("keypress", this._eventListener.keyboardCollector);
-    }
-
-    this._collectorsStarted = false;
-  },
-  
-  /* use a cookie to store entropy.
-  useCookie: function (all_cookies) {
-      throw new sjcl.exception.bug("random: useCookie is unimplemented");
-  },*/
-  
-  /** add an event listener for progress or seeded-ness. */
-  addEventListener: function (name, callback) {
-    this._callbacks[name][this._callbackI++] = callback;
-  },
-  
-  /** remove an event listener for progress or seeded-ness */
-  removeEventListener: function (name, cb) {
-    var i, j, cbs=this._callbacks[name], jsTemp=[];
-
-    /* I'm not sure if this is necessary; in C++, iterating over a
-     * collection and modifying it at the same time is a no-no.
-     */
-
-    for (j in cbs) {
-      if (cbs.hasOwnProperty(j) && cbs[j] === cb) {
-        jsTemp.push(j);
-      }
-    }
-
-    for (i=0; i<jsTemp.length; i++) {
-      j = jsTemp[i];
-      delete cbs[j];
-    }
-  },
-  
-  _bind: function (func) {
-    var that = this;
-    return function () {
-      func.apply(that, arguments);
-    };
-  },
-
-  /** Generate 4 random words, no reseed, no gate.
-   * @private
-   */
-  _gen4words: function () {
-    for (var i=0; i<4; i++) {
-      this._counter[i] = this._counter[i]+1 | 0;
-      if (this._counter[i]) { break; }
-    }
-    return this._cipher.encrypt(this._counter);
-  },
-  
-  /* Rekey the AES instance with itself after a request, or every _MAX_WORDS_PER_BURST words.
-   * @private
-   */
-  _gate: function () {
-    this._key = this._gen4words().concat(this._gen4words());
-    this._cipher = new sjcl.cipher.aes(this._key);
-  },
-  
-  /** Reseed the generator with the given words
-   * @private
-   */
-  _reseed: function (seedWords) {
-    this._key = sjcl.hash.sha256.hash(this._key.concat(seedWords));
-    this._cipher = new sjcl.cipher.aes(this._key);
-    for (var i=0; i<4; i++) {
-      this._counter[i] = this._counter[i]+1 | 0;
-      if (this._counter[i]) { break; }
-    }
-  },
-  
-  /** reseed the data from the entropy pools
-   * @param full If set, use all the entropy pools in the reseed.
-   */
-  _reseedFromPools: function (full) {
-    var reseedData = [], strength = 0, i;
-  
-    this._nextReseed = reseedData[0] =
-      (new Date()).valueOf() + this._MILLISECONDS_PER_RESEED;
-    
-    for (i=0; i<16; i++) {
-      /* On some browsers, this is cryptographically random.  So we might
-       * as well toss it in the pot and stir...
-       */
-      reseedData.push(Math.random()*0x100000000|0);
-    }
-    
-    for (i=0; i<this._pools.length; i++) {
-     reseedData = reseedData.concat(this._pools[i].finalize());
-     strength += this._poolEntropy[i];
-     this._poolEntropy[i] = 0;
-   
-     if (!full && (this._reseedCount & (1<<i))) { break; }
-    }
-  
-    /* if we used the last pool, push a new one onto the stack */
-    if (this._reseedCount >= 1 << this._pools.length) {
-     this._pools.push(new sjcl.hash.sha256());
-     this._poolEntropy.push(0);
-    }
-  
-    /* how strong was this reseed? */
-    this._poolStrength -= strength;
-    if (strength > this._strength) {
-      this._strength = strength;
-    }
-  
-    this._reseedCount ++;
-    this._reseed(reseedData);
-  },
-  
-  _keyboardCollector: function () {
-    this._addCurrentTimeToEntropy(1);
-  },
-  
-  _mouseCollector: function (ev) {
-    var x, y;
-
-    try {
-      x = ev.x || ev.clientX || ev.offsetX || 0;
-      y = ev.y || ev.clientY || ev.offsetY || 0;
-    } catch (err) {
-      // Event originated from a secure element. No mouse position available.
-      x = 0;
-      y = 0;
-    }
-
-    if (x != 0 && y!= 0) {
-      this.addEntropy([x,y], 2, "mouse");
-    }
-
-    this._addCurrentTimeToEntropy(0);
-  },
-
-  _touchCollector: function(ev) {
-    var touch = ev.touches[0] || ev.changedTouches[0];
-    var x = touch.pageX || touch.clientX,
-        y = touch.pageY || touch.clientY;
-
-    this.addEntropy([x,y],1,"touch");
-
-    this._addCurrentTimeToEntropy(0);
-  },
-  
-  _loadTimeCollector: function () {
-    this._addCurrentTimeToEntropy(2);
-  },
-
-  _addCurrentTimeToEntropy: function (estimatedEntropy) {
-    if (typeof window !== 'undefined' && window.performance && typeof window.performance.now === "function") {
-      //how much entropy do we want to add here?
-      this.addEntropy(window.performance.now(), estimatedEntropy, "loadtime");
-    } else {
-      this.addEntropy((new Date()).valueOf(), estimatedEntropy, "loadtime");
-    }
-  },
-  _accelerometerCollector: function (ev) {
-    var ac = ev.accelerationIncludingGravity.x||ev.accelerationIncludingGravity.y||ev.accelerationIncludingGravity.z;
-    if(window.orientation){
-      var or = window.orientation;
-      if (typeof or === "number") {
-        this.addEntropy(or, 1, "accelerometer");
-      }
-    }
-    if (ac) {
-      this.addEntropy(ac, 2, "accelerometer");
-    }
-    this._addCurrentTimeToEntropy(0);
-  },
-
-  _fireEvent: function (name, arg) {
-    var j, cbs=sjcl.random._callbacks[name], cbsTemp=[];
-    /* TODO: there is a race condition between removing collectors and firing them */
-
-    /* I'm not sure if this is necessary; in C++, iterating over a
-     * collection and modifying it at the same time is a no-no.
-     */
-
-    for (j in cbs) {
-      if (cbs.hasOwnProperty(j)) {
-        cbsTemp.push(cbs[j]);
-      }
-    }
-
-    for (j=0; j<cbsTemp.length; j++) {
-      cbsTemp[j](arg);
-    }
-  }
-};
-
-/** an instance for the prng.
-* @see sjcl.prng
-*/
-sjcl.random = new sjcl.prng(6);
-
-(function(){
-  // function for getting nodejs crypto module. catches and ignores errors.
-  function getCryptoModule() {
-    try {
-      return require('crypto');
-    }
-    catch (e) {
-      return null;
-    }
-  }
-
-  try {
-    var buf, crypt, ab;
-
-    // get cryptographically strong entropy depending on runtime environment
-    if (typeof module !== 'undefined' && module.exports && (crypt = getCryptoModule()) && crypt.randomBytes) {
-      buf = crypt.randomBytes(1024/8);
-      buf = new Uint32Array(new Uint8Array(buf).buffer);
-      sjcl.random.addEntropy(buf, 1024, "crypto.randomBytes");
-
-    } else if (typeof window !== 'undefined' && typeof Uint32Array !== 'undefined') {
-      ab = new Uint32Array(32);
-      if (window.crypto && window.crypto.getRandomValues) {
-        window.crypto.getRandomValues(ab);
-      } else if (window.msCrypto && window.msCrypto.getRandomValues) {
-        window.msCrypto.getRandomValues(ab);
-      } else {
-        return;
-      }
-
-      // get cryptographically strong entropy in Webkit
-      sjcl.random.addEntropy(ab, 1024, "crypto.getRandomValues");
-
-    } else {
-      // no getRandomValues :-(
-    }
-  } catch (e) {
-    if (typeof window !== 'undefined' && window.console) {
-      console.log("There was an error collecting entropy from the browser:");
-      console.log(e);
-      //we do not want the library to fail due to randomness not being maintained.
-    }
-  }
-}());
-/** @fileOverview Convenience functions centered around JSON encapsulation.
- *
- * @author Emily Stark
- * @author Mike Hamburg
- * @author Dan Boneh
- */
-
- /**
-  * JSON encapsulation
-  * @namespace
-  */
- sjcl.json = {
-  /** Default values for encryption */
-  defaults: { v:1, iter:10000, ks:128, ts:64, mode:"ccm", adata:"", cipher:"aes" },
-
-  /** Simple encryption function.
-   * @param {String|bitArray} password The password or key.
-   * @param {String} plaintext The data to encrypt.
-   * @param {Object} [params] The parameters including tag, iv and salt.
-   * @param {Object} [rp] A returned version with filled-in parameters.
-   * @return {Object} The cipher raw data.
-   * @throws {sjcl.exception.invalid} if a parameter is invalid.
-   */
-  _encrypt: function (password, plaintext, params, rp) {
-    params = params || {};
-    rp = rp || {};
-
-    var j = sjcl.json, p = j._add({ iv: sjcl.random.randomWords(4,0) },
-                                  j.defaults), tmp, prp, adata;
-    j._add(p, params);
-    adata = p.adata;
-    if (typeof p.salt === "string") {
-      p.salt = sjcl.codec.base64.toBits(p.salt);
-    }
-    if (typeof p.iv === "string") {
-      p.iv = sjcl.codec.base64.toBits(p.iv);
-    }
-
-    if (!sjcl.mode[p.mode] ||
-        !sjcl.cipher[p.cipher] ||
-        (typeof password === "string" && p.iter <= 100) ||
-        (p.ts !== 64 && p.ts !== 96 && p.ts !== 128) ||
-        (p.ks !== 128 && p.ks !== 192 && p.ks !== 256) ||
-        (p.iv.length < 2 || p.iv.length > 4)) {
-      throw new sjcl.exception.invalid("json encrypt: invalid parameters");
-    }
-
-    if (typeof password === "string") {
-      tmp = sjcl.misc.cachedPbkdf2(password, p);
-      password = tmp.key.slice(0,p.ks/32);
-      p.salt = tmp.salt;
-    } else if (sjcl.ecc && password instanceof sjcl.ecc.elGamal.publicKey) {
-      tmp = password.kem();
-      p.kemtag = tmp.tag;
-      password = tmp.key.slice(0,p.ks/32);
-    }
-    if (typeof plaintext === "string") {
-      plaintext = sjcl.codec.utf8String.toBits(plaintext);
-    }
-    if (typeof adata === "string") {
-      p.adata = adata = sjcl.codec.utf8String.toBits(adata);
-    }
-    prp = new sjcl.cipher[p.cipher](password);
-
-    /* return the json data */
-    j._add(rp, p);
-    rp.key = password;
-
-    /* do the encryption */
-    if (p.mode === "ccm" && sjcl.arrayBuffer && sjcl.arrayBuffer.ccm && plaintext instanceof ArrayBuffer) {
-      p.ct = sjcl.arrayBuffer.ccm.encrypt(prp, plaintext, p.iv, adata, p.ts);
-    } else {
-      p.ct = sjcl.mode[p.mode].encrypt(prp, plaintext, p.iv, adata, p.ts);
-    }
-
-    //return j.encode(j._subtract(p, j.defaults));
-    return p;
-  },
-
-  /** Simple encryption function.
-   * @param {String|bitArray} password The password or key.
-   * @param {String} plaintext The data to encrypt.
-   * @param {Object} [params] The parameters including tag, iv and salt.
-   * @param {Object} [rp] A returned version with filled-in parameters.
-   * @return {String} The ciphertext serialized data.
-   * @throws {sjcl.exception.invalid} if a parameter is invalid.
-   */
-  encrypt: function (password, plaintext, params, rp) {
-    var j = sjcl.json, p = j._encrypt.apply(j, arguments);
-    return j.encode(p);
-  },
-
-  /** Simple decryption function.
-   * @param {String|bitArray} password The password or key.
-   * @param {Object} ciphertext The cipher raw data to decrypt.
-   * @param {Object} [params] Additional non-default parameters.
-   * @param {Object} [rp] A returned object with filled parameters.
-   * @return {String} The plaintext.
-   * @throws {sjcl.exception.invalid} if a parameter is invalid.
-   * @throws {sjcl.exception.corrupt} if the ciphertext is corrupt.
-   */
-  _decrypt: function (password, ciphertext, params, rp) {
-    params = params || {};
-    rp = rp || {};
-
-    var j = sjcl.json, p = j._add(j._add(j._add({},j.defaults),ciphertext), params, true), ct, tmp, prp, adata=p.adata;
-    if (typeof p.salt === "string") {
-      p.salt = sjcl.codec.base64.toBits(p.salt);
-    }
-    if (typeof p.iv === "string") {
-      p.iv = sjcl.codec.base64.toBits(p.iv);
-    }
-
-    if (!sjcl.mode[p.mode] ||
-        !sjcl.cipher[p.cipher] ||
-        (typeof password === "string" && p.iter <= 100) ||
-        (p.ts !== 64 && p.ts !== 96 && p.ts !== 128) ||
-        (p.ks !== 128 && p.ks !== 192 && p.ks !== 256) ||
-        (!p.iv) ||
-        (p.iv.length < 2 || p.iv.length > 4)) {
-      throw new sjcl.exception.invalid("json decrypt: invalid parameters");
-    }
-
-    if (typeof password === "string") {
-      tmp = sjcl.misc.cachedPbkdf2(password, p);
-      password = tmp.key.slice(0,p.ks/32);
-      p.salt  = tmp.salt;
-    } else if (sjcl.ecc && password instanceof sjcl.ecc.elGamal.secretKey) {
-      password = password.unkem(sjcl.codec.base64.toBits(p.kemtag)).slice(0,p.ks/32);
-    }
-    if (typeof adata === "string") {
-      adata = sjcl.codec.utf8String.toBits(adata);
-    }
-    prp = new sjcl.cipher[p.cipher](password);
-
-    /* do the decryption */
-    if (p.mode === "ccm" && sjcl.arrayBuffer && sjcl.arrayBuffer.ccm && p.ct instanceof ArrayBuffer) {
-      ct = sjcl.arrayBuffer.ccm.decrypt(prp, p.ct, p.iv, p.tag, adata, p.ts);
-    } else {
-      ct = sjcl.mode[p.mode].decrypt(prp, p.ct, p.iv, adata, p.ts);
-    }
-
-    /* return the json data */
-    j._add(rp, p);
-    rp.key = password;
-
-    if (params.raw === 1) {
-      return ct;
-    } else {
-      return sjcl.codec.utf8String.fromBits(ct);
-    }
-  },
-
-  /** Simple decryption function.
-   * @param {String|bitArray} password The password or key.
-   * @param {String} ciphertext The ciphertext to decrypt.
-   * @param {Object} [params] Additional non-default parameters.
-   * @param {Object} [rp] A returned object with filled parameters.
-   * @return {String} The plaintext.
-   * @throws {sjcl.exception.invalid} if a parameter is invalid.
-   * @throws {sjcl.exception.corrupt} if the ciphertext is corrupt.
-   */
-  decrypt: function (password, ciphertext, params, rp) {
-    var j = sjcl.json;
-    return j._decrypt(password, j.decode(ciphertext), params, rp);
-  },
-
-  /** Encode a flat structure into a JSON string.
-   * @param {Object} obj The structure to encode.
-   * @return {String} A JSON string.
-   * @throws {sjcl.exception.invalid} if obj has a non-alphanumeric property.
-   * @throws {sjcl.exception.bug} if a parameter has an unsupported type.
-   */
-  encode: function (obj) {
-    var i, out='{', comma='';
-    for (i in obj) {
-      if (obj.hasOwnProperty(i)) {
-        if (!i.match(/^[a-z0-9]+$/i)) {
-          throw new sjcl.exception.invalid("json encode: invalid property name");
-        }
-        out += comma + '"' + i + '":';
-        comma = ',';
-
-        switch (typeof obj[i]) {
-          case 'number':
-          case 'boolean':
-            out += obj[i];
-            break;
-
-          case 'string':
-            out += '"' + escape(obj[i]) + '"';
-            break;
-
-          case 'object':
-            out += '"' + sjcl.codec.base64.fromBits(obj[i],0) + '"';
-            break;
-
-          default:
-            throw new sjcl.exception.bug("json encode: unsupported type");
-        }
-      }
-    }
-    return out+'}';
-  },
-
-  /** Decode a simple (flat) JSON string into a structure.  The ciphertext,
-   * adata, salt and iv will be base64-decoded.
-   * @param {String} str The string.
-   * @return {Object} The decoded structure.
-   * @throws {sjcl.exception.invalid} if str isn't (simple) JSON.
-   */
-  decode: function (str) {
-    str = str.replace(/\s/g,'');
-    if (!str.match(/^\{.*\}$/)) {
-      throw new sjcl.exception.invalid("json decode: this isn't json!");
-    }
-    var a = str.replace(/^\{|\}$/g, '').split(/,/), out={}, i, m;
-    for (i=0; i<a.length; i++) {
-      if (!(m=a[i].match(/^\s*(?:(["']?)([a-z][a-z0-9]*)\1)\s*:\s*(?:(-?\d+)|"([a-z0-9+\/%*_.@=\-]*)"|(true|false))$/i))) {
-        throw new sjcl.exception.invalid("json decode: this isn't json!");
-      }
-      if (m[3] != null) {
-        out[m[2]] = parseInt(m[3],10);
-      } else if (m[4] != null) {
-        out[m[2]] = m[2].match(/^(ct|adata|salt|iv)$/) ? sjcl.codec.base64.toBits(m[4]) : unescape(m[4]);
-      } else if (m[5] != null) {
-        out[m[2]] = m[5] === 'true';
-      }
-    }
-    return out;
-  },
-
-  /** Insert all elements of src into target, modifying and returning target.
-   * @param {Object} target The object to be modified.
-   * @param {Object} src The object to pull data from.
-   * @param {boolean} [requireSame=false] If true, throw an exception if any field of target differs from corresponding field of src.
-   * @return {Object} target.
-   * @private
-   */
-  _add: function (target, src, requireSame) {
-    if (target === undefined) { target = {}; }
-    if (src === undefined) { return target; }
-    var i;
-    for (i in src) {
-      if (src.hasOwnProperty(i)) {
-        if (requireSame && target[i] !== undefined && target[i] !== src[i]) {
-          throw new sjcl.exception.invalid("required parameter overridden");
-        }
-        target[i] = src[i];
-      }
-    }
-    return target;
-  },
-
-  /** Remove all elements of minus from plus.  Does not modify plus.
-   * @private
-   */
-  _subtract: function (plus, minus) {
-    var out = {}, i;
-
-    for (i in plus) {
-      if (plus.hasOwnProperty(i) && plus[i] !== minus[i]) {
-        out[i] = plus[i];
-      }
-    }
-
-    return out;
-  },
-
-  /** Return only the specified elements of src.
-   * @private
-   */
-  _filter: function (src, filter) {
-    var out = {}, i;
-    for (i=0; i<filter.length; i++) {
-      if (src[filter[i]] !== undefined) {
-        out[filter[i]] = src[filter[i]];
-      }
-    }
-    return out;
-  }
-};
-
-/** Simple encryption function; convenient shorthand for sjcl.json.encrypt.
- * @param {String|bitArray} password The password or key.
- * @param {String} plaintext The data to encrypt.
- * @param {Object} [params] The parameters including tag, iv and salt.
- * @param {Object} [rp] A returned version with filled-in parameters.
- * @return {String} The ciphertext.
- */
-sjcl.encrypt = sjcl.json.encrypt;
-
-/** Simple decryption function; convenient shorthand for sjcl.json.decrypt.
- * @param {String|bitArray} password The password or key.
- * @param {String} ciphertext The ciphertext to decrypt.
- * @param {Object} [params] Additional non-default parameters.
- * @param {Object} [rp] A returned object with filled parameters.
- * @return {String} The plaintext.
- */
-sjcl.decrypt = sjcl.json.decrypt;
-
-/** The cache for cachedPbkdf2.
- * @private
- */
-sjcl.misc._pbkdf2Cache = {};
-
-/** Cached PBKDF2 key derivation.
- * @param {String} password The password.
- * @param {Object} [obj] The derivation params (iteration count and optional salt).
- * @return {Object} The derived data in key, the salt in salt.
- */
-sjcl.misc.cachedPbkdf2 = function (password, obj) {
-  var cache = sjcl.misc._pbkdf2Cache, c, cp, str, salt, iter;
-
-  obj = obj || {};
-  iter = obj.iter || 1000;
-
-  /* open the cache for this password and iteration count */
-  cp = cache[password] = cache[password] || {};
-  c = cp[iter] = cp[iter] || { firstSalt: (obj.salt && obj.salt.length) ?
-                     obj.salt.slice(0) : sjcl.random.randomWords(2,0) };
-
-  salt = (obj.salt === undefined) ? c.firstSalt : obj.salt;
-
-  c[salt] = c[salt] || sjcl.misc.pbkdf2(password, salt, obj.iter);
-  return { key: c[salt].slice(0), salt:salt.slice(0) };
-};
-if(typeof module !== 'undefined' && module.exports){
-  module.exports = sjcl;
-}
-if (typeof define === "function") {
-    define([], function () {
-        return sjcl;
-    });
-}
diff --git a/static/js/node_store.mjs b/static/js/node_store.mjs
index 6be8f82..bf7c4e8 100644
--- a/static/js/node_store.mjs
+++ b/static/js/node_store.mjs
@@ -1,12 +1,218 @@
-import { Node } from 'node'
-
 export const ROOT_NODE = '00000000-0000-0000-0000-000000000000'
 export const ORPHANED_NODE = '00000000-0000-0000-0000-000000000001'
 export const DELETED_NODE = '00000000-0000-0000-0000-000000000002'
 
+export class Node {
+	static sort(a, b) {//{{{
+		// Nodes with children ("folders") are sorted first.
+		if (a._has_children && !b._has_children) return -1
+		if (!a._has_children && b._has_children) return 1
+
+		// Otherwise sort by lowercased name.
+		const an = a.data.Name.toLowerCase()
+		const bn = b.data.Name.toLowerCase()
+		if (an < bn) return -1
+		if (an > bn) return 1
+		return 0
+	}//}}}
+	static create(name, parentUUID) {// {{{
+		const node = new Node({
+			UUID: uuidv7(),
+			Created: (new Date()).toISOString(),
+			Content: '',
+			Name: name,
+			ParentUUID: parentUUID,
+			Markdown: false,
+		})
+
+		// Newly created node (not constructed from existing data) is considered modified
+		// since node.save returns early if it isn't modified.
+		node._modified = true
+
+		return node
+	}// }}}
+
+	constructor(nodeData, level) {//{{{
+		this.Level = level
+		this.data = nodeData
+		this.UUID = nodeData.UUID
+
+		// Toplevel nodes are normalized to have the ROOT_NODE as parent.
+		if (nodeData.UUID !== ROOT_NODE && nodeData.ParentUUID === '') {
+			this.ParentUUID = ROOT_NODE
+			this.data.ParentUUID = ROOT_NODE
+		} else
+			this.ParentUUID = nodeData.ParentUUID
+
+		this._children_fetched = false
+		this._has_children = null // this will be set by nodeStore.getTreeNodes
+		this.Children = []
+		this.Ancestors = []
+
+		this._sibling_before = null
+		this._sibling_after = null
+		this._parent = null
+
+		this.reset()
+	}//}}}
+
+	reset() {// {{{
+		// this._content is the runtime content in the editor.
+		// this.data.Content is the original data.
+		this._content = this.data.Content
+		this._modified = false
+	}// }}}
+	get(prop) {//{{{
+		return this.data[prop]
+	}//}}}
+	updated() {//{{{
+		// '2024-12-17T17:33:48.85939Z
+		return new Date(Date.parse(this.data.Updated))
+	}//}}}
+	isModified() {// {{{
+		return this._modified
+	}// }}}
+	hasFetchedChildren() {//{{{
+		return this._children_fetched
+	}//}}}
+	async fetchChildren() {//{{{
+		this.Children = await globalThis.nodeStore.getTreeNodes(this.UUID, this.Level + 1)
+		this._children_fetched = true
+
+		// Children are sorted to allow for storing siblings befare and after.
+		// These are used with keyboard navigation in the tree.
+		this.Children.sort(Node.sort)
+
+		const numChildren = this.Children.length
+		this.setHasChildren(numChildren > 0)
+		for (let i = 0; i < numChildren; i++) {
+			if (i > 0)
+				this.Children[i]._sibling_before = this.Children[i - 1]
+			if (i < numChildren - 1)
+				this.Children[i]._sibling_after = this.Children[i + 1]
+			this.Children[i]._parent = this
+		}
+
+		return this.Children
+	}//}}}
+	setHasChildren(v) {// {{{
+		this._has_children = v
+	}// }}}
+	hasChildren() {//{{{
+		return this._has_children
+	}//}}}
+	getSiblingBefore() {// {{{
+		return this._sibling_before
+	}// }}}
+	getSiblingAfter() {// {{{
+		return this._sibling_after
+	}// }}}
+	getParent() {//{{{
+		return this._parent
+	}//}}}
+	moveToParent(newParentUUID) {// {{{
+		if (this.UUID === newParentUUID)
+			throw new Error("New parent UUID is the same as node UUID. Can't be your own parent.")
+
+		this.ParentUUID = newParentUUID
+		this.data.ParentUUID = newParentUUID
+		this._modified = true
+	}// }}}
+	isLastSibling() {//{{{
+		return this._sibling_after === null
+	}//}}}
+	isFirstSibling() {//{{{
+		return this._sibling_before === null
+	}//}}}
+	isSpecial() {// {{{
+		return this.data.Special
+	}// }}}
+	content() {//{{{
+		// TODO - implement crypto
+		return this._content
+	}//}}}
+	setContent(new_content) {//{{{
+		this._content = new_content
+		this._modified = true
+		_mbus.dispatch('NODE_MODIFIED', { node: this })
+	}//}}}
+	setName(new_name) {// {{{
+		if (new_name.trim() === '')
+			throw new Error(`The name can't be empty`)
+
+		this.data.Name = new_name
+		this._modified = true
+		_mbus.dispatch('NODE_MODIFIED', { node: this })
+	}// }}}
+	async save() {//{{{
+		try {
+			const dblink = /db:\/\/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/gi
+
+			// Just safeguarding not using the root node,
+			// which sort of exist but isn't supposed to communicate to server.
+			if (this.UUID == ROOT_NODE)
+				return
+
+			// File links from the original, unmodified content are found to compare to links from the new content.
+			// All files (images) needs to be indexed to nodes in order to track orphaned files.
+			const before = new Set([...this.data.Content.matchAll(dblink)].map(m => m[1]))
+			const after = new Set([...this._content.matchAll(dblink)].map(m => m[1]))
+			const removed = before.difference(after)
+			const added = after.difference(before)
+
+			await globalThis.nodeStore.filesNodelink.removeFileUUIDs(this.UUID, removed)
+			await globalThis.nodeStore.filesNodelink.addFileUUIDs(this.UUID, added)
+
+			// Authoritative content and metadata is set to prepare it for IndexedDB update.
+			this.data.Content = this._content
+			this.data.Updated = new Date().toISOString()
+			this.data.HistoryUUID = uuidv7() // every time the node is saved a new history UUID identifies the changed node.
+
+			_mbus.dispatch('NODE_UNMODIFIED')
+			this._modified = false
+
+			// When stored into database and ancestry was changed,
+			// the ancestry path could be interesting.
+			/*
+			const ancestors = await nodeStore.getNodeAncestry(this)
+			this.data.Ancestors = ancestors.map(a => a.get('Name')).reverse()
+			*/
+
+			/* The node history is a local store for node history.
+			 * This could be provisioned from the server or cleared if
+			 * deemed unnecessary.
+			 *
+			 * The send queue is what will be sent back to the server
+			 * to have a recorded history of the notes.
+			 *
+			 * A setting to be implemented in the future could be to
+			 * not save the history locally at all. */
+
+			// Current node is added to history. It will be duplicated with the "nodes" store
+			// for simplicity, to hopefully avoid bugs.
+			const history = globalThis.nodeStore.nodesHistory.add(this)
+
+			// Updated node is added to the send queue to be stored on server.
+
+			const sendQueue = globalThis.nodeStore.sendQueue.add(this)
+
+			// Updated node is saved to the primary node store.
+			const nodeStoreAdding = globalThis.nodeStore.add([this])
+
+			await Promise.all([history, sendQueue, nodeStoreAdding])
+
+		} catch (err) {
+			console.error(err)
+			alert(err.message)
+		}
+
+		return
+	}//}}}
+}
+
 export class NodeStore {
 	constructor() {//{{{
-		if (!('indexedDB' in window)) {
+		if (!('indexedDB' in self)) {
 			throw 'Missing IndexedDB'
 		}
 
@@ -15,12 +221,13 @@ export class NodeStore {
 		this.sendQueue = null
 		this.nodesHistory = null
 		this.files = null
+		this.filesMetadata = null
 
 		this.initializeSpecialNodes()
 	}//}}}
 	initializeDB() {//{{{
 		return new Promise((resolve, reject) => {
-			const req = indexedDB.open('notes', 8)
+			const req = indexedDB.open('notes', 14)
 
 			// Schema upgrades for IndexedDB.
 			// These can start from different points depending on updates to Notes2 since a device was online.
@@ -71,6 +278,30 @@ export class NodeStore {
 						case 8:
 							files = db.createObjectStore('files', { keyPath: 'UUID' })
 							break
+
+						case 9:
+							db.createObjectStore('files_metadata', { keyPath: 'UUID' })
+							break
+
+						case 10:
+							trx.objectStore('files_metadata').createIndex('byUploaded', 'uploaded', { unique: false })
+							break
+
+						case 11:
+							db.createObjectStore('files_nodelink', { keyPath: 'UUID' })
+							break
+
+						case 12:
+							trx.objectStore('files_nodelink').createIndex('byNodeCount', 'NodeCount', { unique: false })
+							break
+
+						case 13:
+							db.createObjectStore('file_segments', { keyPath: ['UUID', 'Sequence'] })
+							break
+
+						case 14:
+							db.deleteObjectStore('files')
+							break
 					}
 				}
 			}
@@ -80,6 +311,9 @@ export class NodeStore {
 				this.sendQueue = new SimpleNodeStore(this.db, 'send_queue')
 				this.nodesHistory = new NodeHistoryStore(this.db, 'nodes_history')
 				this.files = new SimpleNodeStore(this.db, 'files')
+				this.fileSegments = new FileSegmentsStore(this.db, 'file_segments')
+				this.filesMetadata = new FilesMetadataStore(this.db, 'files_metadata')
+				this.filesNodelink = new FileNodesLinkStore(this.db, 'files_nodelink')
 				resolve()
 			}
 
@@ -221,7 +455,6 @@ export class NodeStore {
 					nodeStore = t.objectStore('nodes')
 
 					t.oncomplete = (_event) => {
-						console.log('complete')
 						resolve()
 					}
 
@@ -332,6 +565,66 @@ export class NodeStore {
 			}
 		})
 	}//}}}
+
+	async storeFile(file) {// {{{
+		const metadata = new FileMetadata(file)
+
+		try {
+			// Do potentially larger blocks.
+			const BLOCKSIZE = 1048576
+			const stream = file.stream()
+			const reader = stream.getReader({ mode: 'byob' })
+			let buffer = new Uint8Array(BLOCKSIZE)
+
+			let seq = 0
+			while (true) {
+				const { done, value } = await reader.read(buffer)
+				if (done) break
+
+				// Block is added as a file segment.
+				await this.fileSegments.add({
+					data: {
+						UUID: metadata.UUID,
+						Sequence: seq,
+						Data: value,
+					}
+				})
+				buffer = new Uint8Array(value.buffer)
+				seq++
+			}
+
+			reader.releaseLock()
+		} catch (e) {
+			console.error(e)
+			alert(e.message)
+		}
+
+		await this.filesMetadata.add({ data: metadata })
+
+		return metadata
+	}// }}}
+	nextFileToSync() {// {{{
+		return new Promise((resolve, reject) => {
+			const req = this.db
+				.transaction('files_metadata', 'readonly')
+				.objectStore('files_metadata')
+				.index('byUploaded')
+				.get('only_on_device')
+
+			req.onerror = (e) => reject(e)
+			req.onsuccess = (e) => {
+				const data = e.target.result
+
+				// No more files to sync.
+				if (data === undefined) {
+					resolve(null)
+					return
+				}
+
+				resolve(new FileMetadata(data))
+			}
+		})
+	}// }}}
 }
 
 class SimpleNodeStore {
@@ -351,7 +644,6 @@ class SimpleNodeStore {
 			// Node to be moved is first stored in the new queue.
 			const req = store.put(node.data)
 			req.onsuccess = () => {
-				console.log('here')
 				resolve()
 			}
 			req.onerror = (event) => {
@@ -460,7 +752,7 @@ class NodeHistoryStore extends SimpleNodeStore {
 			}
 
 			req.onerror = (event) => {
-				console.log(event.target.error)
+				console.error(event.target.error)
 				reject(event.target.error)
 			}
 		})
@@ -513,6 +805,120 @@ class NodeHistoryStore extends SimpleNodeStore {
 	}// }}}
 }
 
+class FileSegmentsStore extends SimpleNodeStore {
+	constructor(db, storeName) {//{{{
+		super(db, storeName)
+	}//}}}
+	async getStream(uuid) {// {{{
+		let seq = 0
+		const meself = this
+
+		return new ReadableStream({
+			type: 'bytes',
+
+			async pull(controller) {
+				try {
+					while (true) {
+						const chunk = await meself.get([uuid, seq])
+						if (!chunk) {
+							controller.close()
+							return
+						}
+
+						controller.enqueue(chunk.Data)
+						seq++
+					}
+				} catch (e) {
+					console.error(e)
+				}
+			}
+		})
+	}// }}}
+}
+
+class FilesMetadataStore extends SimpleNodeStore {
+	countToUpload() {// {{{
+		const store = this.db
+			.transaction(this.storeName, 'readonly')
+			.objectStore(this.storeName)
+			.index('byUploaded')
+		return new Promise((resolve, reject) => {
+			const request = store.count('only_on_device')
+			request.onsuccess = (event) => resolve(event.target.result)
+			request.onerror = (event) => reject(event.target.error)
+		})
+	}// }}}
+}
+
+class FileNodesLinkStore extends SimpleNodeStore {
+	async removeFileUUIDs(nodeUUID, fileUUIDs) {// {{{
+		for (const fileUUID of fileUUIDs) {
+			let nodelink = await this.get(fileUUID)
+
+			// Nothing to remove from.
+			if (nodelink === undefined)
+				continue
+
+			const idx = nodelink.Nodes.indexOf(nodeUUID)
+			if (idx > -1)
+				nodelink.Nodes.splice(idx, 1)
+
+			// Maintains an index to quickly find orphaned files.
+			nodelink.NodeCount = nodelink.Nodes.length
+
+			await this.add({ data: nodelink })
+		}
+	}// }}}
+	async addFileUUIDs(nodeUUID, fileUUIDs) {// {{{
+		for (const fileUUID of fileUUIDs) {
+			let nodelink = await this.get(fileUUID)
+
+			// Needs to be initialized if not existing already.
+			if (nodelink === undefined)
+				nodelink = {
+					UUID: fileUUID,
+					Nodes: [nodeUUID],
+				}
+
+			// Can get called with the same UUID as already there.
+			// No duplicates, only append if missing.
+			if (!nodelink.Nodes.includes(nodeUUID))
+				nodelink.Nodes.push(nodeUUID)
+
+			// Maintains an index to quickly find orphaned files.
+			nodelink.NodeCount = nodelink.Nodes.length
+
+			await this.add({ data: nodelink })
+		}
+	}// }}}
+}
+
+class FileMetadata {
+	constructor(data) {// {{{
+		console.log('md', data)
+		this.UUID = data.UUID || uuidv7()
+		this.uploaded = data.uploaded || 'only_on_device'
+
+		this.name = data.name
+		this.size = data.size
+		this.type = data.type || 'application/octet-stream'
+		this.modified = data.modified || data.lastModified || Date.now()
+	}// }}}
+	setUploaded() {// {{{
+		this.uploaded = 'on_server'
+	}// }}}
+	get data() {// {{{
+		return {
+			UUID: this.UUID,
+			uploaded: this.uploaded,
+			name: this.name,
+			size: this.size,
+			type: this.type,
+			modified: this.modified,
+		}
+	}// }}}
+}
+
 export function uuidv7() {// {{{
 	// random bytes
 	const value = new Uint8Array(16)
diff --git a/static/js/page_history.mjs b/static/js/page_history.mjs
index 44061f6..2c03193 100644
--- a/static/js/page_history.mjs
+++ b/static/js/page_history.mjs
@@ -1,5 +1,5 @@
 import { CustomHTMLElement } from './lib/custom_html_element.mjs'
-import { Node } from './page_node.mjs'
+import { Node } from 'node_store'
 import { MarkedPosition } from './marked_position.mjs'
 
 
diff --git a/static/js/page_node.mjs b/static/js/page_node.mjs
index 2106ada..574fe96 100644
--- a/static/js/page_node.mjs
+++ b/static/js/page_node.mjs
@@ -1,4 +1,3 @@
-import { ROOT_NODE, uuidv7 } from 'node_store'
 import { CustomHTMLElement } from './lib/custom_html_element.mjs'
 import { MarkedPosition } from './marked_position.mjs'
 
@@ -267,11 +266,11 @@ export class N2PageNodeUI extends CustomHTMLElement {
 					const file = item.getAsFile()
 					if (!file)
 						throw new Error("Couldn't convert image to file object.")
-					const uuid = uuidv7()
-					await globalThis.nodeStore.files.add({ data: { UUID: uuid, file: file } })
+
+					const fileMetadata = await globalThis.nodeStore.storeFile(file)
 
 					const [start, end] = [this.elNodeContent.selectionStart, this.elNodeContent.selectionEnd]
-					this.elNodeContent.setRangeText(`![${file.name}](db://${uuid})`, start, end, 'select');
+					this.elNodeContent.setRangeText(`![${file.name}](db://${fileMetadata.UUID})`, start, end, 'select');
 
 					// Editing the textarea programatically doesn't generate the events it usually gets when edited interactively.
 					this.node.setContent(this.elNodeContent.value)
@@ -398,196 +397,4 @@ export class N2PageNodeUI extends CustomHTMLElement {
 }
 customElements.define('n2-nodeui', N2PageNodeUI)
 
-export class Node {
-	static sort(a, b) {//{{{
-		// Nodes with children ("folders") are sorted first.
-		if (a._has_children && !b._has_children) return -1
-		if (!a._has_children && b._has_children) return 1
-
-		// Otherwise sort by lowercased name.
-		const an = a.data.Name.toLowerCase()
-		const bn = b.data.Name.toLowerCase()
-		if (an < bn) return -1
-		if (an > bn) return 1
-		return 0
-	}//}}}
-	static create(name, parentUUID) {// {{{
-		const node = new Node({
-			UUID: uuidv7(),
-			Created: (new Date()).toISOString(),
-			Content: '',
-			Name: name,
-			ParentUUID: parentUUID,
-			Markdown: false,
-		})
-
-		// Newly created node (not constructed from existing data) is considered modified
-		// since node.save returns early if it isn't modified.
-		node._modified = true
-
-		return node
-	}// }}}
-
-	constructor(nodeData, level) {//{{{
-		this.Level = level
-		this.data = nodeData
-		this.UUID = nodeData.UUID
-
-		// Toplevel nodes are normalized to have the ROOT_NODE as parent.
-		if (nodeData.UUID !== ROOT_NODE && nodeData.ParentUUID === '') {
-			this.ParentUUID = ROOT_NODE
-			this.data.ParentUUID = ROOT_NODE
-		} else
-			this.ParentUUID = nodeData.ParentUUID
-
-		this._children_fetched = false
-		this._has_children = null // this will be set by nodeStore.getTreeNodes
-		this.Children = []
-		this.Ancestors = []
-
-		this._sibling_before = null
-		this._sibling_after = null
-		this._parent = null
-
-		this.reset()
-	}//}}}
-
-	reset() {// {{{
-		this._content = this.data.Content
-		this._modified = false
-	}// }}}
-	get(prop) {//{{{
-		return this.data[prop]
-	}//}}}
-	updated() {//{{{
-		// '2024-12-17T17:33:48.85939Z
-		return new Date(Date.parse(this.data.Updated))
-	}//}}}
-	isModified() {// {{{
-		return this._modified
-	}// }}}
-	hasFetchedChildren() {//{{{
-		return this._children_fetched
-	}//}}}
-	async fetchChildren() {//{{{
-		this.Children = await nodeStore.getTreeNodes(this.UUID, this.Level + 1)
-		this._children_fetched = true
-
-		// Children are sorted to allow for storing siblings befare and after.
-		// These are used with keyboard navigation in the tree.
-		this.Children.sort(Node.sort)
-
-		const numChildren = this.Children.length
-		this.setHasChildren(numChildren > 0)
-		for (let i = 0; i < numChildren; i++) {
-			if (i > 0)
-				this.Children[i]._sibling_before = this.Children[i - 1]
-			if (i < numChildren - 1)
-				this.Children[i]._sibling_after = this.Children[i + 1]
-			this.Children[i]._parent = this
-		}
-
-		return this.Children
-	}//}}}
-	setHasChildren(v) {// {{{
-		this._has_children = v
-	}// }}}
-	hasChildren() {//{{{
-		return this._has_children
-	}//}}}
-	getSiblingBefore() {// {{{
-		return this._sibling_before
-	}// }}}
-	getSiblingAfter() {// {{{
-		return this._sibling_after
-	}// }}}
-	getParent() {//{{{
-		return this._parent
-	}//}}}
-	moveToParent(newParentUUID) {// {{{
-		if (this.UUID === newParentUUID)
-			throw new Error("New parent UUID is the same as node UUID. Can't be your own parent.")
-
-		this.ParentUUID = newParentUUID
-		this.data.ParentUUID = newParentUUID
-		this._modified = true
-	}// }}}
-	isLastSibling() {//{{{
-		return this._sibling_after === null
-	}//}}}
-	isFirstSibling() {//{{{
-		return this._sibling_before === null
-	}//}}}
-	isSpecial() {// {{{
-		return this.data.Special
-	}// }}}
-	content() {//{{{
-		/* TODO - implement crypto
-		if (this.CryptoKeyID != 0 && !this._decrypted)
-			this.#decrypt()
-		*/
-		return this._content
-	}//}}}
-	setContent(new_content) {//{{{
-		this._content = new_content
-		this._modified = true
-		_mbus.dispatch('NODE_MODIFIED', { node: this })
-	}//}}}
-	setName(new_name) {// {{{
-		if (new_name.trim() === '')
-			throw new Error(`The name can't be empty`)
-
-		this.data.Name = new_name
-		this._modified = true
-		_mbus.dispatch('NODE_MODIFIED', { node: this })
-	}// }}}
-	async save() {//{{{
-		// Just safeguarding not using the root node,
-		// which sort of exist but isn't supposed to communicate to server.
-		if (this.UUID == ROOT_NODE)
-			return
-
-		this.data.Content = this._content
-		this.data.Updated = new Date().toISOString()
-		this.data.HistoryUUID = uuidv7() // every time the node is saved a new history UUID identifies the changed node.
-		this._modified = false
-
-		_mbus.dispatch('NODE_UNMODIFIED')
-
-		// When stored into database and ancestry was changed,
-		// the ancestry path could be interesting.
-		/*
-		const ancestors = await nodeStore.getNodeAncestry(this)
-		this.data.Ancestors = ancestors.map(a => a.get('Name')).reverse()
-		*/
-		/* The node history is a local store for node history.
-		 * This could be provisioned from the server or cleared if
-		 * deemed unnecessary.
-		 *
-		 * The send queue is what will be sent back to the server
-		 * to have a recorded history of the notes.
-		 *
-		 * A setting to be implemented in the future could be to
-		 * not save the history locally at all. */
-
-		// Current node is added to history. It will be duplicated with the "nodes" store
-		// for simplicity, to hopefully avoid bugs.
-		const history = nodeStore.nodesHistory.add(this)
-
-		// Updated node is added to the send queue to be stored on server.
-
-		const sendQueue = nodeStore.sendQueue.add(this)
-
-		// Updated node is saved to the primary node store.
-		const nodeStoreAdding = nodeStore.add([this])
-
-		console.log('waiting')
-		await Promise.all([history, sendQueue, nodeStoreAdding])
-		console.log('waiting done')
-
-		return
-	}//}}}
-}
-
-
 // vim: foldmethod=marker
diff --git a/static/js/page_preferences.mjs b/static/js/page_preferences.mjs
index 9655278..dd85ebf 100644
--- a/static/js/page_preferences.mjs
+++ b/static/js/page_preferences.mjs
@@ -45,7 +45,7 @@ export class N2PagePreferences extends CustomHTMLElement {
 
 		this.elNewSet.addEventListener('click', () => this.newSet())
 		this.elSave.addEventListener('click', () => this.save())
-		this.elDevPreferenceSet.addEventListener('change', event=>this.changePreferenceSet(event))
+		this.elDevPreferenceSet.addEventListener('change', ()=>this.changePreferenceSet())
 
 		window._mbus.subscribe('SHOW_PAGE', async event => {
 			if (event.detail.data?.page == 'preferences') {
@@ -71,7 +71,7 @@ export class N2PagePreferences extends CustomHTMLElement {
 			this.sets.sort(this.sortSets)
 			this.elSets.replaceChildren(...this.sets)
 			
-			const setNames = this.sets.entries().map(([i, set]) => {
+			const setNames = this.sets.entries().map(([_idx, set]) => {
 				const optn = document.createElement('option')
 				optn.innerText = set.name
 				return optn
@@ -106,7 +106,7 @@ export class N2PagePreferences extends CustomHTMLElement {
 			alert(`Error retrieving preferences: ${e.message}`)
 		}
 	}// }}}
-	changePreferenceSet(event) {// {{{
+	changePreferenceSet() {// {{{
 		this.preferencesModified()
 	}// }}}
 	newSet() {// {{{
@@ -168,6 +168,8 @@ export class N2PagePreferences extends CustomHTMLElement {
 			user.Preferences = newPrefs
 			localStorage.setItem('user', JSON.stringify(user))
 			localStorage.setItem('device_preference_set', this.elDevPreferenceSet.value)
+
+			// Application is told that reloading preferences is to be done.
 			_mbus.dispatch('DEVICE_PREFERENCE_SET_UPDATED')
 		} catch (e) {
 			console.error(e)
diff --git a/static/js/page_storage.mjs b/static/js/page_storage.mjs
index a007130..96f50ac 100644
--- a/static/js/page_storage.mjs
+++ b/static/js/page_storage.mjs
@@ -1,17 +1,51 @@
 import { CustomHTMLElement } from "./lib/custom_html_element.mjs"
+import { API } from 'api'
 
 export class N2PageStorage extends CustomHTMLElement {
 	static {
 		this.tmpl = document.createElement('template')
 		this.tmpl.innerHTML = `
+			<style>
+				.table {
+					display: grid;
+					grid-template-columns: min-content min-content;
+					grid-gap: 4px 16px;
+					align-items: center;
+					white-space: nowrap;
+				}
+
+				.error {
+					background-color: #ff2a2a;
+					color: #fff;
+					padding: 4px 8px;
+					border-radius: 4px;
+				}
+			</style>
+
 			<h1>Local storage</h1>
-			<div data-el="count-nodes"></div>
-			<div data-el="count-queued-nodes"></div>
-			<div data-el="count-history-nodes"></div>
+			<div class="table">
+				<div>Local nodes</div>
+				<div data-el="count-nodes"></div>
+
+				<div>Queued to sync</div>
+				<div data-el="count-queued-nodes"></div>
+
+				<div>History nodes</div>
+				<div data-el="count-history-nodes"></div>
+			</div>
+
+			<h1>Files</h1>
+			<div class="table">
+				<div>Files on server</div>
+				<div data-el="count-files-on-server"></div>
+
+				<div>Files to send</div>
+				<div data-el="count-queued-files"></div>
+			</div>
 		`
 	}
 	constructor() {
-		super()
+		super(true)
 
 		window._mbus.subscribe('SHOW_PAGE', event => {
 			if (event.detail.data?.page == 'storage')
@@ -19,13 +53,21 @@ export class N2PageStorage extends CustomHTMLElement {
 		})
 	}
 	async render() {
-		const countNodes = await globalThis.nodeStore.nodeCount()
-		const countQueuedNodes = await globalThis.nodeStore.sendQueue.count()
-		const countHistoryNodes = await globalThis.nodeStore.nodesHistory.count()
+		API.query('GET', '/file/count')
+			.then(res => {
+				this.elCountFilesOnServer.innerText = res.Count
+			})
+			.catch(err => {
+				this.elCountFilesOnServer.classList.add('error')
+				console.error(err)
+				this.elCountFilesOnServer.innerText = err.message
+			})
 
-		this.elCountNodes.innerText = countNodes
-		this.elCountQueuedNodes.innerText = countQueuedNodes
-		this.elCountHistoryNodes.innerText = countHistoryNodes
+
+		this.elCountNodes.innerText = await globalThis.nodeStore.nodeCount()
+		this.elCountQueuedNodes.innerText = await globalThis.nodeStore.sendQueue.count()
+		this.elCountHistoryNodes.innerText = await globalThis.nodeStore.nodesHistory.count()
+		this.elCountQueuedFiles.innerText = await globalThis.nodeStore.filesMetadata.countToUpload()
 	}
 }
 customElements.define('n2-pagestorage', N2PageStorage)
diff --git a/static/js/sidebar.mjs b/static/js/sidebar.mjs
index 6cd5814..899e955 100644
--- a/static/js/sidebar.mjs
+++ b/static/js/sidebar.mjs
@@ -1,5 +1,4 @@
-import { ROOT_NODE, ORPHANED_NODE, DELETED_NODE } from 'node_store'
-import { Node } from 'node'
+import { ROOT_NODE, ORPHANED_NODE, DELETED_NODE, Node } from 'node_store'
 import { CustomHTMLElement } from './lib/custom_html_element.mjs'
 import { Color, Solver } from './lib/css_colorize.mjs'
 
@@ -82,11 +81,16 @@ export class N2Sidebar extends CustomHTMLElement {
 
 					.icons {
 						display: flex;
-						justify-content: center;
+						justify-content: start;
 						margin-top: 16px;
-						gap: 8px;
+						gap: 8px 16px;
+						padding-left: 40px;
 						padding-bottom: 16px;
 						border-bottom: 1px solid var(--line-color);
+
+						img {
+							cursor: pointer;
+						}
 					}
 
 
@@ -104,6 +108,7 @@ export class N2Sidebar extends CustomHTMLElement {
 			</div>
 			<div class="icons">
 				<img data-el="sync"     class='sync colorize'     src="/images/${_VERSION}/icon_refresh.svg"  />
+				<img data-el="storage"  class='storage colorize'  src="/images/${_VERSION}/icon_storage.svg"  />
 				<img data-el="search"   class='search colorize'   src="/images/${_VERSION}/icon_search.svg" style="height: 22px" />
 				<img data-el="settings" class='settings colorize' src="/images/${_VERSION}/icon_settings.svg" />
 			</div>
@@ -127,6 +132,7 @@ export class N2Sidebar extends CustomHTMLElement {
 		this.addEventListener('keydown', event => this.keyHandler(event))
 		this.elSearch.addEventListener('click', () => _mbus.dispatch('op-search'))
 		this.elSync.addEventListener('click', () => _sync.run())
+		this.elStorage.addEventListener('click', () => _mbus.dispatch('SHOW_PAGE', { page: 'storage' }))
 		this.elLogo.addEventListener('click', () => _app.goToNode(ROOT_NODE, false, false))
 		this.elSettings.addEventListener('click', ()=> _mbus.dispatch('SHOW_PAGE', { page: 'preferences' }))
 		this.elHideTree.addEventListener('click', event => {
diff --git a/static/js/sync.mjs b/static/js/sync.mjs
index daa603f..f68a09f 100644
--- a/static/js/sync.mjs
+++ b/static/js/sync.mjs
@@ -1,5 +1,5 @@
 import { API } from 'api'
-import { Node } from 'node'
+import { Node } from 'node_store'
 import { CustomHTMLElement } from './lib/custom_html_element.mjs'
 
 export class Sync {
@@ -164,6 +164,53 @@ export class Sync {
 			}
 		}
 	}//}}}
+	async filesToServer() {// {{{
+		try {
+			const BLOCKSIZE = 128 * 1024
+			let sentBytes = 0
+
+			const metadata = await nodeStore.nextFileToSync()
+			if (metadata === null)
+				return
+
+			const stream = await globalThis.nodeStore.fileSegments.getStream(metadata.UUID)
+			const reader = stream.getReader({ mode: 'byob' }) // Bring Your Own Buffer
+			let buffer = new Uint8Array(BLOCKSIZE)
+
+			while (true) {
+				const { value, done } = await reader.read(buffer)
+
+				await API.upload(metadata.UUID, value, sentBytes, metadata)
+				metadata.setUploaded()
+				nodeStore.filesMetadata.add(metadata)
+
+				if (done)
+					break
+				sentBytes += value.length
+				buffer = new Uint8Array(value.buffer)
+			}
+			reader.releaseLock()
+		} catch (e) {
+			console.error(e)
+			alert(e.message)
+		}
+	}// }}}
+
+	async filesFromServer() {// {{{
+		let offset = 0
+		let more = true
+
+		try {
+			while (more) {
+				const res = await API.query('GET', `/file/server_uuids/${offset}`)
+				more = res.MoreRowsExist
+				console.log(res)
+			}
+		} catch (e) {
+			console.error(e)
+			alert(e.message)
+		}
+	}// }}}
 }
 
 export class N2SyncProgress extends CustomHTMLElement {
diff --git a/static/service_worker.js b/static/service_worker.js
index 8522b20..7cf268e 100644
--- a/static/service_worker.js
+++ b/static/service_worker.js
@@ -1,3 +1,5 @@
+import { NodeStore } from '/js/{{ .VERSION }}/node_store.mjs'
+
 const CACHE_NAME = 'notes2-{{ .VERSION }}'
 const CACHED_ASSETS = [
 	'/',
@@ -11,16 +13,21 @@ const CACHED_ASSETS = [
 
 	'/images/{{ .VERSION }}/collapsed.svg',
 	'/images/{{ .VERSION }}/expanded.svg',
+	'/images/{{ .VERSION }}/icon_back.svg',
 	'/images/{{ .VERSION }}/icon_history.svg',
 	'/images/{{ .VERSION }}/icon_home.svg',
 	'/images/{{ .VERSION }}/icon_markdown_hollow.svg',
 	'/images/{{ .VERSION }}/icon_markdown.svg',
+	'/images/{{ .VERSION }}/icon_menu.svg',
+	'/images/{{ .VERSION }}/icon_new_document.svg',
 	'/images/{{ .VERSION }}/icon_refresh.svg',
 	'/images/{{ .VERSION }}/icon_save_disabled.svg',
 	'/images/{{ .VERSION }}/icon_save.svg',
 	'/images/{{ .VERSION }}/icon_search.svg',
 	'/images/{{ .VERSION }}/icon_settings.svg',
+	'/images/{{ .VERSION }}/icon_storage.svg',
 	'/images/{{ .VERSION }}/icon_table.svg',
+	'/images/{{ .VERSION }}/icon_transfer.svg',
 	'/images/{{ .VERSION }}/leaf.svg',
 	'/images/{{ .VERSION }}/logo_small.svg',
 	'/images/{{ .VERSION }}/logo.svg',
@@ -28,20 +35,18 @@ const CACHED_ASSETS = [
 	'/js/{{ .VERSION }}/api.mjs',
 	'/js/{{ .VERSION }}/app.mjs',
 	'/js/{{ .VERSION }}/checklist.mjs',
-	'/js/{{ .VERSION }}/crypto.mjs',
 	'/js/{{ .VERSION }}/file.mjs',
-	'/js/{{ .VERSION }}/key.mjs',
 	'/js/{{ .VERSION }}/lib/css_colorize.mjs',
 	'/js/{{ .VERSION }}/lib/custom_html_element.mjs',
 	'/js/{{ .VERSION }}/lib/node_modules/marked/lib/marked.esm.js',
 	'/js/{{ .VERSION }}/lib/node_modules/marked-token-position/lib/index.esm.js',
-	'/js/{{ .VERSION }}/lib/sjcl.js',
 	'/js/{{ .VERSION }}/marked_position.mjs',
 	'/js/{{ .VERSION }}/mbus.mjs',
 	'/js/{{ .VERSION }}/node_store.mjs',
 	'/js/{{ .VERSION }}/notes2.mjs',
 	'/js/{{ .VERSION }}/page_history.mjs',
 	'/js/{{ .VERSION }}/page_node.mjs',
+	'/js/{{ .VERSION }}/page_preferences.mjs',
 	'/js/{{ .VERSION }}/page_storage.mjs',
 	'/js/{{ .VERSION }}/sidebar.mjs',
 	'/js/{{ .VERSION }}/sync.mjs',
@@ -120,14 +125,55 @@ self.addEventListener('activate', event => {
 })
 
 self.addEventListener('fetch', event => {
+	const url = new URL(event.request.url)
+
 	// The fetch event is also seeing requests to other domains.
 	// Just let the browser handle those for itself.
-	const ourDomain = event.request.url.startsWith(self.location.origin)
+	const ourDomain = (url.host == self.location.host)
 	if (!ourDomain)
 		return event
 
+	if (url.pathname == '/stream-local') {
+		event.respondWith(indexeddbFile(event))
+		return
+	}
+
 	if (`{{ .DevMode }}` == 'true')
 		return event
-
-	event.respondWith(fetchAsset(event))
+	else
+		event.respondWith(fetchAsset(event))
 })
+
+
+let nodestore = null
+async function getNodestore() {
+	if (nodestore)
+		return nodestore
+
+	// When setting nodestore directly, then waiting on initializeDB,
+	// a second call for getNodestore can return the nodestore before
+	// initialized.
+	const initializingNodeStore = new NodeStore()
+	await initializingNodeStore.initializeDB()
+	nodestore = initializingNodeStore
+	return nodestore
+}
+
+async function indexeddbFile(event) {
+	const url = new URL(event.request.url)
+	const uuid = url.searchParams.get('uuid')
+
+	try {
+		const nodeStore = await getNodestore()
+		const md = await nodeStore.filesMetadata.get(uuid)
+		const stream = await nodeStore.fileSegments.getStream(uuid)
+
+		return new Response(stream, {
+			headers: {
+				'Content-Type': md.type,
+			}
+		})
+	} catch (err) {
+		console.error(err)
+	}
+}
diff --git a/views/layouts/main.gotmpl b/views/layouts/main.gotmpl
index c5fbead..13a0bcf 100644
--- a/views/layouts/main.gotmpl
+++ b/views/layouts/main.gotmpl
@@ -9,10 +9,8 @@
 		{
 			"imports": {
 				"api":        "/js/{{ .VERSION }}/api.mjs",
-				"sync":        "/js/{{ .VERSION }}/sync.mjs",
-				"key":        "/js/{{ .VERSION }}/key.mjs",
+				"sync":       "/js/{{ .VERSION }}/sync.mjs",
 				"checklist":  "/js/{{ .VERSION }}/checklist.mjs",
-				"crypto":     "/js/{{ .VERSION }}/crypto.mjs",
 				"node_store": "/js/{{ .VERSION }}/node_store.mjs",
 				"node":       "/js/{{ .VERSION }}/page_node.mjs",
 				"sidebar":    "/js/{{ .VERSION }}/sidebar.mjs"
@@ -20,14 +18,14 @@
 		}
 		</script>
 		<script>
-			window._VERSION = "{{ .VERSION }}"
+			globalThis._VERSION = "{{ .VERSION }}"
 
 			if (navigator.serviceWorker)
-				navigator.serviceWorker.register('/service_worker.js')
+				navigator.serviceWorker.register('/service_worker.js', { type: 'module' })
 		</script>
 		<script type="module" defer>
 			import { MessageBus } from '/js/{{ .VERSION }}/mbus.mjs'
-			window._mbus = new MessageBus()
+			globalThis._mbus = new MessageBus()
 		</script>
 	</head>
 	<body>
diff --git a/views/pages/login.gotmpl b/views/pages/login.gotmpl
index 3e2235f..8e824aa 100644
--- a/views/pages/login.gotmpl
+++ b/views/pages/login.gotmpl
@@ -4,7 +4,7 @@
 	<img id="logo" src="/images/v1/logo.svg">
 	<input type="text" id="username" placeholder="Username">
 	<input type="password" id="password" placeholder="Password">
-	<button onclick=window._login.authenticate()>Log in</button>
+	<button onclick="globalThis._login.authenticate()">Log in</button>
 	<div id="error"></div>
 </div>
 
@@ -42,6 +42,6 @@ class Login {
 	}
 }
 
-window._login = new Login()
+globalThis._login = new Login()
 </script>
 {{ end }}
diff --git a/views/pages/notes2.gotmpl b/views/pages/notes2.gotmpl
index 2755aea..c5df63e 100644
--- a/views/pages/notes2.gotmpl
+++ b/views/pages/notes2.gotmpl
@@ -7,7 +7,7 @@
 
 <!-- page-node -->
 <div id="notes2" class="page-node">
-	<div id="tree-expander" onclick="window._mbus.dispatch('TREE_EXPANSION', { expand: true })">&gt;</div>
+	<div id="tree-expander" onclick="globalThis._mbus.dispatch('TREE_EXPANSION', { expand: true })">&gt;</div>
 	<div id="tree" tabindex=0></div>
 
 	<div id="main-page">
@@ -47,20 +47,21 @@
 	import {App} from "/js/{{ .VERSION }}/app.mjs"
 	import {API} from 'api'
 	import {Sync} from 'sync'
+	import { } from '/js/{{ .VERSION }}/page_node.mjs'
 	import { } from '/js/{{ .VERSION }}/page_preferences.mjs'
 	import { } from '/js/{{ .VERSION }}/page_storage.mjs'
 	import { } from '/js/{{ .VERSION }}/page_history.mjs'
 	import { } from '/js/{{ .VERSION }}/file.mjs'
 
-	window.Sync = Sync
+	globalThis.Sync = Sync
 
 	if (!API.hasAuthenticationToken()) {
 		location.href = '/login'
 	} else {
 		try {
-			window.nodeStore = new NodeStore()
-			window.nodeStore.initializeDB().then(() => {
-				window._app = new App()
+			globalThis.nodeStore = new NodeStore()
+			globalThis.nodeStore.initializeDB().then(() => {
+				globalThis._app = new App()
 			})
 		} catch (e) {
 			alert(e)
diff --git a/views/pages/sync.gotmpl b/views/pages/sync.gotmpl
index eb79c77..c9fa870 100644
--- a/views/pages/sync.gotmpl
+++ b/views/pages/sync.gotmpl
@@ -5,9 +5,9 @@
 	<script type="module">
 		import { NodeStore } from 'node_store'
 		import { Sync } from 'sync'
-		window.Sync = Sync
-		window.nodeStore = new NodeStore()
-		window.nodeStore.initializeDB().then(()=>{
+		globalThis.Sync = Sync
+		globalThis.nodeStore = new NodeStore()
+		globalThis.nodeStore.initializeDB().then(()=>{
 			Sync.tree()
 		})
 	</script>