@fc3/mmcadi 0.1.48 → 0.1.50

package/dist/client.js

@@ -259,9 +259,9 @@
       };
       Object.defineProperty(exports, "__esModule", { value: true });
       var generic_1 = __importDefault(require_generic());
-      var InvariantViolation12 = class extends generic_1.default {
+      var InvariantViolation14 = class extends generic_1.default {
       };
-      exports.default = InvariantViolation12;
+      exports.default = InvariantViolation14;
     }
   });
 
@@ -888,10 +888,10 @@
     "node_modules/@fc3/array/dist/src/get-first-value.js"(exports) {
       "use strict";
       Object.defineProperty(exports, "__esModule", { value: true });
-      function getFirstValue3(array) {
+      function getFirstValue2(array) {
         return array[0];
       }
-      exports.default = getFirstValue3;
+      exports.default = getFirstValue2;
     }
   });
 
@@ -963,8 +963,769 @@
     }
   });
 
+  // node_modules/@fc3/time/dist/src/enum/time-interval.js
+  var require_time_interval = __commonJS({
+    "node_modules/@fc3/time/dist/src/enum/time-interval.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      var TimeInterval2;
+      (function(TimeInterval3) {
+        TimeInterval3[TimeInterval3["ONE_FRAME"] = 16] = "ONE_FRAME";
+        TimeInterval3[TimeInterval3["ONE_SECOND"] = 1e3] = "ONE_SECOND";
+        TimeInterval3[TimeInterval3["ONE_MINUTE"] = 6e4] = "ONE_MINUTE";
+        TimeInterval3[TimeInterval3["ONE_HOUR"] = 36e5] = "ONE_HOUR";
+        TimeInterval3[TimeInterval3["ONE_DAY"] = 864e5] = "ONE_DAY";
+        TimeInterval3[TimeInterval3["ONE_WEEK"] = 6048e5] = "ONE_WEEK";
+        TimeInterval3[TimeInterval3["ONE_MONTH"] = 2592e6] = "ONE_MONTH";
+        TimeInterval3[TimeInterval3["ONE_YEAR"] = 31536e6] = "ONE_YEAR";
+      })(TimeInterval2 || (TimeInterval2 = {}));
+      exports.default = TimeInterval2;
+    }
+  });
+
+  // node_modules/@fc3/time/dist/src/utility/sleep.js
+  var require_sleep = __commonJS({
+    "node_modules/@fc3/time/dist/src/utility/sleep.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      function sleep(duration) {
+        return new Promise((resolve) => {
+          setTimeout(() => {
+            resolve();
+          }, duration);
+        });
+      }
+      exports.default = sleep;
+    }
+  });
+
+  // node_modules/@fc3/grammar/dist/src/noun-inflector.js
+  var require_noun_inflector = __commonJS({
+    "node_modules/@fc3/grammar/dist/src/noun-inflector.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      var SINGULAR_TO_PLURAL_MAP = {
+        loot: "loot"
+      };
+      var NounInflector = class {
+        singularize(plural_form) {
+          for (const singular_key in SINGULAR_TO_PLURAL_MAP) {
+            if (SINGULAR_TO_PLURAL_MAP[singular_key] === plural_form) {
+              return singular_key;
+            }
+          }
+          if (plural_form.slice(-3) === "ies") {
+            return plural_form.slice(0, -3) + "y";
+          }
+          if (plural_form.slice(-1) === "i") {
+            return plural_form.slice(0, -1) + "us";
+          }
+          if (plural_form.slice(-1) === "s") {
+            return plural_form.slice(0, -1);
+          }
+          return plural_form;
+        }
+        pluralize(singular_form) {
+          if (SINGULAR_TO_PLURAL_MAP[singular_form] !== void 0) {
+            return SINGULAR_TO_PLURAL_MAP[singular_form];
+          }
+          if (singular_form.slice(-1) === "y") {
+            if (!this.isVowel(singular_form.slice(-2, -1))) {
+              return singular_form.slice(0, -1) + "ies";
+            }
+          }
+          if (singular_form.slice(-2) === "ch") {
+            return singular_form + "es";
+          }
+          if (singular_form.slice(-2) === "us") {
+            return singular_form.slice(0, -2) + "i";
+          }
+          if (singular_form.slice(-2) === "ss") {
+            return singular_form + "es";
+          }
+          if (singular_form === "life") {
+            return "lives";
+          }
+          return singular_form + "s";
+        }
+        /**
+         * Takes a number, and a singular suffix noun, and returns the correctly
+         * formatted result for the given number.
+         *
+         * Example:
+         *
+         *    singularizeOrPluralize(1, 'account')   =>   '1 account'
+         *    singularizeOrPluralize(6, 'account')   =>   '6 accounts'
+         */
+        singularizeOrPluralize(amount, suffix) {
+          if (typeof amount === "string") {
+            amount = parseFloat(amount);
+          }
+          if (amount === 1) {
+            return `${amount} ${suffix}`;
+          }
+          const plural_suffix = this.pluralize(suffix);
+          return `${amount} ${plural_suffix}`;
+        }
+        prependArticle(suffix) {
+          const first_letter = suffix[0];
+          const is_vowel = this.isVowel(first_letter);
+          let article;
+          if (is_vowel) {
+            article = "an";
+          } else {
+            article = "a";
+          }
+          return `${article} ${suffix}`;
+        }
+        isVowel(letter) {
+          return /[aeiou]/.test(letter.toLowerCase());
+        }
+      };
+      exports.default = NounInflector;
+    }
+  });
+
+  // node_modules/@fc3/string/dist/src/create-slug.js
+  var require_create_slug = __commonJS({
+    "node_modules/@fc3/string/dist/src/create-slug.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      function createSlug(message) {
+        if (message === "") {
+          throw new Error("Tried to create slug, but message was empty");
+        }
+        return message.replace(/[^A-Za-z0-9-\s_]/g, "").trim().replace(/[\s_]/g, "-").toLowerCase();
+      }
+      exports.default = createSlug;
+    }
+  });
+
+  // node_modules/@fc3/string/dist/src/capitalize.js
+  var require_capitalize = __commonJS({
+    "node_modules/@fc3/string/dist/src/capitalize.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      function capitalize(str) {
+        const first_character = str[0];
+        const remaining_characters = str.slice(1);
+        return first_character.toUpperCase() + remaining_characters;
+      }
+      exports.default = capitalize;
+    }
+  });
+
+  // node_modules/@fc3/string/dist/src/enum/string-encoding.js
+  var require_string_encoding = __commonJS({
+    "node_modules/@fc3/string/dist/src/enum/string-encoding.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      var StringEncoding;
+      (function(StringEncoding2) {
+        StringEncoding2["ASCII"] = "ascii";
+        StringEncoding2["BASE64"] = "base64";
+        StringEncoding2["BINARY"] = "binary";
+        StringEncoding2["HEX"] = "hex";
+        StringEncoding2["UTF8"] = "utf8";
+      })(StringEncoding || (StringEncoding = {}));
+      exports.default = StringEncoding;
+    }
+  });
+
+  // node_modules/@fc3/string/dist/src/index.js
+  var require_src4 = __commonJS({
+    "node_modules/@fc3/string/dist/src/index.js"(exports) {
+      "use strict";
+      var __importDefault = exports && exports.__importDefault || function(mod) {
+        return mod && mod.__esModule ? mod : { "default": mod };
+      };
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.StringEncoding = exports.capitalize = exports.createSlug = void 0;
+      var create_slug_1 = require_create_slug();
+      Object.defineProperty(exports, "createSlug", { enumerable: true, get: function() {
+        return __importDefault(create_slug_1).default;
+      } });
+      var capitalize_1 = require_capitalize();
+      Object.defineProperty(exports, "capitalize", { enumerable: true, get: function() {
+        return __importDefault(capitalize_1).default;
+      } });
+      var string_encoding_1 = require_string_encoding();
+      Object.defineProperty(exports, "StringEncoding", { enumerable: true, get: function() {
+        return __importDefault(string_encoding_1).default;
+      } });
+    }
+  });
+
+  // node_modules/@fc3/grammar/dist/src/verb-inflector.js
+  var require_verb_inflector = __commonJS({
+    "node_modules/@fc3/grammar/dist/src/verb-inflector.js"(exports) {
+      "use strict";
+      var __importDefault = exports && exports.__importDefault || function(mod) {
+        return mod && mod.__esModule ? mod : { "default": mod };
+      };
+      Object.defineProperty(exports, "__esModule", { value: true });
+      var string_1 = require_src4();
+      var noun_inflector_1 = __importDefault(require_noun_inflector());
+      var VerbInflector = class {
+        constructor(value) {
+          this.value = value;
+          const index = value.indexOf(" ");
+          if (index !== -1) {
+            this.suffix = value.slice(index);
+            value = value.slice(0, index);
+          } else {
+            this.suffix = "";
+          }
+          this.uppercase = value !== value.toLowerCase();
+          this.verb = value.toLowerCase();
+        }
+        toPresentParticiple() {
+          if (this.verb === "group") {
+            return this.finalize("grouping");
+          }
+          if (this.verb === "be") {
+            return this.finalize("being");
+          }
+          if (/[aeiou]p$/.test(this.verb)) {
+            return this.finalize(this.verb + "ping");
+          }
+          if (/[aeiou]g$/.test(this.verb)) {
+            return this.finalize(this.verb + "ging");
+          }
+          if (/ee$/.test(this.verb)) {
+            return this.finalize(this.verb + "ing");
+          }
+          if (/e$/.test(this.verb)) {
+            return this.finalize(this.verb.slice(0, -1) + "ing");
+          }
+          if (/[aeiou]n$/.test(this.verb)) {
+            return this.finalize(this.verb + "ning");
+          }
+          if (/[aeiou]t$/.test(this.verb)) {
+            return this.finalize(this.verb + "ting");
+          }
+          return this.finalize(this.verb + "ing");
+        }
+        toPastParticiple() {
+          switch (this.verb) {
+            case "choose":
+              return this.finalize("chosen");
+            default:
+              return this.toPastTense();
+          }
+        }
+        toInfinitive() {
+          return this.finalize(`to ${this.verb}`);
+        }
+        toAdjective() {
+          if (this.value.startsWith("be ")) {
+            return this.value.slice(3);
+          } else {
+            return this.finalize(this.verb + "y");
+          }
+        }
+        toPresentTense() {
+          switch (this.verb) {
+            case "be":
+              return this.finalize("is");
+            default:
+              return this.finalize(this.verb);
+          }
+        }
+        toImperfectTense() {
+          const participle = this.toPresentParticiple();
+          return this.finalize(`was ${participle}`);
+        }
+        toPastTense() {
+          switch (this.verb) {
+            case "find":
+              return this.finalize("found");
+            case "get":
+              return this.finalize("got");
+            case "run":
+              return this.finalize("ran");
+            case "read":
+              return this.finalize("read");
+            case "write":
+              return this.finalize("wrote");
+            case "choose":
+              return this.finalize("chose");
+            case "build":
+              return this.finalize("built");
+          }
+          if (/[aeiou]p$/.test(this.verb)) {
+            return this.finalize(this.verb + "ped");
+          }
+          if (/[aeiou]g$/.test(this.verb)) {
+            return this.finalize(this.verb + "ged");
+          }
+          if (this.verb === "be") {
+            return this.finalize("was");
+          }
+          if (this.verb === "draw") {
+            return this.finalize("drew");
+          }
+          if (/e$/.test(this.verb)) {
+            return this.finalize(this.verb + "d");
+          }
+          if (/[aeiou]y$/.test(this.verb)) {
+            return this.finalize(this.verb + "ed");
+          }
+          if (/y$/.test(this.verb)) {
+            return this.finalize(this.verb.slice(0, -1) + "ied");
+          }
+          return this.finalize(this.verb + "ed");
+        }
+        toFutureTense() {
+          return this.finalize(`will ${this.verb}`);
+        }
+        toSingularNoun() {
+          switch (this.verb) {
+            case "cut":
+              return this.finalize("cut");
+            case "die":
+              return this.finalize("death");
+            case "live":
+              return this.finalize("life");
+            case "change":
+              return this.finalize("change");
+            case "make water":
+              return this.finalize("water");
+            case "do":
+              return this.finalize("action");
+            case "protect":
+              return this.finalize("protection");
+            case "affirm":
+              return this.finalize("affirmation");
+            case "choose":
+              return this.finalize("choice");
+            case "collide":
+              return this.finalize("collision");
+            case "encase":
+              return this.finalize("casing");
+            case "darken":
+              return this.finalize("shadow");
+            case "damage":
+              return this.finalize("damage");
+            case "define":
+              return this.finalize("definition");
+            case "describe":
+              return this.finalize("description");
+            case "hear":
+              return this.finalize("sound");
+            case "measure":
+              return this.finalize("measurement");
+            case "rate":
+              return this.finalize("rating");
+            case "move":
+              return this.finalize("movement");
+            case "regard":
+              return this.finalize("regard");
+            case "survey":
+              return this.finalize("area");
+            case "interact":
+              return this.finalize("interaction");
+            case "name":
+              return this.finalize("name");
+            case "speak":
+              return this.finalize("speech");
+            case "count":
+              return this.finalize("number");
+            case "reside":
+              return this.finalize("residence");
+            case "know":
+              return this.finalize("knowledge");
+            case "divide":
+              return this.finalize("division");
+            case "void":
+              return this.finalize("void");
+            case "make":
+              switch (this.value) {
+                case "make music":
+                  return "music";
+                case "make noise":
+                  return "noise";
+                default:
+                  return this.suffix.slice(1);
+              }
+            case "breathe":
+              return this.finalize("breath");
+            case "have":
+              return this.finalize("belonging");
+            case "bear":
+              if (this.suffix === " fruit") {
+                return "fruit";
+              }
+            case "dream":
+              return "dream";
+            case "test":
+              return "test";
+            case "prepare":
+              return "preparation";
+            case "ascend":
+              return "ascension";
+            case "sleep":
+              return "sleep";
+            default:
+              if (this.verb.slice(-2) === "te") {
+                return this.finalize(this.verb.slice(0, -2) + "tion");
+              }
+              return this.finalize(this.toPresentParticiple());
+          }
+        }
+        toPluralNoun() {
+          const inflector = new noun_inflector_1.default();
+          const singular = this.toSingularNoun();
+          return this.finalize(inflector.pluralize(singular));
+        }
+        toSingularActor() {
+          switch (this.verb) {
+            case "be":
+              return this.finalize("being");
+          }
+          if (this.verb.endsWith("ate")) {
+            return this.finalize(`${this.verb.slice(0, -1)}or`);
+          }
+          if (this.verb.endsWith("e")) {
+            return this.finalize(`${this.verb}r`);
+          }
+          if (this.verb.endsWith("ct")) {
+            return this.finalize(`${this.verb}or`);
+          }
+          return this.finalize(`${this.verb}er`);
+        }
+        toPluralActor() {
+          const singular_actor = this.toSingularActor();
+          const inflector = new noun_inflector_1.default();
+          return this.finalize(inflector.pluralize(singular_actor));
+        }
+        finalize(value) {
+          value += this.suffix;
+          if (this.uppercase) {
+            return (0, string_1.capitalize)(value);
+          } else {
+            return value.toLowerCase();
+          }
+        }
+      };
+      exports.default = VerbInflector;
+    }
+  });
+
+  // node_modules/@fc3/grammar/dist/src/utility/get-words-from-identifier.js
+  var require_get_words_from_identifier = __commonJS({
+    "node_modules/@fc3/grammar/dist/src/utility/get-words-from-identifier.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      function getWordsFromIdentifier(identifier) {
+        const delimited_identifier = identifier.replace(/[a-z][A-Z]/g, (match) => {
+          return match[0] + "_" + match[1];
+        });
+        return delimited_identifier.split("_");
+      }
+      exports.default = getWordsFromIdentifier;
+    }
+  });
+
+  // node_modules/@fc3/grammar/dist/src/utility/singularize.js
+  var require_singularize = __commonJS({
+    "node_modules/@fc3/grammar/dist/src/utility/singularize.js"(exports) {
+      "use strict";
+      var __importDefault = exports && exports.__importDefault || function(mod) {
+        return mod && mod.__esModule ? mod : { "default": mod };
+      };
+      Object.defineProperty(exports, "__esModule", { value: true });
+      var noun_inflector_1 = __importDefault(require_noun_inflector());
+      function singularize(word) {
+        const inflector = new noun_inflector_1.default();
+        return inflector.singularize(word);
+      }
+      exports.default = singularize;
+    }
+  });
+
+  // node_modules/@fc3/grammar/dist/src/utility/pluralize.js
+  var require_pluralize = __commonJS({
+    "node_modules/@fc3/grammar/dist/src/utility/pluralize.js"(exports) {
+      "use strict";
+      var __importDefault = exports && exports.__importDefault || function(mod) {
+        return mod && mod.__esModule ? mod : { "default": mod };
+      };
+      Object.defineProperty(exports, "__esModule", { value: true });
+      var noun_inflector_1 = __importDefault(require_noun_inflector());
+      function pluralize(word) {
+        const inflector = new noun_inflector_1.default();
+        return inflector.pluralize(word);
+      }
+      exports.default = pluralize;
+    }
+  });
+
+  // node_modules/@fc3/grammar/dist/src/utility/singularize-or-pluralize.js
+  var require_singularize_or_pluralize = __commonJS({
+    "node_modules/@fc3/grammar/dist/src/utility/singularize-or-pluralize.js"(exports) {
+      "use strict";
+      var __importDefault = exports && exports.__importDefault || function(mod) {
+        return mod && mod.__esModule ? mod : { "default": mod };
+      };
+      Object.defineProperty(exports, "__esModule", { value: true });
+      var noun_inflector_1 = __importDefault(require_noun_inflector());
+      function singularizeOrPluralize(count, word) {
+        const inflector = new noun_inflector_1.default();
+        return inflector.singularizeOrPluralize(count, word);
+      }
+      exports.default = singularizeOrPluralize;
+    }
+  });
+
+  // node_modules/@fc3/grammar/dist/src/index.js
+  var require_src5 = __commonJS({
+    "node_modules/@fc3/grammar/dist/src/index.js"(exports) {
+      "use strict";
+      var __importDefault = exports && exports.__importDefault || function(mod) {
+        return mod && mod.__esModule ? mod : { "default": mod };
+      };
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.singularizeOrPluralize = exports.pluralize = exports.singularize = exports.getWordsFromIdentifier = exports.VerbInflector = exports.NounInflector = void 0;
+      var noun_inflector_1 = require_noun_inflector();
+      Object.defineProperty(exports, "NounInflector", { enumerable: true, get: function() {
+        return __importDefault(noun_inflector_1).default;
+      } });
+      var verb_inflector_1 = require_verb_inflector();
+      Object.defineProperty(exports, "VerbInflector", { enumerable: true, get: function() {
+        return __importDefault(verb_inflector_1).default;
+      } });
+      var get_words_from_identifier_1 = require_get_words_from_identifier();
+      Object.defineProperty(exports, "getWordsFromIdentifier", { enumerable: true, get: function() {
+        return __importDefault(get_words_from_identifier_1).default;
+      } });
+      var singularize_1 = require_singularize();
+      Object.defineProperty(exports, "singularize", { enumerable: true, get: function() {
+        return __importDefault(singularize_1).default;
+      } });
+      var pluralize_1 = require_pluralize();
+      Object.defineProperty(exports, "pluralize", { enumerable: true, get: function() {
+        return __importDefault(pluralize_1).default;
+      } });
+      var singularize_or_pluralize_1 = require_singularize_or_pluralize();
+      Object.defineProperty(exports, "singularizeOrPluralize", { enumerable: true, get: function() {
+        return __importDefault(singularize_or_pluralize_1).default;
+      } });
+    }
+  });
+
+  // node_modules/@fc3/time/dist/src/utility/format-duration.js
+  var require_format_duration = __commonJS({
+    "node_modules/@fc3/time/dist/src/utility/format-duration.js"(exports) {
+      "use strict";
+      var __importDefault = exports && exports.__importDefault || function(mod) {
+        return mod && mod.__esModule ? mod : { "default": mod };
+      };
+      Object.defineProperty(exports, "__esModule", { value: true });
+      var grammar_1 = require_src5();
+      var time_interval_1 = __importDefault(require_time_interval());
+      function formatMilliseconds(ms, shorthand = false) {
+        if (shorthand) {
+          return `${ms}ms`;
+        }
+        const inflector = new grammar_1.NounInflector();
+        return inflector.singularizeOrPluralize(ms, "millisecond");
+      }
+      function formatSeconds(ms, shorthand = false) {
+        const seconds = Math.floor(ms / time_interval_1.default.ONE_SECOND);
+        if (shorthand) {
+          return `${seconds}s`;
+        }
+        const inflector = new grammar_1.NounInflector();
+        return inflector.singularizeOrPluralize(seconds, "second");
+      }
+      function formatMinutes(ms, shorthand = false) {
+        const minutes = Math.floor(ms / time_interval_1.default.ONE_MINUTE);
+        if (shorthand) {
+          return `${minutes}m`;
+        }
+        const inflector = new grammar_1.NounInflector();
+        return inflector.singularizeOrPluralize(minutes, "minute");
+      }
+      function formatHours(ms, shorthand = false) {
+        const hours = Math.floor(ms / time_interval_1.default.ONE_HOUR);
+        if (shorthand) {
+          return `${hours}h`;
+        }
+        const inflector = new grammar_1.NounInflector();
+        return inflector.singularizeOrPluralize(hours, "hour");
+      }
+      function formatDays(ms, shorthand = false) {
+        const days = Math.floor(ms / time_interval_1.default.ONE_DAY);
+        if (shorthand) {
+          return `${days}d`;
+        }
+        const inflector = new grammar_1.NounInflector();
+        return inflector.singularizeOrPluralize(days, "day");
+      }
+      function formatWeeks(ms, shorthand = false) {
+        const weeks = Math.floor(ms / time_interval_1.default.ONE_WEEK);
+        if (shorthand) {
+          return `${weeks}w`;
+        }
+        const inflector = new grammar_1.NounInflector();
+        return inflector.singularizeOrPluralize(weeks, "week");
+      }
+      function formatMonths(ms, shorthand = false) {
+        const months = Math.floor(ms / time_interval_1.default.ONE_MONTH);
+        if (shorthand) {
+          return `${months}mo`;
+        }
+        const inflector = new grammar_1.NounInflector();
+        return inflector.singularizeOrPluralize(months, "month");
+      }
+      function formatYears(ms, shorthand = false) {
+        let years = ms / time_interval_1.default.ONE_YEAR;
+        const years_rounded = Math.round(years);
+        if (Math.abs(years - years_rounded) < 1 / 24) {
+          years = years_rounded;
+        } else {
+          years = parseFloat(years.toFixed(1));
+        }
+        if (shorthand) {
+          return `${years}y`;
+        }
+        const inflector = new grammar_1.NounInflector();
+        return inflector.singularizeOrPluralize(years, "year");
+      }
+      function formatDuration(ms, shorthand = false) {
+        if (ms < time_interval_1.default.ONE_SECOND) {
+          return formatMilliseconds(ms, shorthand);
+        }
+        if (ms < time_interval_1.default.ONE_MINUTE) {
+          return formatSeconds(ms, shorthand);
+        }
+        if (ms < time_interval_1.default.ONE_HOUR) {
+          return formatMinutes(ms, shorthand);
+        }
+        if (ms < time_interval_1.default.ONE_DAY) {
+          return formatHours(ms, shorthand);
+        }
+        if (ms < time_interval_1.default.ONE_WEEK) {
+          return formatDays(ms, shorthand);
+        }
+        if (ms < time_interval_1.default.ONE_MONTH) {
+          return formatWeeks(ms, shorthand);
+        }
+        if (ms < time_interval_1.default.ONE_YEAR) {
+          return formatMonths(ms, shorthand);
+        }
+        return formatYears(ms, shorthand);
+      }
+      exports.default = formatDuration;
+    }
+  });
+
+  // node_modules/@fc3/time/dist/src/utility/format-relative-duration.js
+  var require_format_relative_duration = __commonJS({
+    "node_modules/@fc3/time/dist/src/utility/format-relative-duration.js"(exports) {
+      "use strict";
+      var __importDefault = exports && exports.__importDefault || function(mod) {
+        return mod && mod.__esModule ? mod : { "default": mod };
+      };
+      Object.defineProperty(exports, "__esModule", { value: true });
+      var format_duration_1 = __importDefault(require_format_duration());
+      function formatRelativeDuration(date, shorthand = false) {
+        let ms;
+        if (date instanceof Date) {
+          ms = date.getTime();
+        } else if (typeof date === "string") {
+          ms = new Date(date).getTime();
+        } else {
+          ms = date;
+        }
+        const elapsed_time = Date.now() - ms;
+        return (0, format_duration_1.default)(elapsed_time, shorthand);
+      }
+      exports.default = formatRelativeDuration;
+    }
+  });
+
+  // node_modules/@fc3/time/dist/src/utility/format-relative-date.js
+  var require_format_relative_date = __commonJS({
+    "node_modules/@fc3/time/dist/src/utility/format-relative-date.js"(exports) {
+      "use strict";
+      var __importDefault = exports && exports.__importDefault || function(mod) {
+        return mod && mod.__esModule ? mod : { "default": mod };
+      };
+      Object.defineProperty(exports, "__esModule", { value: true });
+      var format_relative_duration_1 = __importDefault(require_format_relative_duration());
+      function formatRelativeDate(ms) {
+        return (0, format_relative_duration_1.default)(ms) + " ago";
+      }
+      exports.default = formatRelativeDate;
+    }
+  });
+
+  // node_modules/@fc3/time/dist/src/utility/format-timecode.js
+  var require_format_timecode = __commonJS({
+    "node_modules/@fc3/time/dist/src/utility/format-timecode.js"(exports) {
+      "use strict";
+      var __importDefault = exports && exports.__importDefault || function(mod) {
+        return mod && mod.__esModule ? mod : { "default": mod };
+      };
+      Object.defineProperty(exports, "__esModule", { value: true });
+      var time_interval_1 = __importDefault(require_time_interval());
+      function formatTimecode2(ms) {
+        const hours = Math.floor(ms / time_interval_1.default.ONE_HOUR);
+        const leftover_hours = ms % time_interval_1.default.ONE_HOUR;
+        const minutes = Math.floor(leftover_hours / time_interval_1.default.ONE_MINUTE);
+        const leftover_minutes = ms % time_interval_1.default.ONE_MINUTE;
+        const seconds = Math.floor(leftover_minutes / time_interval_1.default.ONE_SECOND);
+        const padded_seconds = seconds.toString().padStart(2, "0");
+        if (hours > 0) {
+          const padded_minutes = minutes.toString().padStart(2, "0");
+          return `${hours}:${padded_minutes}:${padded_seconds}`;
+        }
+        return `${minutes}:${padded_seconds}`;
+      }
+      exports.default = formatTimecode2;
+    }
+  });
+
+  // node_modules/@fc3/time/dist/src/index.js
+  var require_src6 = __commonJS({
+    "node_modules/@fc3/time/dist/src/index.js"(exports) {
+      "use strict";
+      var __importDefault = exports && exports.__importDefault || function(mod) {
+        return mod && mod.__esModule ? mod : { "default": mod };
+      };
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.formatTimecode = exports.formatDuration = exports.formatRelativeDate = exports.formatRelativeDuration = exports.sleep = exports.TimeInterval = void 0;
+      var time_interval_1 = require_time_interval();
+      Object.defineProperty(exports, "TimeInterval", { enumerable: true, get: function() {
+        return __importDefault(time_interval_1).default;
+      } });
+      var sleep_1 = require_sleep();
+      Object.defineProperty(exports, "sleep", { enumerable: true, get: function() {
+        return __importDefault(sleep_1).default;
+      } });
+      var format_relative_duration_1 = require_format_relative_duration();
+      Object.defineProperty(exports, "formatRelativeDuration", { enumerable: true, get: function() {
+        return __importDefault(format_relative_duration_1).default;
+      } });
+      var format_relative_date_1 = require_format_relative_date();
+      Object.defineProperty(exports, "formatRelativeDate", { enumerable: true, get: function() {
+        return __importDefault(format_relative_date_1).default;
+      } });
+      var format_duration_1 = require_format_duration();
+      Object.defineProperty(exports, "formatDuration", { enumerable: true, get: function() {
+        return __importDefault(format_duration_1).default;
+      } });
+      var format_timecode_1 = require_format_timecode();
+      Object.defineProperty(exports, "formatTimecode", { enumerable: true, get: function() {
+        return __importDefault(format_timecode_1).default;
+      } });
+    }
+  });
+
   // src/client/client.ts
