@fc3/mmcadi 0.1.48 → 0.1.49

package/dist/client.js

@@ -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,6 +963,767 @@
     }
   });
 
+  // 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());
 
@@ -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) {
@@ -1408,7 +2179,8 @@
 
   // src/client/page/cursor.ts
   var import_errors7 = __toESM(require_src2());
-  var import_array2 = __toESM(require_src3());
+  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());
@@ -1503,13 +2275,91 @@
       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.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) {
@@ -1617,15 +2467,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";
@@ -1658,16 +2508,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() {
@@ -1711,7 +2571,7 @@
     }
     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;
       }
@@ -1719,7 +2579,7 @@
     }
     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;
       }
@@ -1788,7 +2648,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);
@@ -1812,16 +2672,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_errors7.InvariantViolation(`
+				Tried to access closest block wrapper for media, but it was not found
+			`);
+      }
+      const index_path = getIndexPathForElement(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_errors7.InvariantViolation(`
+				Tried to access persistent audio element, but it was not found
+			`);
+      }
+      if (track_target === null) {
+        throw new import_errors7.InvariantViolation(`
+				Tried to access persistent track name element, but it was not found
+			`);
+      }
+      if (artist_target === null) {
+        throw new import_errors7.InvariantViolation(`
+				Tried to access persistent artist name element, but it was not found
+			`);
       }
+      if (track_source === null) {
+        throw new import_errors7.InvariantViolation(`
+				Tried to read track name source, but it was not found
+			`);
+      }
+      if (artist_source === null) {
+        throw new import_errors7.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 +2731,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_errors7.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 +2750,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 +2758,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 +2779,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();
       });
     }
@@ -2050,6 +2976,9 @@
       if (!this.isLoggedIn()) {
         return;
       }
+      if (this.shiftIsPressed()) {
+        return;
+      }
       const block_element = this.getCurrentBlockElement();
       if (block_element === null) {
         return;