-  var import_errors12 = __toESM(require_src2());
+  var import_errors14 = __toESM(require_src2());
 
   // src/client/enum/page-type.ts
   var PageType = /* @__PURE__ */ ((PageType2) => {
@@ -993,9 +1754,6 @@
   })(PageType || {});
   var page_type_default = PageType;
 
-  // src/client/page.ts
-  var import_array = __toESM(require_src3());
-
   // src/client/enum/key-code.ts
   var KeyCode = /* @__PURE__ */ ((KeyCode2) => {
     KeyCode2[KeyCode2["ENTER"] = 13] = "ENTER";
@@ -1071,20 +1829,33 @@
       return this.shift_pressed;
     }
     focusElement(element) {
-      const rectangle = element.getBoundingClientRect();
-      const headers = Array.from(document.getElementsByTagName("header"));
-      const header = (0, import_array.getFirstValue)(headers);
-      const header_offset = header === void 0 ? 0 : header.clientHeight;
-      if (rectangle.top < header_offset) {
-        if (header_offset === 0) {
-          window.scrollBy(0, rectangle.top);
+      let current_top = 0;
+      let current_element = element;
+      while (current_element) {
+        current_top += current_element.offsetTop;
+        current_element = current_element.offsetParent;
+      }
+      const current_bottom = current_top + element.offsetHeight;
+      const [target_top, viewport_min] = (() => {
+        const header = document.querySelector("header");
+        if (header === null) {
+          return [
+            current_top,
+            window.scrollY
+          ];
         } else {
-          window.scrollBy(0, -1 * (header_offset - rectangle.top));
-        }
-      } else if (rectangle.bottom > window.innerHeight) {
-        if (rectangle.height < window.innerHeight) {
-          window.scrollBy(0, rectangle.bottom - window.innerHeight);
+          return [
+            current_top - header.offsetHeight,
+            window.scrollY + header.offsetHeight
+          ];
         }
+      })();
+      const viewport_max = window.scrollY + window.innerHeight;
+      if (current_top < viewport_min) {
+        window.scrollTo(0, target_top);
+      }
+      if (current_bottom > viewport_max) {
+        window.scrollTo(0, current_bottom - window.innerHeight);
       }
     }
     getNumericQueryParameter(key, fallback) {
@@ -1385,115 +2156,937 @@
           return super.handleKey(key_code);
       }
     }
-    createBlockOfType(block_type) {
-      const id = `add-block-${block_type}`;
-      const element = document.getElementById(id);
-      if (element === null) {
-        throw new import_errors4.InvariantViolation(`
-				Tried to create block of type ${block_type},
-				but the creation link was not found
-			`);
+    createBlockOfType(block_type) {
+      const id = `add-block-${block_type}`;
+      const element = document.getElementById(id);
+      if (element === null) {
+        throw new import_errors4.InvariantViolation(`
+				Tried to create block of type ${block_type},
+				but the creation link was not found
+			`);
+      }
+      const href = element.getAttribute("href");
+      if (href === null) {
+        throw new import_errors4.InvariantViolation(`
+				Tried to create block of type ${block_type},
+				but the creation href was not present on the link element
+			`);
+      }
+      window.location.href = href;
+    }
+  };
+  var select_block_type_default = SelectBlockTypePage;
+
+  // src/client/page/cursor.ts
+  var import_errors9 = __toESM(require_src2());
+  var import_array = __toESM(require_src3());
+  var import_time = __toESM(require_src6());
+
+  // src/client/utility/get-meta-value.ts
+  var import_errors5 = __toESM(require_src2());
+  function getMetaValue(name) {
+    const element = document.querySelector(`meta[name="${name}"]`);
+    if (element === null) {
+      throw new import_errors5.InvariantViolation(`
+			Tried to read ${name} meta tag, but it was not set
+		`);
+    }
+    if (!(element instanceof HTMLMetaElement)) {
+      throw new import_errors5.InvariantViolation(`
+			Got wrong element for ${name} meta tag: ${element.tagName}
+		`);
+    }
+    const meta_tag = element;
+    return meta_tag.content;
+  }
+  var get_meta_value_default = getMetaValue;
+
+  // src/server/utility/validate-path.ts
+  var import_errors6 = __toESM(require_src2());
+  function validatePath(path) {
+    if (!path.startsWith("/")) {
+      throw new import_errors6.InvalidError(`Invalid path: ${path}`);
+    }
+  }
+  var validate_path_default = validatePath;
+
+  // src/common/utility/get-parent-path.ts
+  function getParentPath(source_path) {
+    validate_path_default(source_path);
+    const query_index = source_path.indexOf("?");
+    if (query_index !== -1) {
+      source_path = source_path.slice(0, query_index);
+    }
+    if (source_path.endsWith("/")) {
+      source_path = source_path.slice(0, -1);
+    }
+    const parts = source_path.split("/").filter((part) => {
+      return part !== "";
+    });
+    parts.pop();
+    if (parts.length === 0) {
+      return "/";
+    }
+    return "/" + parts.join("/");
+  }
+  var get_parent_path_default = getParentPath;
+
+  // src/client/enum/media-ready-state.ts
+  var MediaReadyState = /* @__PURE__ */ ((MediaReadyState2) => {
+    MediaReadyState2[MediaReadyState2["HAVE_NOTHING"] = 0] = "HAVE_NOTHING";
+    MediaReadyState2[MediaReadyState2["HAVE_METADATA"] = 1] = "HAVE_METADATA";
+    MediaReadyState2[MediaReadyState2["HAVE_CURRENT_DATA"] = 2] = "HAVE_CURRENT_DATA";
+    MediaReadyState2[MediaReadyState2["HAVE_FUTURE_DATA"] = 3] = "HAVE_FUTURE_DATA";
+    MediaReadyState2[MediaReadyState2["HAVE_ENOUGH_DATA"] = 4] = "HAVE_ENOUGH_DATA";
+    return MediaReadyState2;
+  })(MediaReadyState || {});
+  var media_ready_state_default = MediaReadyState;
+
+  // src/client/helper/interaction.ts
+  var import_errors8 = __toESM(require_src2());
+
+  // src/enum/action-type.ts
+  var ActionType = /* @__PURE__ */ ((ActionType2) => {
+    ActionType2["ADD_BLOCK"] = "add_block";
+    ActionType2["DELETE_BLOCK"] = "delete_block";
+    ActionType2["MOVE_BLOCK"] = "move_block";
+    ActionType2["HIDE_BLOCK"] = "hide_block";
+    ActionType2["PROMOTE_BLOCK"] = "promote_block";
+    ActionType2["DEMOTE_BLOCK"] = "demote_block";
+    ActionType2["REPOSITION_BLOCK"] = "reposition_block";
+    ActionType2["EDIT_BLOCK"] = "edit_block";
+    ActionType2["CREATE_PAGE"] = "create_page";
+    ActionType2["COMPLETE_BLOCK"] = "complete_block";
+    ActionType2["ADD_BLOCK_TO_PLAYLIST"] = "add_to_playlist";
+    return ActionType2;
+  })(ActionType || {});
+  var action_type_default = ActionType;
+
+  // src/enum/emoji.ts
+  var Emoji = /* @__PURE__ */ ((Emoji2) => {
+    Emoji2["USER_PORTRAIT"] = "\u{1F464}";
+    Emoji2["WARNING_SIGN"] = "\u26A0\uFE0F";
+    Emoji2["BAR_CHART"] = "\u{1F4CA}";
+    Emoji2["FOLDER"] = "\u{1F5C2}\uFE0F";
+    Emoji2["FILE"] = "\u{1F4C4}";
+    Emoji2["HOUSE"] = "\u{1F3E0}";
+    Emoji2["NONE"] = "\u{1F6AB}";
+    Emoji2["WHITE_SQUARE"] = "\u2B1C";
+    Emoji2["GRID_GLOBE"] = "\u{1F310}";
+    Emoji2["SATELLITE_DISH"] = "\u{1F4E1}";
+    Emoji2["COMPLETED_CHECKMARK"] = "\u2705";
+    Emoji2["RED_X"] = "\u274C";
+    Emoji2["CLOCK"] = "\u{1F552}";
+    Emoji2["SUNSHINE"] = "\u{1F506}";
+    Emoji2["ALARM_CLOCK"] = "\u23F0";
+    Emoji2["MAGNIFYING_GLASS"] = "\u{1F50E}";
+    Emoji2["MAGIC_WAND"] = "\u{1FA84}";
+    Emoji2["CALENDAR"] = "\u{1F4C5}";
+    Emoji2["LOCKED"] = "\u{1F512}";
+    Emoji2["UNLOCKED"] = "\u{1F513}";
+    Emoji2["NORTHWEST_ARROW"] = "\u2196\uFE0F";
+    Emoji2["RIGHT_ARROW"] = "\u27A1\uFE0F";
+    Emoji2["LEFT_ARROW"] = "\u2B05\uFE0F";
+    Emoji2["UP_ARROW"] = "\u2B06\uFE0F";
+    Emoji2["UP_DOWN_ARROW"] = "\u2195\uFE0F";
+    Emoji2["LEFT_ARROW_UNICODE"] = "\u25C4";
+    Emoji2["UP_ARROW_UNICODE"] = "\u25B2";
+    Emoji2["RIGHT_ARROW_UNICODE"] = "\u25BA";
+    Emoji2["DOWN_ARROW_UNICODE"] = "\u25BC";
+    Emoji2["BRICK"] = "\u{1F9F1}";
+    Emoji2["RULER"] = "\u{1F4D0}";
+    Emoji2["SWORD"] = "\u{1F5E1}\uFE0F";
+    Emoji2["PEACE_SIGN"] = "\u270C\uFE0F";
+    Emoji2["SIGN"] = "\u{1FAA7}";
+    Emoji2["CONSTRUCTION"] = "\u{1F3D7}\uFE0F";
+    Emoji2["CAMERA"] = "\u{1F4F7}";
+    Emoji2["MOVIE_CAMERA"] = "\u{1F3A5}";
+    Emoji2["PAINTING"] = "\u{1F5BC}\uFE0F";
+    Emoji2["PALETTE"] = "\u{1F3A8}";
+    Emoji2["MICROPHONE"] = "\u{1F399}\uFE0F";
+    Emoji2["NOTEPAD"] = "\u{1F4DD}";
+    Emoji2["GEAR"] = "\u2699\uFE0F";
+    Emoji2["REPEAT"] = "\u{1F501}";
+    Emoji2["SNOWMAN"] = "\u2603\uFE0F";
+    Emoji2["SNOWFLAKE"] = "\u2744\uFE0F";
+    Emoji2["SNOW_CLOUD"] = "\u{1F328}\uFE0F";
+    Emoji2["SCARF"] = "\u{1F9E3}";
+    Emoji2["GLOVES"] = "\u{1F9E4}";
+    Emoji2["CANDLE"] = "\u{1F56F}\uFE0F";
+    Emoji2["CHRISTMAS_TREE"] = "\u{1F384}";
+    Emoji2["SOCKS"] = "\u{1F9E6}";
+    Emoji2["COLD_FACE"] = "\u{1F976}";
+    Emoji2["EYE"] = "\u{1F441}\uFE0F";
+    Emoji2["CHAINS"] = "\u26D3\uFE0F";
+    Emoji2["SPEAKER"] = "\u{1F50A}";
+    Emoji2["COMPACT_DISK"] = "\u{1F4BF}";
+    Emoji2["SEEDLING"] = "\u{1F331}";
+    Emoji2["TULIP"] = "\u{1F337}";
+    Emoji2["BEE"] = "\u{1F41D}";
+    Emoji2["HATCHING_CHICK"] = "\u{1F423}";
+    Emoji2["NEST_WITH_EGGS"] = "\u{1FABA}";
+    Emoji2["BLOSSOM"] = "\u{1F33C}";
+    Emoji2["UMBRELLA"] = "\u2614";
+    Emoji2["RAINBOW"] = "\u{1F308}";
+    Emoji2["PICNIC_BASKET"] = "\u{1F9FA}";
+    Emoji2["SUN_WITH_FACE"] = "\u{1F31E}";
+    Emoji2["BEACH_UMBRELLA"] = "\u{1F3D6}\uFE0F";
+    Emoji2["WATERMELON"] = "\u{1F349}";
+    Emoji2["SUNGLASSES"] = "\u{1F576}\uFE0F";
+    Emoji2["ICE_CREAM"] = "\u{1F366}";
+    Emoji2["SUNFLOWER"] = "\u{1F33B}";
+    Emoji2["CAMPING"] = "\u{1F3D5}\uFE0F";
+    Emoji2["JUICE_BOX"] = "\u{1F9C3}";
+    Emoji2["PARASOL"] = "\u26F1\uFE0F";
+    Emoji2["MAPLE_LEAF"] = "\u{1F341}";
+    Emoji2["FALLEN_LEAF"] = "\u{1F342}";
+    Emoji2["TURKEY"] = "\u{1F983}";
+    Emoji2["JACK_O_LANTERN"] = "\u{1F383}";
+    Emoji2["PIE"] = "\u{1F967}";
+    Emoji2["LOG"] = "\u{1FAB5}";
+    Emoji2["SPIDER_WEB"] = "\u{1F578}\uFE0F";
+    Emoji2["BACKPACK"] = "\u{1F392}";
+    Emoji2["CHESTNUT"] = "\u{1F330}";
+    Emoji2["PLACARD"] = "\u{1FAA7}";
+    Emoji2["RECEIPT"] = "\u{1F9FE}";
+    Emoji2["DOCUMENT"] = "\u{1F4C4}";
+    Emoji2["SPARKLES"] = "\u2728";
+    Emoji2["BOOKS"] = "\u{1F4DA}";
+    Emoji2["SHOPPING_BAGS"] = "\u{1F6CD}\uFE0F";
+    Emoji2["LINK"] = "\u{1F517}";
+    Emoji2["GREEN_ASTERISK"] = "\u2733\uFE0F";
+    Emoji2["RADIO_BUTTON"] = "\u{1F518}";
+    Emoji2["WINDOW"] = "\u{1FA9F}";
+    Emoji2["MUSIC_NOTES"] = "\u{1F3B6}";
+    Emoji2["INVISIBLE_FACE"] = "\u{1FAE5}";
+    Emoji2["PLUS_SIGN"] = "\u2795";
+    Emoji2["JOKER"] = "\u{1F0CF}";
+    Emoji2["PLAY"] = "\u25B6\uFE0F";
+    Emoji2["PAUSE"] = "\u23F8\uFE0F";
+    return Emoji2;
+  })(Emoji || {});
+  var emoji_default = Emoji;
+
+  // src/client/utility/get-index-path-for-element.ts
+  var import_errors7 = __toESM(require_src2());
+  function getIndexPathForElement(element) {
+    const value = element.getAttribute("data-index-path");
+    if (value === null) {
+      throw new import_errors7.InvariantViolation(
+        "Tried to read data-index-path for element, but it was not set"
+      );
+    }
+    return value;
+  }
+  var get_index_path_for_element_default = getIndexPathForElement;
+
+  // src/client/helper/interaction.ts
+  var InteractionHelper = class {
+    constructor() {
+      this.drag_active = false;
+      this.drag_origin_block = null;
+      this.drag_placeholder = null;
+      this.drag_ghost = null;
+      this.drag_start_y = null;
+      this.drag_pointer_offset_y = null;
+      this.drag_press_timer = null;
+      this.swipe_active = false;
+      this.swipe_block = null;
+      this.swipe_start_x = null;
+      this.swipe_start_y = null;
+      this.swipe_content = null;
+      this.swipe_menu_width = 0;
+      this.open_swipe_block = null;
+      this.open_swipe_content = null;
+    }
+    attach() {
+      document.addEventListener("mousedown", (event) => {
+        this.onPressStart(event);
+      }, true);
+      document.addEventListener("touchstart", (event) => {
+        this.onPressStart(event);
+      }, { capture: true, passive: false });
+      document.addEventListener("mousemove", (event) => {
+        this.onPointerMove(event);
+      }, true);
+      document.addEventListener("touchmove", (event) => {
+        this.onPointerMove(event);
+      }, { capture: true, passive: false });
+      document.addEventListener("mouseup", (event) => {
+        this.onPressEnd(event);
+      }, true);
+      document.addEventListener("touchend", (event) => {
+        this.onPressEnd(event);
+      }, true);
+      document.addEventListener("touchstart", (event) => {
+        this.onGlobalTouchStart(event);
+      }, { capture: true, passive: true });
+      document.addEventListener("dragstart", (event) => {
+        this.onNativeDragStart(event);
+      }, true);
+    }
+    isDragging() {
+      return this.drag_active;
+    }
+    getBlockElements() {
+      const elements = document.querySelectorAll("section.block");
+      return Array.from(elements);
+    }
+    getSiblingBlocks(container, exclude) {
+      const children = Array.from(container.children);
+      return children.filter((element) => {
+        if (element === exclude) {
+          return false;
+        }
+        return element.classList.contains("block");
+      });
+    }
+    onPressStart(event) {
+      const target = event.target;
+      if (target === null) {
+        return;
+      }
+      if (target.closest("button, input, textarea, select, label, form")) {
+        return;
+      }
+      const block = target.closest("section.block");
+      if (block === null) {
+        return;
+      }
+      if (event instanceof MouseEvent) {
+        const anchor = target.closest("a[href]");
+        if (anchor) {
+          event.preventDefault();
+        }
+      }
+      const touch_event = event;
+      const is_touch = touch_event.type === "touchstart";
+      const point = this.getEventPoint(event);
+      if (point === null) {
+        return;
+      }
+      this.drag_origin_block = block;
+      this.drag_start_y = point.clientY;
+      if (is_touch) {
+        this.swipe_block = block;
+        this.swipe_start_x = point.clientX;
+        this.swipe_start_y = point.clientY;
+      }
+      const threshold_ms = is_touch ? 350 : 200;
+      this.clearPressTimer();
+      this.drag_press_timer = window.setTimeout(() => {
+        this.beginDrag(point.clientY);
+      }, threshold_ms);
+    }
+    onNativeDragStart(event) {
+      const target = event.target;
+      if (!target) {
+        return;
+      }
+      if (target.closest("section.block")) {
+        event.preventDefault();
+      }
+    }
+    onPointerMove(event) {
+      const point = this.getEventPoint(event);
+      if (point === null) {
+        return;
+      }
+      const touch_event = event;
+      const { touches } = touch_event;
+      const is_touch = touches !== void 0;
+      if (is_touch && this.swipe_block) {
+        if (this.swipe_start_x === null || this.swipe_start_y === null) {
+          throw new import_errors8.InvariantViolation("Swipe start coordinates were not initialized");
+        }
+        const start_x = this.swipe_start_x;
+        const start_y = this.swipe_start_y;
+        const delta_x = point.clientX - start_x;
+        const delta_y = point.clientY - start_y;
+        if (!this.swipe_active) {
+          const abs_x = Math.abs(delta_x);
+          const abs_y = Math.abs(delta_y);
+          if (abs_x > 12 && abs_x > abs_y) {
+            this.clearPressTimer();
+            this.closeOpenSwipeMenu(this.swipe_block);
+            this.swipe_active = true;
+            this.beginSwipe(this.swipe_block);
+          }
+        }
+        if (this.swipe_active) {
+          event.preventDefault();
+          const content_element = this.swipe_content;
+          const menu_width = this.swipe_menu_width;
+          const translate_x = Math.max(-menu_width, Math.min(0, delta_x));
+          content_element.style.transition = "";
+          content_element.style.transform = `translateX(${translate_x}px)`;
+          return;
+        }
+      }
+      if (!this.drag_active && this.drag_origin_block && this.drag_start_y !== null) {
+        const delta_y = Math.abs(point.clientY - this.drag_start_y);
+        if (delta_y > 8 && this.drag_press_timer !== null) {
+          this.beginDrag(point.clientY);
+        }
+      }
+      if (!this.drag_active) {
+        return;
+      }
+      event.preventDefault();
+      const origin = this.drag_origin_block;
+      let container = null;
+      if (this.drag_placeholder !== null) {
+        container = this.drag_placeholder.parentElement;
+      }
+      if (container === null && origin !== null) {
+        container = origin.parentElement;
+      }
+      if (container === null) {
+        return;
+      }
+      const blocks_before = this.getSiblingBlocks(container, origin);
+      const preceding_rects = /* @__PURE__ */ new Map();
+      blocks_before.forEach((element) => {
+        const rect = element.getBoundingClientRect();
+        preceding_rects.set(element, rect);
+      });
+      this.updatePlaceholderPosition(point.clientY);
+      if (this.drag_ghost && this.drag_pointer_offset_y !== null) {
+        const top_position = point.clientY - this.drag_pointer_offset_y;
+        this.drag_ghost.style.top = `${top_position}px`;
+      }
+      const blocks_after = this.getSiblingBlocks(container, origin);
+      this.animateWithFlip(preceding_rects, blocks_after);
+    }
+    onPressEnd(event) {
+      this.clearPressTimer();
+      if (this.swipe_active) {
+        const content = this.swipe_content;
+        const style = window.getComputedStyle(content);
+        let current_x = 0;
+        try {
+          const css_matrix = new WebKitCSSMatrix(style.transform);
+          current_x = css_matrix.m41;
+        } catch {
+          const translate_match = style.transform.match(/translateX\(([-0-9.]+)px\)/);
+          if (translate_match) {
+            current_x = parseFloat(translate_match[1]);
+          }
+        }
+        const width = this.swipe_menu_width;
+        const open = Math.abs(current_x) > width / 2;
+        content.style.transition = "transform 150ms ease";
+        content.style.transform = open ? `translateX(${-width}px)` : "translateX(0)";
+        if (!open) {
+          this.teardownSwipe();
+        }
+        if (open) {
+          this.open_swipe_block = this.swipe_block;
+          this.open_swipe_content = content;
+        }
+        this.swipe_active = false;
+        return;
+      }
+      if (!this.drag_active) {
+        this.resetDragState();
+        return;
+      }
+      event.preventDefault();
+      const origin = this.drag_origin_block;
+      const placeholder = this.drag_placeholder;
+      const source_index_path = get_index_path_for_element_default(origin);
+      const target_index_path = this.computeTargetIndexPath(placeholder);
+      this.cleanupDragElements();
+      if (target_index_path === null || target_index_path === source_index_path) {
+        this.resetDragState();
+        return;
+      }
+      const editing = new URL(window.location.href).searchParams.get("editing") === "true";
+      this.postReposition(source_index_path, target_index_path, editing).then((new_index_path) => {
+        if (new_index_path) {
+          const url = new URL(window.location.href);
+          url.searchParams.set("index_path", new_index_path);
+          history.replaceState({}, "", url.toString());
+        }
+        const blocks = this.getBlockElements();
+        blocks.forEach((element) => {
+          element.classList.remove("selected");
+        });
+        origin.classList.add("selected");
+        this.updateTopLevelIndexPaths();
+      }).finally(() => {
+        this.resetDragState();
+      });
+    }
+    beginSwipe(block) {
+      const result = this.ensureSwipeUI(block);
+      const target = result.target;
+      const menu = result.menu;
+      const menu_width = result.menu_width;
+      this.swipe_content = target;
+      this.swipe_menu_width = menu_width;
+      if (menu) {
+        menu.style.display = "flex";
+        menu.style.opacity = "1";
+      }
+    }
+    closeOpenSwipeMenu(except) {
+      if (!this.open_swipe_content) {
+        return;
+      }
+      if (except && this.open_swipe_block === except) {
+        return;
+      }
+      const content = this.open_swipe_content;
+      content.style.transition = "transform 150ms ease";
+      content.style.transform = "translateX(0)";
+      const clear_callback = () => {
+        content.removeEventListener("transitionend", clear_callback);
+        if (this.open_swipe_block) {
+          const menu_element = this.getSwipeMenuFor(this.open_swipe_block);
+          if (menu_element && menu_element.parentElement) {
+            menu_element.parentElement.removeChild(menu_element);
+          }
+        }
+        this.open_swipe_block = null;
+        this.open_swipe_content = null;
+      };
+      content.addEventListener("transitionend", clear_callback);
+    }
+    teardownSwipe() {
+      if (!this.swipe_block || !this.swipe_content) {
+        this.resetSwipeState();
+        return;
+      }
+      this.swipe_content.style.transition = "";
+      this.swipe_content.style.transform = "translateX(0)";
+      const menu = this.getSwipeMenuFor(this.swipe_block);
+      if (menu && menu.parentElement) {
+        menu.parentElement.removeChild(menu);
+      }
+      this.resetSwipeState();
+    }
+    onGlobalTouchStart(event) {
+      if (!this.open_swipe_block || !this.open_swipe_content) {
+        return;
+      }
+      const target = event.target;
+      if (!target) {
+        return;
+      }
+      const menu = this.getSwipeMenuFor(this.open_swipe_block);
+      const closest_block = target.closest("section.block");
+      const swipe_actions = target.closest(".swipe-actions");
+      if (closest_block === this.open_swipe_block || swipe_actions === menu) {
+        return;
+      }
+      this.closeOpenSwipeMenu();
+    }
+    getSwipeMenuFor(block) {
+      const wrapper = block.closest("main .section-wrapper");
+      if (!wrapper || !block.id) {
+        return null;
+      }
+      return wrapper.querySelector(`.swipe-actions[data-for="${block.id}"]`);
+    }
+    resetSwipeState() {
+      this.swipe_block = null;
+      this.swipe_start_x = null;
+      this.swipe_start_y = null;
+      this.swipe_content = null;
+      this.swipe_menu_width = 0;
+    }
+    ensureSwipeUI(block) {
+      const target = block;
+      target.style.willChange = "transform";
+      target.style.transform = "translateX(0)";
+      target.style.transition = "";
+      target.style.position = target.style.position || "relative";
+      target.style.zIndex = "1";
+      const wrapper = block.closest("main .section-wrapper");
+      let menu = null;
+      if (wrapper) {
+        if (getComputedStyle(wrapper).position === "static") {
+          wrapper.style.position = "relative";
+        }
+        let existing = wrapper.querySelector(`.swipe-actions[data-for="${block.id}"]`);
+        if (!existing) {
+          existing = document.createElement("div");
+          existing.className = "swipe-actions";
+          existing.setAttribute("data-for", block.id);
+          existing.style.position = "absolute";
+          existing.style.right = "0";
+          existing.style.display = "none";
+          existing.style.opacity = "0";
+          existing.style.gap = "8px";
+          existing.style.alignItems = "stretch";
+          existing.style.padding = "0 8px";
+          existing.style.background = "transparent";
+          existing.style.zIndex = "0";
+          const edit_button = document.createElement("button");
+          const delete_button = document.createElement("button");
+          const add_button = document.createElement("button");
+          edit_button.textContent = emoji_default.GEAR;
+          edit_button.setAttribute("aria-label", "Edit");
+          edit_button.style.background = "#f0ad4e";
+          edit_button.style.color = "#000";
+          edit_button.style.border = "none";
+          edit_button.style.padding = "0";
+          edit_button.style.fontSize = "20px";
+          edit_button.style.width = "48px";
+          edit_button.style.minWidth = "48px";
+          edit_button.style.display = "flex";
+          edit_button.style.alignItems = "center";
+          edit_button.style.justifyContent = "center";
+          edit_button.style.cursor = "pointer";
+          delete_button.textContent = emoji_default.RED_X;
+          delete_button.setAttribute("aria-label", "Delete");
+          delete_button.style.background = "#e74c3c";
+          delete_button.style.color = "#fff";
+          delete_button.style.border = "none";
+          delete_button.style.padding = "0";
+          delete_button.style.fontSize = "20px";
+          delete_button.style.width = "48px";
+          delete_button.style.minWidth = "48px";
+          delete_button.style.display = "flex";
+          delete_button.style.alignItems = "center";
+          delete_button.style.justifyContent = "center";
+          delete_button.style.cursor = "pointer";
+          add_button.textContent = emoji_default.PLUS_SIGN;
+          add_button.setAttribute("aria-label", "Add After");
+          add_button.style.background = "#27ae60";
+          add_button.style.color = "#fff";
+          add_button.style.border = "none";
+          add_button.style.padding = "0";
+          add_button.style.fontSize = "20px";
+          add_button.style.width = "48px";
+          add_button.style.minWidth = "48px";
+          add_button.style.display = "flex";
+          add_button.style.alignItems = "center";
+          add_button.style.justifyContent = "center";
+          add_button.style.cursor = "pointer";
+          existing.appendChild(edit_button);
+          existing.appendChild(delete_button);
+          existing.appendChild(add_button);
+          wrapper.appendChild(existing);
+          const edit_handler = (event) => {
+            event.preventDefault();
+            event.stopPropagation();
+            this.navigateToBlockLink(block, "edit");
+          };
+          const delete_handler = (event) => {
+            event.preventDefault();
+            event.stopPropagation();
+            this.navigateToBlockLink(block, "delete");
+          };
+          const add_handler = (event) => {
+            event.preventDefault();
+            event.stopPropagation();
+            this.navigateToAddAfter(block);
+          };
+          existing.addEventListener("touchstart", (event) => {
+            event.stopPropagation();
+          });
+          existing.addEventListener("mousedown", (event) => {
+            event.stopPropagation();
+          });
+          edit_button.addEventListener("click", edit_handler);
+          edit_button.addEventListener("touchend", edit_handler);
+          delete_button.addEventListener("click", delete_handler);
+          delete_button.addEventListener("touchend", delete_handler);
+          add_button.addEventListener("click", add_handler);
+          add_button.addEventListener("touchend", add_handler);
+        }
+        menu = existing;
+        const top = block.offsetTop;
+        const height = block.offsetHeight;
+        menu.style.top = `${top}px`;
+        menu.style.height = `${height}px`;
+      }
+      let menu_width = 160;
+      if (menu) {
+        const prevDisplay = menu.style.display;
+        const prevOpacity = menu.style.opacity;
+        menu.style.display = "flex";
+        menu.style.opacity = "0";
+        menu_width = menu.offsetWidth || 160;
+        menu.style.display = prevDisplay;
+        menu.style.opacity = prevOpacity;
+      }
+      this.enforceTimeVisibility(block);
+      return {
+        target,
+        menu,
+        menu_width
+      };
+    }
+    navigateToAddAfter(block) {
+      const current = get_index_path_for_element_default(block);
+      const parts = current.split(".").map((part) => {
+        return parseInt(part, 10);
+      });
+      const has_invalid_number = parts.some((value) => {
+        return isNaN(value);
+      });
+      if (parts.length === 0 || has_invalid_number) {
+        throw new import_errors8.InvariantViolation("Invalid index_path for Add After");
+      }
+      const last = parts.pop();
+      if (last === void 0) {
+        throw new import_errors8.InvariantViolation("Unable to compute next index for Add After");
+      }
+      parts.push(last + 1);
+      const index_path = parts.join(".");
+      const url = new URL(window.location.href);
+      const editing = url.searchParams.get("editing") === "true";
+      const path = window.location.pathname;
+      const actionUrl = new URL("/actions", window.location.origin);
+      actionUrl.searchParams.set("path", path);
+      actionUrl.searchParams.set("editing", String(editing));
+      actionUrl.searchParams.set("action_type", "add_block");
+      actionUrl.searchParams.set("index_path", index_path);
+      window.location.href = actionUrl.toString();
+    }
+    enforceTimeVisibility(block) {
+      const shows_time = block.classList.contains("with-time");
+      const time_element = block.querySelector(":scope time");
+      if (!time_element) {
+        return;
+      }
+      if (!shows_time) {
+        time_element.style.display = "none";
+      } else {
+        time_element.style.display = "";
+      }
+    }
+    navigateToBlockLink(block, type) {
+      const block_id = block.id;
+      const link_id = `${block_id}-${type}`;
+      const link_element = document.getElementById(link_id);
+      if (!link_element) {
+        return;
       }
-      const href = element.getAttribute("href");
-      if (href === null) {
-        throw new import_errors4.InvariantViolation(`
-				Tried to create block of type ${block_type},
-				but the creation href was not present on the link element
-			`);
+      const href = link_element.getAttribute("href");
+      if (href) {
+        window.location.href = href;
       }
-      window.location.href = href;
     }
-  };
-  var select_block_type_default = SelectBlockTypePage;
-
-  // src/client/page/cursor.ts
-  var import_errors7 = __toESM(require_src2());
-  var import_array2 = __toESM(require_src3());
-
-  // src/client/utility/get-meta-value.ts
-  var import_errors5 = __toESM(require_src2());
-  function getMetaValue(name) {
-    const element = document.querySelector(`meta[name="${name}"]`);
-    if (element === null) {
-      throw new import_errors5.InvariantViolation(`
-			Tried to read ${name} meta tag, but it was not set
-		`);
+    beginDrag(current_y) {
+      if (this.drag_active) {
+        return;
+      }
+      const block = this.drag_origin_block;
+      if (!block) {
+        return;
+      }
+      this.drag_active = true;
+      document.body.style.userSelect = "none";
+      document.body.style.cursor = "grabbing";
+      const rect = block.getBoundingClientRect();
+      const ghost = block.cloneNode(true);
+      ghost.style.position = "fixed";
+      ghost.style.top = `${rect.top}px`;
+      ghost.style.left = `${rect.left}px`;
+      ghost.style.width = `${rect.width}px`;
+      ghost.style.pointerEvents = "none";
+      ghost.style.opacity = "0.9";
+      ghost.style.boxShadow = "0 8px 16px rgba(0,0,0,0.2)";
+      ghost.style.zIndex = "9999";
+      document.body.appendChild(ghost);
+      this.drag_ghost = ghost;
+      this.drag_pointer_offset_y = current_y - rect.top;
+      const placeholder = document.createElement("div");
+      placeholder.style.height = `${rect.height}px`;
+      placeholder.style.margin = getComputedStyle(block).margin;
+      placeholder.style.border = "2px dashed #888";
+      placeholder.style.borderRadius = "4px";
+      placeholder.style.boxSizing = "border-box";
+      if (block.parentElement !== null) {
+        block.parentElement.insertBefore(placeholder, block);
+      }
+      this.drag_placeholder = placeholder;
+      block.style.display = "none";
+      this.updatePlaceholderPosition(current_y);
+    }
+    updatePlaceholderPosition(cursor_y) {
+      const placeholder = this.drag_placeholder;
+      const origin = this.drag_origin_block;
+      if (!placeholder || !origin) {
+        return;
+      }
+      const container = placeholder.parentElement;
+      const blocks = this.getSiblingBlocks(container, origin);
+      let inserted = false;
+      for (let i = 0; i < blocks.length; i++) {
+        const element = blocks[i];
+        const rect = element.getBoundingClientRect();
+        const midpoint = rect.top + rect.height / 2;
+        if (cursor_y < midpoint) {
+          const parent = element.parentElement;
+          if (parent) {
+            parent.insertBefore(placeholder, element);
+          }
+          inserted = true;
+          break;
+        }
+      }
+      if (!inserted) {
+        const last_element = blocks[blocks.length - 1];
+        if (last_element) {
+          const parent = last_element.parentElement;
+          if (parent) {
+            parent.appendChild(placeholder);
+          }
+        }
+      }
     }
-    if (!(element instanceof HTMLMetaElement)) {
-      throw new import_errors5.InvariantViolation(`
-			Got wrong element for ${name} meta tag: ${element.tagName}
-		`);
+    animateWithFlip(preceding_rects, blocks_after) {
+      blocks_after.forEach((element) => {
+        const first = preceding_rects.get(element);
+        if (!first) {
+          return;
+        }
+        const last_rect = element.getBoundingClientRect();
+        const delta_y = first.top - last_rect.top;
+        if (delta_y === 0) {
+          return;
+        }
+        element.style.transition = "";
+        element.style.transform = `translateY(${delta_y}px)`;
+        void element.getBoundingClientRect();
+        element.style.transition = "transform 120ms ease";
+        element.style.transform = "translateY(0)";
+        const cleanup = () => {
+          element.style.transition = "";
+          element.style.transform = "";
+          element.removeEventListener("transitionend", cleanup);
+        };
+        element.addEventListener("transitionend", cleanup);
+      });
     }
-    const meta_tag = element;
-    return meta_tag.content;
-  }
-  var get_meta_value_default = getMetaValue;
-
-  // src/server/utility/validate-path.ts
-  var import_errors6 = __toESM(require_src2());
-  function validatePath(path) {
-    if (!path.startsWith("/")) {
-      throw new import_errors6.InvalidError(`Invalid path: ${path}`);
+    async postReposition(source_index_path, target_index_path, editing) {
+      const form = new FormData();
+      form.set("path", window.location.pathname);
+      form.set("action_type", action_type_default.REPOSITION_BLOCK);
+      form.set("source_index_path", source_index_path);
+      form.set("target_index_path", target_index_path);
+      const response = await fetch(`/actions?editing=${editing}`, {
+        method: "POST",
+        body: form,
+        credentials: "same-origin",
+        redirect: "follow"
+      });
+      try {
+        const url_object = new URL(response.url, window.location.origin);
+        return url_object.searchParams.get("index_path");
+      } catch (_) {
+        return null;
+      }
     }
-  }
-  var validate_path_default = validatePath;
-
-  // src/common/utility/get-parent-path.ts
-  function getParentPath(source_path) {
-    validate_path_default(source_path);
-    const query_index = source_path.indexOf("?");
-    if (query_index !== -1) {
-      source_path = source_path.slice(0, query_index);
+    computeTargetIndexPath(placeholder) {
+      if (!placeholder) {
+        return null;
+      }
+      const parent = placeholder.parentElement;
+      if (!parent) {
+        return null;
+      }
+      let index = 0;
+      const children_elements = Array.from(parent.children);
+      for (let i = 0; i < children_elements.length; i++) {
+        const child_element = children_elements[i];
+        if (child_element === placeholder) {
+          break;
+        }
+        if (child_element.classList.contains("block")) {
+          index += 1;
+        }
+      }
+      return index.toString();
     }
-    if (source_path.endsWith("/")) {
-      source_path = source_path.slice(0, -1);
+    updateTopLevelIndexPaths() {
+      const wrapper = document.querySelector("main .section-wrapper");
+      let blocks;
+      if (wrapper) {
+        const node_list = wrapper.querySelectorAll(":scope > section.block");
+        blocks = Array.from(node_list);
+      } else {
+        const node_list = document.querySelectorAll("main > section.block");
+        blocks = Array.from(node_list);
+      }
+      for (let i = 0; i < blocks.length; i++) {
+        blocks[i].setAttribute("data-index-path", i.toString());
+      }
     }
-    const parts = source_path.split("/").filter((part) => {
-      return part !== "";
-    });
-    parts.pop();
-    if (parts.length === 0) {
-      return "/";
+    cleanupDragElements() {
+      if (this.drag_ghost && this.drag_ghost.parentElement) {
+        this.drag_ghost.parentElement.removeChild(this.drag_ghost);
+      }
+      if (this.drag_placeholder && this.drag_placeholder.parentElement) {
+        if (this.drag_origin_block) {
+          this.drag_placeholder.parentElement.insertBefore(this.drag_origin_block, this.drag_placeholder);
+        }
+        this.drag_placeholder.parentElement.removeChild(this.drag_placeholder);
+      }
+      if (this.drag_origin_block) {
+        this.drag_origin_block.style.display = "";
+      }
+      this.drag_ghost = null;
+      this.drag_placeholder = null;
+      document.body.style.userSelect = "";
+      document.body.style.cursor = "";
+    }
+    resetDragState() {
+      this.cleanupDragElements();
+      this.drag_active = false;
+      this.drag_origin_block = null;
+      this.drag_start_y = null;
+      this.drag_pointer_offset_y = null;
+    }
+    clearPressTimer() {
+      if (this.drag_press_timer !== null) {
+        window.clearTimeout(this.drag_press_timer);
+        this.drag_press_timer = null;
+      }
+    }
+    getEventPoint(event) {
+      const touch_event = event;
+      const has_touches = touch_event.touches !== void 0;
+      if (has_touches) {
+        const primary_touch = touch_event.touches[0] || touch_event.changedTouches[0];
+        if (!primary_touch) {
+          return null;
+        }
+        return {
+          clientX: primary_touch.clientX,
+          clientY: primary_touch.clientY
+        };
+      }
+      const mouse_event = event;
+      return {
+        clientX: mouse_event.clientX,
+        clientY: mouse_event.clientY
+      };
     }
-    return "/" + parts.join("/");
-  }
-  var get_parent_path_default = getParentPath;
-
-  // src/client/enum/media-ready-state.ts
-  var MediaReadyState = /* @__PURE__ */ ((MediaReadyState2) => {
-    MediaReadyState2[MediaReadyState2["HAVE_NOTHING"] = 0] = "HAVE_NOTHING";
-    MediaReadyState2[MediaReadyState2["HAVE_METADATA"] = 1] = "HAVE_METADATA";
-    MediaReadyState2[MediaReadyState2["HAVE_CURRENT_DATA"] = 2] = "HAVE_CURRENT_DATA";
-    MediaReadyState2[MediaReadyState2["HAVE_FUTURE_DATA"] = 3] = "HAVE_FUTURE_DATA";
-    MediaReadyState2[MediaReadyState2["HAVE_ENOUGH_DATA"] = 4] = "HAVE_ENOUGH_DATA";
-    return MediaReadyState2;
-  })(MediaReadyState || {});
-  var media_ready_state_default = MediaReadyState;
+  };
+  var interaction_default = InteractionHelper;
 
   // src/client/page/cursor.ts
-  function getAttributeForElement(element, attribute) {
-    const value = element.getAttribute(attribute);
-    if (value === null) {
-      throw new import_errors7.InvariantViolation(`
-			Tried to read ${attribute} for element, but it was not set
-		`);
-    }
-    return value;
-  }
-  function getIndexPathForElement(element) {
-    return getAttributeForElement(element, "data-index-path");
-  }
   var CursorPage = class extends page_default {
     constructor() {
       super();
       this.logged_in = false;
       this.queued_media = null;
       this.ready_media = [];
+      this.drag_helper = new interaction_default();
     }
     initView() {
       this.focusCurrentBlockElement();
       const meta_value = get_meta_value_default("logged_in");
       this.logged_in = meta_value === "true";
+      if (this.isLoggedIn()) {
+        this.drag_helper.attach();
+      }
     }
     initEvents() {
       super.initEvents();
@@ -1503,13 +3096,94 @@
       document.addEventListener("ended", (event) => {
         this.handleMediaPlaybackEnded(event);
       }, true);
+      document.addEventListener("click", (event) => {
+        this.handleGenericClick(event);
+      }, true);
+      window.addEventListener("popstate", (event) => {
+        this.handlePopstate(event);
+      });
+    }
+    handleGenericClick(event) {
+      if (this.drag_helper.isDragging()) {
+        return;
+      }
+      if (!this.hasActiveMedia()) {
+        return;
+      }
+      if (event.defaultPrevented) {
+        return;
+      }
+      const mouse_event = event;
+      if (mouse_event.button !== 0) {
+        return;
+      }
+      if (mouse_event.metaKey || mouse_event.ctrlKey || mouse_event.shiftKey || mouse_event.altKey) {
+        return;
+      }
+      if (event.target === null) {
+        return;
+      }
+      const target = event.target;
+      const anchor = target.closest("a[href]");
+      if (anchor === null) {
+        return;
+      }
+      const url = new URL(anchor.href, window.location.href);
+      if (url.origin !== window.location.origin) {
+        return;
+      }
+      event.preventDefault();
+      const path = url.pathname + url.search + url.hash;
+      this.navigateToPath(path);
+    }
+    navigateToPath(path) {
+      if (!this.hasActiveMedia()) {
+        window.location.href = path;
+        return;
+      }
+      history.pushState({ path }, "", path);
+      this.fetchAndDisplay(path);
+    }
+    async fetchAndDisplay(path) {
+      const response = await fetch(path, {
+        headers: {
+          "Accept": "text/html"
+        }
+      });
+      if (!response.ok) {
+        window.location.href = path;
+        return;
+      }
+      const html = await response.text();
+      const parser = new DOMParser();
+      const updated_document = parser.parseFromString(html, "text/html");
+      const tags = ["header", "main", "footer"];
+      let index = 0;
+      while (index < tags.length) {
+        const tag = tags[index++];
+        const old_element = document.querySelector(tag);
+        const new_element = updated_document.querySelector(tag);
+        if (old_element === null && new_element === null) {
+          continue;
+        }
+        if (old_element === null || new_element === null) {
+          window.location.href = path;
+          return;
+        }
+        old_element.replaceWith(new_element);
+      }
+    }
+    handlePopstate(event) {
+      const { pathname, search, hash } = window.location;
+      const path = pathname + search + hash;
+      this.fetchAndDisplay(path);
     }
     focusCurrentBlockElement() {
-      const element = this.getCurrentBlockElement();
-      if (element === null) {
+      const current_block = this.getCurrentBlockElement();
+      if (current_block === null) {
         return;
       }
-      this.focusElement(element);
+      this.focusElement(current_block);
     }
     handleKey(key_code) {
       switch (key_code) {
@@ -1546,13 +3220,13 @@
       const link_id = `${block_id}-add-to-playlist`;
       const link_element = document.getElementById(link_id);
       if (link_element === null) {
-        throw new import_errors7.InvariantViolation(`
+        throw new import_errors9.InvariantViolation(`
 				Unable to find playlist link element for block: ${block_id}
 			`);
       }
       const href = link_element.getAttribute("href");
       if (href === null) {
-        throw new import_errors7.InvariantViolation(`
+        throw new import_errors9.InvariantViolation(`
 				Unable to find playlist link href for block: ${block_id}
 			`);
       }
@@ -1580,7 +3254,7 @@
       const form_id = `${block_id}-promote`;
       const form_element = document.getElementById(form_id);
       if (form_element === null) {
-        throw new import_errors7.InvariantViolation(`
+        throw new import_errors9.InvariantViolation(`
 				Unable to find promotion form element for block: ${block_id}
 			`);
       }
@@ -1598,7 +3272,7 @@
       const form_id = `${block_id}-demote`;
       const form_element = document.getElementById(form_id);
       if (form_element === null) {
-        throw new import_errors7.InvariantViolation(`
+        throw new import_errors9.InvariantViolation(`
 				Unable to find demotion form element for block: ${block_id}
 			`);
       }
@@ -1617,15 +3291,15 @@
     }
     jumpToPageTop() {
       this.navigateToIndex(this.getFirstBlockIndex());
-      this.focusCurrentBlockElement();
+      window.scrollTo(0, 0);
     }
     jumpToPageBottom() {
       this.navigateToIndex(this.getLastBlockIndex());
-      this.focusCurrentBlockElement();
+      window.scrollTo(0, document.documentElement.scrollHeight);
     }
     navigateToParentPage() {
       const parent_path = get_parent_path_default(window.location.pathname);
-      window.location.href = parent_path;
+      this.navigateToPath(parent_path);
     }
     navigateToHistory() {
       window.location.href = "/history";
@@ -1637,7 +3311,7 @@
       const block_elements = this.getBlockElements();
       let found = false;
       block_elements.forEach((block_element) => {
-        const sibling_path = getIndexPathForElement(block_element);
+        const sibling_path = get_index_path_for_element_default(block_element);
         const is_match = sibling_path === index_path;
         block_element.classList.toggle("selected", is_match);
         if (is_match) {
@@ -1645,7 +3319,7 @@
         }
       });
       if (!found) {
-        throw new import_errors7.InvariantViolation(`
+        throw new import_errors9.InvariantViolation(`
 				Tried to navigate to element at index path ${index_path},
 				but matching element was not found
 			`);
@@ -1658,16 +3332,26 @@
       if (this.shiftIsPressed()) {
         this.promoteCurrentBlock();
       } else {
-        this.navigateToIndex(this.getPreviousBlockIndex());
-        this.focusCurrentBlockElement();
+        const index = this.getPreviousBlockIndex();
+        if (index === null) {
+          window.scrollTo(0, 0);
+        } else {
+          this.navigateToIndex(index);
+          this.focusCurrentBlockElement();
+        }
       }
     }
     selectNextBlock() {
       if (this.shiftIsPressed()) {
         this.demoteCurrentBlock();
       } else {
-        this.navigateToIndex(this.getNextBlockIndex());
-        this.focusCurrentBlockElement();
+        const index = this.getNextBlockIndex();
+        if (index === null) {
+          window.scrollTo(0, document.documentElement.scrollHeight);
+        } else {
+          this.navigateToIndex(index);
+          this.focusCurrentBlockElement();
+        }
       }
     }
     getCurrentBlockIndex() {
@@ -1675,7 +3359,7 @@
       if (element === null) {
         return "0";
       }
-      return getIndexPathForElement(element);
+      return get_index_path_for_element_default(element);
     }
     getCurrentBlockNumericIndex() {
       const index = this.getCurrentBlockIndex();
@@ -1704,26 +3388,26 @@
         return null;
       }
       const element = block_elements.find((element2) => {
-        const attribute = getIndexPathForElement(element2);
+        const attribute = get_index_path_for_element_default(element2);
         return attribute === index_path;
       });
       return element || null;
     }
     getFirstBlockIndex() {
       const blocks = this.getBlockElements();
-      const first_block = (0, import_array2.getFirstValue)(blocks);
+      const first_block = (0, import_array.getFirstValue)(blocks);
       if (first_block === void 0) {
         return null;
       }
-      return getIndexPathForElement(first_block);
+      return get_index_path_for_element_default(first_block);
     }
     getLastBlockIndex() {
       const blocks = this.getBlockElements();
-      const last_block = (0, import_array2.getLastValue)(blocks);
+      const last_block = (0, import_array.getLastValue)(blocks);
       if (last_block === void 0) {
         return null;
       }
-      return getIndexPathForElement(last_block);
+      return get_index_path_for_element_default(last_block);
     }
     getNextBlockIndex() {
       const current_block = this.getCurrentBlockElement();
@@ -1733,7 +3417,7 @@
       if (next_block === void 0) {
         return null;
       }
-      return getIndexPathForElement(next_block);
+      return get_index_path_for_element_default(next_block);
     }
     getPreviousBlockIndex() {
       const current_block = this.getCurrentBlockElement();
@@ -1752,14 +3436,14 @@
       }
       const attribute = block_element.getAttribute("data-block-type");
       if (attribute === null) {
-        throw new import_errors7.InvariantViolation(`
+        throw new import_errors9.InvariantViolation(`
 				Tried to activate current block, but it did not have a block type
 			`);
       }
       const block_type = attribute;
       const block_types = Object.values(block_type_default);
       if (!block_types.includes(block_type)) {
-        throw new import_errors7.InvariantViolation(`
+        throw new import_errors9.InvariantViolation(`
 				Invalid block type: ${block_type}
 			`);
       }
@@ -1780,7 +3464,7 @@
       const forms = block_element.getElementsByTagName("form");
       const form = forms[0];
       if (form === void 0) {
-        throw new import_errors7.InvariantViolation(`
+        throw new import_errors9.InvariantViolation(`
 				Tried to activate form for todo block, but it was not set
 			`);
       }
@@ -1788,7 +3472,7 @@
     }
     activateFolderBlock(block_element) {
       const href = get_block_activation_href_default(block_element);
-      window.location.href = href;
+      this.navigateToPath(href);
     }
     activateImageBlock(block_element) {
       const href = get_block_activation_href_default(block_element);
@@ -1797,7 +3481,7 @@
     activateAudioBlock(block_element) {
       const audio_element = block_element.querySelectorAll("audio")[0];
       if (audio_element === void 0) {
-        throw new import_errors7.InvariantViolation(`
+        throw new import_errors9.InvariantViolation(`
 				Tried to read audio element for block, but it was not present
 			`);
       }
@@ -1812,16 +3496,57 @@
       if (element === null) {
         return;
       }
+      this.playElement(element);
+    }
+    playElement(element) {
+      this.pauseActiveMedia();
       const media_block = element.closest("section.block");
-      if (media_block !== null) {
-        const index_path = getIndexPathForElement(media_block);
-        this.navigateToIndex(index_path);
-        this.focusCurrentBlockElement();
+      if (media_block === null) {
+        throw new import_errors9.InvariantViolation(`
+				Tried to access closest block wrapper for media, but it was not found
+			`);
+      }
+      const index_path = get_index_path_for_element_default(media_block);
+      this.navigateToIndex(index_path);
+      this.focusCurrentBlockElement();
+      const persistent_element = document.getElementById("persistent-audio");
+      const persistent_audio = persistent_element;
+      const track_target = document.getElementById("persistent-track-name");
+      const artist_target = document.getElementById("persistent-artist-name");
+      const track_source = media_block.querySelector('[data-role="track_name"]');
+      const artist_source = media_block.querySelector('[data-role="artist_name"]');
+      if (persistent_audio === null) {
+        throw new import_errors9.InvariantViolation(`
+				Tried to access persistent audio element, but it was not found
+			`);
+      }
+      if (track_target === null) {
+        throw new import_errors9.InvariantViolation(`
+				Tried to access persistent track name element, but it was not found
+			`);
+      }
+      if (artist_target === null) {
+        throw new import_errors9.InvariantViolation(`
+				Tried to access persistent artist name element, but it was not found
+			`);
       }
+      if (track_source === null) {
+        throw new import_errors9.InvariantViolation(`
+				Tried to read track name source, but it was not found
+			`);
+      }
+      if (artist_source === null) {
+        throw new import_errors9.InvariantViolation(`
+				Tried to read artist name source, but it was not found
+			`);
+      }
+      persistent_audio.src = element.src;
+      track_target.innerHTML = track_source.innerHTML;
+      artist_target.innerHTML = artist_source.innerHTML;
+      document.body.classList.add("media-visible");
       if (element.readyState >= media_ready_state_default.HAVE_CURRENT_DATA) {
-        element.currentTime = 0;
-        element.play();
-        return;
+        persistent_audio.currentTime = 0;
+        persistent_audio.play();
       }
     }
     handleMediaCanPlay(event) {
@@ -1830,6 +3555,18 @@
         return;
       }
       const media_target = target;
+      const duration_ms = media_target.duration * import_time.TimeInterval.ONE_SECOND;
+      const timecode = (0, import_time.formatTimecode)(duration_ms);
+      const block = media_target.closest("section.block");
+      if (block !== null) {
+        const duration_label = block.querySelector('[data-role="duration"]');
+        if (duration_label === null) {
+          throw new import_errors9.InvariantViolation(`
+					Tried to read duration label for media block, but it was not found
+				`);
+        }
+        duration_label.innerHTML = timecode;
+      }
       if (this.queued_media !== media_target) {
         return;
       }
@@ -1837,8 +3574,7 @@
         return;
       }
       this.ready_media.push(media_target);
-      media_target.currentTime = 0;
-      media_target.play();
+      this.playElement(media_target);
     }
     handleMediaPlaybackEnded(event) {
       const target = event.target;
@@ -1846,16 +3582,20 @@
         return;
       }
       const media_target = target;
-      if (this.queued_media !== null && this.queued_media !== media_target) {
-        return;
+      const queued_media = this.queued_media;
+      if (queued_media !== null) {
+        if (queued_media.src !== media_target.src) {
+          return;
+        }
       }
       this.setQueuedMedia(null);
       media_target.currentTime = 0;
-      const media_elements = document.querySelectorAll("audio,video");
+      const elements = document.querySelectorAll("audio,video");
+      const media_elements = Array.from(elements);
       let index = 0;
       while (index < media_elements.length) {
         const element = media_elements[index++];
-        if (element === media_target) {
+        if (element.src === media_target.src) {
           const next_element = media_elements[index];
           if (next_element) {
             return this.setQueuedMedia(next_element);
@@ -1863,17 +3603,27 @@
         }
       }
     }
-    pauseActiveMedia() {
-      this.setQueuedMedia(null);
+    hasActiveMedia() {
+      const active_media = this.getActiveMedia();
+      return active_media.length > 0;
+    }
+    getActiveMedia() {
       const elements = document.querySelectorAll("audio,video");
       const media_elements = Array.from(elements);
-      media_elements.forEach((media_element) => {
+      return media_elements.filter((media_element) => {
         if (media_element.paused || media_element.ended) {
-          return;
+          return false;
         }
         if (media_element.readyState < media_ready_state_default.HAVE_CURRENT_DATA) {
-          return;
+          return false;
         }
+        return true;
+      });
+    }
+    pauseActiveMedia() {
+      this.setQueuedMedia(null);
+      const active_media = this.getActiveMedia();
+      active_media.forEach((media_element) => {
         media_element.pause();
       });
     }
@@ -1914,7 +3664,7 @@
   var create_block_default = CreateBlockPage;
 
   // src/client/page/edit-block.ts
-  var import_errors8 = __toESM(require_src2());
+  var import_errors10 = __toESM(require_src2());
   var EditBlockPage = class extends page_default {
     initEvents() {
       super.initEvents();
@@ -1931,7 +3681,7 @@
           }
         }
         if (form === void 0) {
-          throw new import_errors8.InvariantViolation(`
+          throw new import_errors10.InvariantViolation(`
 					Tried to read form for textarea, but it was not set
 				`);
         }
@@ -1947,7 +3697,7 @@
   var edit_block_default = EditBlockPage;
 
   // src/client/page/view-custom.ts
-  var import_errors9 = __toESM(require_src2());
+  var import_errors11 = __toESM(require_src2());
   var ViewCustomPage = class extends cursor_default {
     handleKey(key_code) {
       switch (key_code) {
@@ -1977,13 +3727,13 @@
       const link_id = `${block_id}-edit`;
       const link_element = document.getElementById(link_id);
       if (link_element === null) {
-        throw new import_errors9.InvariantViolation(`
+        throw new import_errors11.InvariantViolation(`
 				Unable to find edit link element for block: ${block_id}
 			`);
       }
       const href = link_element.getAttribute("href");
       if (href === null) {
-        throw new import_errors9.InvariantViolation(`
+        throw new import_errors11.InvariantViolation(`
 				Unable to find edit link href for block: ${block_id}
 			`);
       }
@@ -1996,7 +3746,7 @@
       const current_path = this.getCurrentBlockIndex();
       const top_level_index = parseInt(current_path, 10);
       if (isNaN(top_level_index)) {
-        throw new import_errors9.InvariantViolation(`Invalid index path: ${current_path}`);
+        throw new import_errors11.InvariantViolation(`Invalid index path: ${current_path}`);
       }
       const add_block_links = document.querySelectorAll('[data-role="add_block_link"]');
       const link_index = (() => {
@@ -2008,14 +3758,14 @@
       })();
       const link = add_block_links[link_index];
       if (link === void 0) {
-        throw new import_errors9.InvariantViolation(`
+        throw new import_errors11.InvariantViolation(`
 				Tried to read link at index ${link_index},
 				but it was not found
 			`);
       }
       const href = link.getAttribute("href");
       if (href === null) {
-        throw new import_errors9.InvariantViolation(`
+        throw new import_errors11.InvariantViolation(`
 				Tried to read href for link at index ${link_index},
 				but it was not set
 			`);
@@ -2034,13 +3784,13 @@
       const link_id = `${block_id}-move`;
       const link_element = document.getElementById(link_id);
       if (link_element === null) {
-        throw new import_errors9.InvariantViolation(`
+        throw new import_errors11.InvariantViolation(`
 				Unable to find move link element for block: ${block_id}
 			`);
       }
       const href = link_element.getAttribute("href");
       if (href === null) {
-        throw new import_errors9.InvariantViolation(`
+        throw new import_errors11.InvariantViolation(`
 				Unable to find move link href for block: ${block_id}
 			`);
       }
@@ -2050,6 +3800,9 @@
       if (!this.isLoggedIn()) {
         return;
       }
+      if (this.shiftIsPressed()) {
+        return;
+      }
       const block_element = this.getCurrentBlockElement();
       if (block_element === null) {
         return;
@@ -2058,13 +3811,13 @@
       const link_id = `${block_id}-hide`;
       const link_element = document.getElementById(link_id);
       if (link_element === null) {
-        throw new import_errors9.InvariantViolation(`
+        throw new import_errors11.InvariantViolation(`
 				Unable to find hide link element for block: ${block_id}
 			`);
       }
       const href = link_element.getAttribute("href");
       if (href === null) {
-        throw new import_errors9.InvariantViolation(`
+        throw new import_errors11.InvariantViolation(`
 				Unable to find hide link href for block: ${block_id}
 			`);
       }
@@ -2075,13 +3828,13 @@
       const link_id = `${block_id}-delete`;
       const link_element = document.getElementById(link_id);
       if (link_element === null) {
-        throw new import_errors9.InvariantViolation(`
+        throw new import_errors11.InvariantViolation(`
 				Unable to find deletion link element for block: ${block_id}
 			`);
       }
       const href = link_element.getAttribute("href");
       if (href === null) {
-        throw new import_errors9.InvariantViolation(`
+        throw new import_errors11.InvariantViolation(`
 				Unable to find deletion link href for block: ${block_id}
 			`);
       }
@@ -2110,7 +3863,7 @@
   var edit_custom_default = EditCustomPage;
 
   // src/client/page/confirm-delete-block.ts
-  var import_errors10 = __toESM(require_src2());
+  var import_errors12 = __toESM(require_src2());
   var ConfirmDeleteBlockPage = class extends page_default {
     handleKey(key_code) {
       switch (key_code) {
@@ -2123,7 +3876,7 @@
     submitDeletionForm() {
       const element = document.getElementById("deletion-form");
       if (element === null) {
-        throw new import_errors10.InvariantViolation("Could not find deletion form element");
+        throw new import_errors12.InvariantViolation("Could not find deletion form element");
       }
       const form = element;
       form.submit();
@@ -2132,7 +3885,7 @@
   var confirm_delete_block_default = ConfirmDeleteBlockPage;
 
   // src/client/page/confirm-hide-block.ts
-  var import_errors11 = __toESM(require_src2());
+  var import_errors13 = __toESM(require_src2());
   var ConfirmHideBlockPage = class extends page_default {
     handleKey(key_code) {
       switch (key_code) {
@@ -2145,7 +3898,7 @@
     submitHideForm() {
       const element = document.getElementById("hide-form");
       if (element === null) {
-        throw new import_errors11.InvariantViolation("Could not find hide form element");
+        throw new import_errors13.InvariantViolation("Could not find hide form element");
       }
       const form = element;
       form.submit();
@@ -2238,7 +3991,7 @@
       const page_type = meta_value;
       const page_types = Object.values(page_type_default);
       if (!page_types.includes(page_type)) {
-        throw new import_errors12.InvariantViolation(`
+        throw new import_errors14.InvariantViolation(`
 				Invalid page type: ${page_type}
 			`);
       }