@fc3/mmcadi 0.1.0 → 0.1.1

package/dist/client.js

@@ -0,0 +1,1066 @@
+"use strict";
+(() => {
+  // src/lib/errors/error/base.ts
+  var BaseError = class extends Error {
+    constructor(message, code) {
+      message = message.replace(/\s+/g, " ").trim();
+      super(message);
+      this.code = code || null;
+    }
+    getMessage() {
+      return this.message;
+    }
+    getCode() {
+      return this.code;
+    }
+    getData() {
+      const error_type = this.getType();
+      const code = this.getCode();
+      const message = this.getMessage();
+      return {
+        error_type,
+        code,
+        message
+      };
+    }
+  };
+  var base_default = BaseError;
+
+  // src/lib/errors/enum/error-type.ts
+  var ErrorType = /* @__PURE__ */ ((ErrorType2) => {
+    ErrorType2["CONFLICT"] = "conflict";
+    ErrorType2["GENERIC"] = "generic";
+    ErrorType2["OMITTED"] = "omitted";
+    ErrorType2["INVALID"] = "invalid";
+    ErrorType2["NOT_ALLOWED"] = "not_allowed";
+    ErrorType2["NOT_FOUND"] = "not_found";
+    ErrorType2["NOT_IMPLEMENTED"] = "not_implemented";
+    ErrorType2["TIMEOUT"] = "timeout";
+    ErrorType2["UNAUTHORIZED"] = "unauthorized";
+    return ErrorType2;
+  })(ErrorType || {});
+  var error_type_default = ErrorType;
+
+  // src/lib/errors/error/generic.ts
+  var GenericError = class _GenericError extends base_default {
+    static fromNativeError(error) {
+      const coded_error = error;
+      return new _GenericError(coded_error.message, coded_error.code);
+    }
+    constructor(message, code) {
+      super(message || "Something went wrong.", code);
+    }
+    getType() {
+      return error_type_default.GENERIC;
+    }
+  };
+  var generic_default = GenericError;
+
+  // src/lib/errors/error/invalid.ts
+  var InvalidError = class extends base_default {
+    constructor(message) {
+      super(message || "The specified data is invalid.");
+    }
+    getType() {
+      return error_type_default.INVALID;
+    }
+  };
+  var invalid_default = InvalidError;
+
+  // src/lib/errors/error/invariant-violation.ts
+  var InvariantViolation = class extends generic_default {
+  };
+  var invariant_violation_default = InvariantViolation;
+
+  // src/client/enum/page-type.ts
+  var PageType = /* @__PURE__ */ ((PageType2) => {
+    PageType2["HOME"] = "home";
+    PageType2["LOGIN"] = "login";
+    PageType2["LOGOUT"] = "logout";
+    PageType2["DAY"] = "day";
+    PageType2["WEEK"] = "week";
+    PageType2["MONTH"] = "month";
+    PageType2["YEAR"] = "year";
+    PageType2["SELECT_BLOCK_TYPE"] = "select_block_type";
+    PageType2["CREATE_BLOCK"] = "create_block";
+    PageType2["EDIT_BLOCK"] = "edit_block";
+    PageType2["VIEW_CUSTOM"] = "view_custom";
+    PageType2["EDIT_CUSTOM"] = "edit_custom";
+    PageType2["CONFIRM_DELETE_BLOCK"] = "confirm_delete_block";
+    PageType2["MOVE_BLOCK"] = "move_block";
+    PageType2["SETTINGS"] = "settings";
+    return PageType2;
+  })(PageType || {});
+  var page_type_default = PageType;
+
+  // src/lib/array/get-last-value.ts
+  function getLastValue(array) {
+    return array[array.length - 1];
+  }
+  var get_last_value_default = getLastValue;
+
+  // src/lib/array/get-first-value.ts
+  function getFirstValue(array) {
+    return array[0];
+  }
+  var get_first_value_default = getFirstValue;
+
+  // src/client/enum/key-code.ts
+  var KeyCode = /* @__PURE__ */ ((KeyCode2) => {
+    KeyCode2[KeyCode2["ENTER"] = 13] = "ENTER";
+    KeyCode2[KeyCode2["SHIFT"] = 16] = "SHIFT";
+    KeyCode2[KeyCode2["ESCAPE"] = 27] = "ESCAPE";
+    KeyCode2[KeyCode2["ONE"] = 49] = "ONE";
+    KeyCode2[KeyCode2["A"] = 65] = "A";
+    KeyCode2[KeyCode2["B"] = 66] = "B";
+    KeyCode2[KeyCode2["C"] = 67] = "C";
+    KeyCode2[KeyCode2["D"] = 68] = "D";
+    KeyCode2[KeyCode2["E"] = 69] = "E";
+    KeyCode2[KeyCode2["F"] = 70] = "F";
+    KeyCode2[KeyCode2["G"] = 71] = "G";
+    KeyCode2[KeyCode2["H"] = 72] = "H";
+    KeyCode2[KeyCode2["I"] = 73] = "I";
+    KeyCode2[KeyCode2["J"] = 74] = "J";
+    KeyCode2[KeyCode2["K"] = 75] = "K";
+    KeyCode2[KeyCode2["L"] = 76] = "L";
+    KeyCode2[KeyCode2["M"] = 77] = "M";
+    KeyCode2[KeyCode2["N"] = 78] = "N";
+    KeyCode2[KeyCode2["O"] = 79] = "O";
+    KeyCode2[KeyCode2["P"] = 80] = "P";
+    KeyCode2[KeyCode2["Q"] = 81] = "Q";
+    KeyCode2[KeyCode2["R"] = 82] = "R";
+    KeyCode2[KeyCode2["S"] = 83] = "S";
+    KeyCode2[KeyCode2["T"] = 84] = "T";
+    KeyCode2[KeyCode2["U"] = 85] = "U";
+    KeyCode2[KeyCode2["V"] = 86] = "V";
+    KeyCode2[KeyCode2["W"] = 87] = "W";
+    KeyCode2[KeyCode2["X"] = 88] = "X";
+    KeyCode2[KeyCode2["Y"] = 89] = "Y";
+    KeyCode2[KeyCode2["Z"] = 90] = "Z";
+    return KeyCode2;
+  })(KeyCode || {});
+  var key_code_default = KeyCode;
+
+  // src/client/page.ts
+  var Page = class {
+    constructor() {
+      this.shift_pressed = false;
+      this.previous_key_code = null;
+    }
+    start() {
+      this.logStarting();
+      this.initEvents();
+      this.bindLoadEvent();
+      this.logStarted();
+    }
+    bindLoadEvent() {
+      window.addEventListener("load", () => {
+        this.initView();
+      });
+    }
+    initEvents() {
+      window.addEventListener("keydown", (event) => {
+        const key_code = event.keyCode || event.charCode;
+        this.shift_pressed = event.shiftKey;
+        this.handleKey(key_code);
+        if (key_code !== key_code_default.SHIFT) {
+          this.previous_key_code = key_code;
+        }
+      });
+    }
+    initView() {
+    }
+    handleKey(key_code) {
+    }
+    getPreviousKeyCode() {
+      return this.previous_key_code;
+    }
+    shiftIsPressed() {
+      return this.shift_pressed;
+    }
+    focusElement(element) {
+      const rectangle = element.getBoundingClientRect();
+      const headers = Array.from(document.getElementsByTagName("header"));
+      const header = get_first_value_default(headers);
+      const header_offset = header === void 0 ? 0 : header.clientHeight;
+      if (rectangle.top < header_offset) {
+        if (header_offset === 0) {
+          window.scrollBy(0, rectangle.top);
+        } 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);
+        }
+      }
+    }
+    getNumericQueryParameter(key, fallback) {
+      const parameter = this.getQueryParameter(key);
+      if (parameter === void 0) {
+        return fallback;
+      }
+      const parsed_value = parseInt(parameter);
+      if (isNaN(parsed_value)) {
+        return fallback;
+      }
+      return parsed_value;
+    }
+    getQueryParameter(key) {
+      const params = new URLSearchParams(window.location.search);
+      const value = params.get(key);
+      if (value === null) {
+        return void 0;
+      }
+      return value;
+    }
+    setQueryParameter(key, value) {
+      const url = new URL(window.location.href);
+      url.searchParams.set(key, value.toString());
+      url.searchParams.delete("toast_message");
+      url.searchParams.delete("toast_color");
+      window.location.href = url.toString();
+    }
+    logStarting() {
+      const name = this.getName();
+      console.log(`[${name}] starting...`);
+    }
+    logStarted() {
+      const name = this.getName();
+      console.log(`[${name}] started.`);
+    }
+    getName() {
+      return this.constructor.name;
+    }
+  };
+  var page_default = Page;
+
+  // src/client/page/home.ts
+  var HomePage = class extends page_default {
+    initEvents() {
+    }
+  };
+  var home_default = HomePage;
+
+  // src/client/page/login.ts
+  var LoginPage = class extends page_default {
+    initEvents() {
+    }
+  };
+  var login_default = LoginPage;
+
+  // src/client/page/logout.ts
+  var LogoutPage = class extends page_default {
+    initEvents() {
+    }
+  };
+  var logout_default = LogoutPage;
+
+  // src/client/page/day.ts
+  var DayPage = class extends page_default {
+    initEvents() {
+    }
+  };
+  var day_default = DayPage;
+
+  // src/client/page/month.ts
+  var MonthPage = class extends page_default {
+    initEvents() {
+    }
+  };
+  var month_default = MonthPage;
+
+  // src/client/page/week.ts
+  var WeekPage = class extends page_default {
+    initEvents() {
+    }
+  };
+  var week_default = WeekPage;
+
+  // src/client/page/year.ts
+  var YearPage = class extends page_default {
+    initEvents() {
+    }
+  };
+  var year_default = YearPage;
+
+  // src/enum/block-type.ts
+  var BlockType = /* @__PURE__ */ ((BlockType2) => {
+    BlockType2["HEADER"] = "header";
+    BlockType2["NOTE"] = "note";
+    BlockType2["IMAGE"] = "image";
+    BlockType2["AUDIO"] = "audio";
+    BlockType2["EPHEMERAL"] = "ephemeral";
+    BlockType2["CALENDAR"] = "calendar";
+    BlockType2["DIRECTORY"] = "directory";
+    BlockType2["FOLDER"] = "folder";
+    BlockType2["MULTI_COLUMN"] = "multi_column";
+    BlockType2["LINK"] = "link";
+    BlockType2["TODO"] = "todo";
+    BlockType2["LIST"] = "list";
+    BlockType2["BACKGROUND"] = "background";
+    BlockType2["WHITESPACE"] = "whitespace";
+    return BlockType2;
+  })(BlockType || {});
+  var block_type_default = BlockType;
+
+  // src/client/page/select-block-type.ts
+  var SelectBlockTypePage = class extends page_default {
+    handleKey(key_code) {
+      switch (key_code) {
+        case key_code_default.N:
+          return this.createBlockOfType(block_type_default.NOTE);
+        case key_code_default.I:
+          return this.createBlockOfType(block_type_default.IMAGE);
+        case key_code_default.A:
+          return this.createBlockOfType(block_type_default.AUDIO);
+        case key_code_default.T:
+          return this.createBlockOfType(block_type_default.TODO);
+        case key_code_default.H:
+          return this.createBlockOfType(block_type_default.HEADER);
+        case key_code_default.F:
+          return this.createBlockOfType(block_type_default.FOLDER);
+        case key_code_default.L:
+          return this.createBlockOfType(block_type_default.LINK);
+        case key_code_default.M:
+          return this.createBlockOfType(block_type_default.MULTI_COLUMN);
+        default:
+          return super.handleKey(key_code);
+      }
+    }
+    createBlockOfType(block_type) {
+      const id = `add-block-${block_type}`;
+      const element = document.getElementById(id);
+      if (element === null) {
+        throw new invariant_violation_default(`
+				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 invariant_violation_default(`
+				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/create-block.ts
+  var CreateBlockPage = class extends page_default {
+  };
+  var create_block_default = CreateBlockPage;
+
+  // src/client/page/edit-block.ts
+  var EditBlockPage = class extends page_default {
+    initEvents() {
+      super.initEvents();
+      const textarea_nodes = document.getElementsByTagName("textarea");
+      const textareas = Array.from(textarea_nodes);
+      textareas.forEach((textarea) => {
+        let form;
+        let current_node = textarea;
+        while (current_node) {
+          current_node = current_node.parentNode;
+          if (current_node instanceof HTMLFormElement) {
+            form = current_node;
+            break;
+          }
+        }
+        if (form === void 0) {
+          throw new invariant_violation_default(`
+					Tried to read form for textarea, but it was not set
+				`);
+        }
+        textarea.addEventListener("keydown", (event) => {
+          const key_code = event.keyCode || event.charCode;
+          if (key_code === key_code_default.ENTER && event.shiftKey) {
+            event.preventDefault();
+          }
+        });
+      });
+    }
+  };
+  var edit_block_default = EditBlockPage;
+
+  // src/lib/time/enum/time-interval.ts
+  var TimeInterval = /* @__PURE__ */ ((TimeInterval2) => {
+    TimeInterval2[TimeInterval2["ONE_FRAME"] = 16] = "ONE_FRAME";
+    TimeInterval2[TimeInterval2["ONE_SECOND"] = 1e3] = "ONE_SECOND";
+    TimeInterval2[TimeInterval2["ONE_MINUTE"] = 6e4] = "ONE_MINUTE";
+    TimeInterval2[TimeInterval2["ONE_HOUR"] = 36e5] = "ONE_HOUR";
+    TimeInterval2[TimeInterval2["ONE_DAY"] = 864e5] = "ONE_DAY";
+    TimeInterval2[TimeInterval2["ONE_WEEK"] = 6048e5] = "ONE_WEEK";
+    TimeInterval2[TimeInterval2["ONE_MONTH"] = 2592e6] = "ONE_MONTH";
+    TimeInterval2[TimeInterval2["ONE_YEAR"] = 31536e6] = "ONE_YEAR";
+    return TimeInterval2;
+  })(TimeInterval || {});
+  var time_interval_default = TimeInterval;
+
+  // src/client/utility/get-meta-value.ts
+  function getMetaValue(name) {
+    const element = document.querySelector(`meta[name="${name}"]`);
+    if (element === null) {
+      throw new invariant_violation_default(`
+			Tried to read ${name} meta tag, but it was not set
+		`);
+    }
+    if (!(element instanceof HTMLMetaElement)) {
+      throw new invariant_violation_default(`
+			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
+  function validatePath(path) {
+    if (!path.startsWith("/")) {
+      throw new invalid_default(`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/page/view-custom.ts
+  function getAttributeForElement(element, attribute) {
+    const value = element.getAttribute(attribute);
+    if (value === null) {
+      throw new invariant_violation_default(`
+			Tried to read ${attribute} for element, but it was not set
+		`);
+    }
+    return value;
+  }
+  function getBlockActivationHref(block_element) {
+    const link_nodes = block_element.getElementsByTagName("a");
+    const links = Array.from(link_nodes);
+    const matching_link = links.find((link) => {
+      const role = link.getAttribute("data-role");
+      return role === "block_activation";
+    });
+    if (matching_link === void 0) {
+      throw new invariant_violation_default(`
+			Tried to activate link for folder block, but it was not set
+		`);
+    }
+    const href = matching_link.getAttribute("href");
+    if (href === null) {
+      throw new invariant_violation_default(`
+			Tried to activate link for folder block, but its href was not set
+		`);
+    }
+    return href;
+  }
+  function getIndexPathForElement(element) {
+    return getAttributeForElement(element, "data-index-path");
+  }
+  function getBlockTypeForElement(element) {
+    return getAttributeForElement(element, "data-block-type");
+  }
+  var ViewCustomPage = class extends page_default {
+    constructor() {
+      super(...arguments);
+      this.logged_in = false;
+      this.scroll_focusing_enabled = true;
+      this.has_touch_event = false;
+    }
+    initEvents() {
+      super.initEvents();
+      window.addEventListener("touchstart", () => {
+        this.has_touch_event = true;
+      });
+      window.addEventListener("wheel", () => {
+        this.handleWheel();
+      });
+      window.addEventListener("scroll", () => {
+        this.handleScroll();
+      });
+    }
+    handleWheel() {
+      this.enableScrollFocusing();
+      this.queueDisableScrollFocusing();
+    }
+    handleScroll() {
+      if (!this.scrollFocusingEnabled()) {
+        return;
+      }
+      if (this.hasTouchEvent()) {
+        return;
+      }
+      const scroll_element = this.getBlockElementFromScrollPosition();
+      if (scroll_element === null) {
+        return;
+      }
+      const index_path = getIndexPathForElement(scroll_element);
+      this.navigateToIndex(index_path);
+    }
+    initView() {
+      this.focusCurrentBlockElement();
+      const meta_value = get_meta_value_default("logged_in");
+      this.logged_in = meta_value === "true";
+    }
+    getBlockElementFromScrollPosition() {
+      const block_elements = this.getBlockElements();
+      const scroll_y = window.scrollY;
+      const view_height = window.innerHeight;
+      const page_height = document.documentElement.scrollHeight;
+      const total_scrollable_height = page_height - view_height;
+      const scroll_ratio = scroll_y / total_scrollable_height;
+      let total_area = 0;
+      block_elements.forEach((block_element) => {
+        const block_type = getBlockTypeForElement(block_element);
+        if (block_type === block_type_default.MULTI_COLUMN) {
+          return;
+        }
+        const rect = block_element.getBoundingClientRect();
+        const block_area = rect.width * rect.height;
+        total_area += block_area;
+      });
+      let index = 0;
+      let cumulative_area = 0;
+      while (index < block_elements.length) {
+        const block_element = block_elements[index++];
+        const block_type = getBlockTypeForElement(block_element);
+        if (block_type === block_type_default.MULTI_COLUMN) {
+          continue;
+        }
+        const rect = block_element.getBoundingClientRect();
+        const area = rect.width * rect.height;
+        cumulative_area += area;
+        const cumulative_ratio = cumulative_area / total_area;
+        if (cumulative_ratio >= scroll_ratio) {
+          return block_element;
+        }
+      }
+      return null;
+    }
+    focusCurrentBlockElement() {
+      const element = this.getCurrentBlockElement();
+      if (element === null) {
+        return;
+      }
+      this.focusElement(element);
+    }
+    enableScrollFocusing() {
+      if (this.scroll_focusing_timer !== void 0) {
+        clearTimeout(this.scroll_focusing_timer);
+      }
+      this.scroll_focusing_enabled = true;
+    }
+    queueDisableScrollFocusing() {
+      if (this.scroll_focusing_timer !== void 0) {
+        clearTimeout(this.scroll_focusing_timer);
+      }
+      const delay = time_interval_default.ONE_SECOND / 2;
+      this.scroll_focusing_timer = setTimeout(() => {
+        this.disableScrollFocusing();
+      }, delay);
+    }
+    disableScrollFocusing() {
+      if (this.scroll_focusing_timer !== void 0) {
+        clearTimeout(this.scroll_focusing_timer);
+      }
+      this.scroll_focusing_enabled = false;
+    }
+    handleKey(key_code) {
+      switch (key_code) {
+        case key_code_default.ENTER:
+        case key_code_default.O:
+          return this.activateBlock();
+        case key_code_default.L:
+          return this.toggleEditMode();
+        case key_code_default.G:
+          return this.performPageJump();
+        case key_code_default.M:
+          return this.showModificationMenu();
+        case key_code_default.J:
+          return this.selectNextBlock();
+        case key_code_default.K:
+          return this.selectPreviousBlock();
+        case key_code_default.U:
+          return this.navigateToParentPage();
+        case key_code_default.D:
+          return this.deleteCurrentBlock();
+        case key_code_default.A:
+          return this.addBlock();
+        case key_code_default.E:
+          return this.beginEditingBlock();
+        default:
+          return super.handleKey(key_code);
+      }
+    }
+    beginEditingBlock() {
+      if (!this.isLoggedIn()) {
+        return;
+      }
+      const block_element = this.getCurrentBlockElement();
+      if (block_element === null) {
+        return;
+      }
+      const block_id = block_element.id;
+      const link_id = `${block_id}-edit`;
+      const link_element = document.getElementById(link_id);
+      if (link_element === null) {
+        throw new invariant_violation_default(`
+				Unable to find edit link element for block: ${block_id}
+			`);
+      }
+      const href = link_element.getAttribute("href");
+      if (href === null) {
+        throw new invariant_violation_default(`
+				Unable to find edit link href for block: ${block_id}
+			`);
+      }
+      window.location.href = href;
+    }
+    addBlock() {
+      if (!this.isLoggedIn()) {
+        return;
+      }
+      const current_path = this.getCurrentBlockIndex();
+      const top_level_index = parseInt(current_path, 10);
+      if (isNaN(top_level_index)) {
+        throw new invariant_violation_default(`Invalid index path: ${current_path}`);
+      }
+      const add_block_links = document.querySelectorAll('[data-role="add_block_link"]');
+      const link_index = (() => {
+        if (this.shiftIsPressed()) {
+          return top_level_index;
+        } else {
+          return top_level_index + 1;
+        }
+      })();
+      const link = add_block_links[link_index];
+      if (link === void 0) {
+        throw new invariant_violation_default(`
+				Tried to read link at index ${link_index},
+				but it was not found
+			`);
+      }
+      const href = link.getAttribute("href");
+      if (href === null) {
+        throw new invariant_violation_default(`
+				Tried to read href for link at index ${link_index},
+				but it was not set
+			`);
+      }
+      window.location.href = href;
+    }
+    deleteCurrentBlock() {
+      if (!this.isLoggedIn()) {
+        return;
+      }
+      const block_element = this.getCurrentBlockElement();
+      if (block_element === null) {
+        return;
+      }
+      const block_id = block_element.id;
+      const link_id = `${block_id}-delete`;
+      const link_element = document.getElementById(link_id);
+      if (link_element === null) {
+        throw new invariant_violation_default(`
+				Unable to find deletion link element for block: ${block_id}
+			`);
+      }
+      const href = link_element.getAttribute("href");
+      if (href === null) {
+        throw new invariant_violation_default(`
+				Unable to find deletion link href for block: ${block_id}
+			`);
+      }
+      window.location.href = href;
+    }
+    promoteCurrentBlock() {
+      if (!this.isLoggedIn()) {
+        return;
+      }
+      const block_element = this.getCurrentBlockElement();
+      if (block_element === null) {
+        return;
+      }
+      const block_id = block_element.id;
+      const form_id = `${block_id}-promote`;
+      const form_element = document.getElementById(form_id);
+      if (form_element === null) {
+        throw new invariant_violation_default(`
+				Unable to find promotion form element for block: ${block_id}
+			`);
+      }
+      form_element.submit();
+    }
+    demoteCurrentBlock() {
+      if (!this.isLoggedIn()) {
+        return;
+      }
+      const block_element = this.getCurrentBlockElement();
+      if (block_element === null) {
+        return;
+      }
+      const block_id = block_element.id;
+      const form_id = `${block_id}-demote`;
+      const form_element = document.getElementById(form_id);
+      if (form_element === null) {
+        throw new invariant_violation_default(`
+				Unable to find demotion form element for block: ${block_id}
+			`);
+      }
+      form_element.submit();
+    }
+    performPageJump() {
+      if (!this.shiftIsPressed()) {
+        return;
+      }
+      const previous_key_code = this.getPreviousKeyCode();
+      if (previous_key_code === key_code_default.ONE) {
+        this.jumpToPageTop();
+      } else {
+        this.jumpToPageBottom();
+      }
+    }
+    jumpToPageTop() {
+      this.navigateToIndex(this.getFirstBlockIndex());
+      this.focusCurrentBlockElement();
+    }
+    jumpToPageBottom() {
+      this.navigateToIndex(this.getLastBlockIndex());
+      this.focusCurrentBlockElement();
+    }
+    navigateToParentPage() {
+      const parent_path = get_parent_path_default(window.location.pathname);
+      window.location.href = parent_path;
+    }
+    navigateToIndex(index_path) {
+      this.disableScrollFocusing();
+      if (index_path === null) {
+        return;
+      }
+      const block_elements = this.getBlockElements();
+      let found = false;
+      block_elements.forEach((block_element) => {
+        const sibling_path = getIndexPathForElement(block_element);
+        const is_match = sibling_path === index_path;
+        block_element.classList.toggle("selected", is_match);
+        if (is_match) {
+          found = true;
+        }
+      });
+      if (!found) {
+        throw new invariant_violation_default(`
+				Tried to navigate to element at index path ${index_path},
+				but matching element was not found
+			`);
+      }
+      const url = new URL(window.location.href);
+      url.searchParams.set("index_path", index_path);
+      window.history.replaceState({}, "", url);
+    }
+    selectPreviousBlock() {
+      if (this.shiftIsPressed()) {
+        this.promoteCurrentBlock();
+      } else {
+        this.navigateToIndex(this.getPreviousBlockIndex());
+        this.focusCurrentBlockElement();
+      }
+    }
+    selectNextBlock() {
+      if (this.shiftIsPressed()) {
+        this.demoteCurrentBlock();
+      } else {
+        this.navigateToIndex(this.getNextBlockIndex());
+        this.focusCurrentBlockElement();
+      }
+    }
+    toggleEditMode() {
+      const editing_flag = this.getQueryParameter("editing");
+      const editing = editing_flag === "true";
+      const new_value = editing ? "false" : "true";
+      this.setQueryParameter("editing", new_value);
+    }
+    getCurrentBlockIndex() {
+      const element = this.getCurrentBlockElement();
+      if (element === null) {
+        return "0";
+      }
+      return getIndexPathForElement(element);
+    }
+    getCurrentBlockNumericIndex() {
+      const index = this.getCurrentBlockIndex();
+      return parseInt(index);
+    }
+    getBlockElements() {
+      const elements = document.getElementsByClassName("block");
+      return Array.from(elements);
+    }
+    getCurrentBlockElement() {
+      const block_elements = this.getBlockElements();
+      const selected_element = block_elements.find((element2) => {
+        return element2.classList.contains("selected");
+      });
+      if (selected_element !== void 0) {
+        return selected_element;
+      }
+      const index_path = (() => {
+        const query_path = this.getQueryParameter("index_path");
+        if (query_path !== void 0) {
+          return query_path;
+        }
+        return this.getFirstBlockIndex();
+      })();
+      if (index_path === null) {
+        return null;
+      }
+      const element = block_elements.find((element2) => {
+        const attribute = getIndexPathForElement(element2);
+        return attribute === index_path;
+      });
+      return element || null;
+    }
+    getFirstBlockIndex() {
+      const blocks = this.getBlockElements();
+      const first_block = get_first_value_default(blocks);
+      if (first_block === void 0) {
+        return null;
+      }
+      return getIndexPathForElement(first_block);
+    }
+    getLastBlockIndex() {
+      const blocks = this.getBlockElements();
+      const last_block = get_last_value_default(blocks);
+      if (last_block === void 0) {
+        return null;
+      }
+      return getIndexPathForElement(last_block);
+    }
+    getNextBlockIndex() {
+      const current_block = this.getCurrentBlockElement();
+      const blocks = this.getBlockElements();
+      const current_index = current_block ? blocks.indexOf(current_block) : -1;
+      const next_block = blocks[current_index + 1];
+      if (next_block === void 0) {
+        return null;
+      }
+      return getIndexPathForElement(next_block);
+    }
+    getPreviousBlockIndex() {
+      const current_block = this.getCurrentBlockElement();
+      const blocks = this.getBlockElements();
+      const current_index = current_block ? blocks.indexOf(current_block) : -1;
+      const previous_block = blocks[current_index - 1];
+      if (previous_block === void 0) {
+        return null;
+      }
+      return previous_block.getAttribute("data-index-path");
+    }
+    activateBlock() {
+      const block_element = this.getCurrentBlockElement();
+      if (block_element === null) {
+        return;
+      }
+      const attribute = block_element.getAttribute("data-block-type");
+      if (attribute === null) {
+        throw new invariant_violation_default(`
+				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 invariant_violation_default(`
+				Invalid block type: ${block_type}
+			`);
+      }
+      switch (block_type) {
+        case block_type_default.FOLDER:
+          return this.activateFolderBlock(block_element);
+        case block_type_default.TODO:
+          return this.activateTodoBlock(block_element);
+        case block_type_default.IMAGE:
+          return this.activateImageBlock(block_element);
+        default:
+          return console.warn(`no-op activation for block of type ${block_type}`);
+      }
+    }
+    activateTodoBlock(block_element) {
+      const forms = block_element.getElementsByTagName("form");
+      const form = forms[0];
+      if (form === void 0) {
+        throw new invariant_violation_default(`
+				Tried to activate form for todo block, but it was not set
+			`);
+      }
+      form.submit();
+    }
+    activateFolderBlock(block_element) {
+      const href = getBlockActivationHref(block_element);
+      window.location.href = href;
+    }
+    activateImageBlock(block_element) {
+      const href = getBlockActivationHref(block_element);
+      window.location.href = href;
+    }
+    showModificationMenu() {
+    }
+    isLoggedIn() {
+      return this.logged_in;
+    }
+    scrollFocusingEnabled() {
+      return this.scroll_focusing_enabled;
+    }
+    hasTouchEvent() {
+      return this.has_touch_event;
+    }
+  };
+  var view_custom_default = ViewCustomPage;
+
+  // src/client/page/edit-custom.ts
+  var EditCustomPage = class extends view_custom_default {
+    handleKey(key_code) {
+      switch (key_code) {
+        case key_code_default.U:
+          return this.toggleEditMode();
+        default:
+          return super.handleKey(key_code);
+      }
+    }
+  };
+  var edit_custom_default = EditCustomPage;
+
+  // src/client/page/confirm-delete-block.ts
+  var ConfirmDeleteBlockPage = class extends page_default {
+    handleKey(key_code) {
+      switch (key_code) {
+        case key_code_default.D:
+          return this.submitDeletionForm();
+        default:
+          return super.handleKey(key_code);
+      }
+    }
+    submitDeletionForm() {
+      const element = document.getElementById("deletion-form");
+      if (element === null) {
+        throw new invariant_violation_default("Could not find deletion form element");
+      }
+      const form = element;
+      form.submit();
+    }
+  };
+  var confirm_delete_block_default = ConfirmDeleteBlockPage;
+
+  // src/client/page/move-block.ts
+  var MoveBlockPage = class extends page_default {
+    initEvents() {
+    }
+  };
+  var move_block_default = MoveBlockPage;
+
+  // src/client/page/settings.ts
+  var SettingsPage = class extends page_default {
+    initEvents() {
+    }
+  };
+  var settings_default = SettingsPage;
+
+  // src/client/factory/page.ts
+  var PageConstructors = {
+    [page_type_default.HOME]: home_default,
+    [page_type_default.LOGIN]: login_default,
+    [page_type_default.LOGOUT]: logout_default,
+    [page_type_default.DAY]: day_default,
+    [page_type_default.WEEK]: week_default,
+    [page_type_default.MONTH]: month_default,
+    [page_type_default.YEAR]: year_default,
+    [page_type_default.SELECT_BLOCK_TYPE]: select_block_type_default,
+    [page_type_default.CREATE_BLOCK]: create_block_default,
+    [page_type_default.EDIT_BLOCK]: edit_block_default,
+    [page_type_default.VIEW_CUSTOM]: view_custom_default,
+    [page_type_default.EDIT_CUSTOM]: edit_custom_default,
+    [page_type_default.CONFIRM_DELETE_BLOCK]: confirm_delete_block_default,
+    [page_type_default.MOVE_BLOCK]: move_block_default,
+    [page_type_default.SETTINGS]: settings_default
+  };
+  var PageFactory = class {
+    constructor(page_type) {
+      this.page_type = page_type;
+    }
+    create() {
+      const page_type = this.getPageType();
+      const page_constructor = PageConstructors[page_type];
+      return new page_constructor();
+    }
+    getPageType() {
+      return this.page_type;
+    }
+  };
+  var page_default2 = PageFactory;
+
+  // src/client/client.ts
+  var Client = class {
+    start() {
+      try {
+        const page = this.buildPage();
+        page.start();
+      } catch (error) {
+        if (!(error instanceof Error)) {
+          throw error;
+        }
+        document.body.innerHTML = `
+				<main>
+					<section class="red">
+						<strong>ERROR:</strong>
+						${error.message}
+						<pre>${error.stack}</pre>
+					</section>
+				</main>
+			`;
+      }
+    }
+    buildPage() {
+      const page_type = this.determinePageType();
+      const factory = new page_default2(page_type);
+      const page = factory.create();
+      return page;
+    }
+    determinePageType() {
+      const meta_value = get_meta_value_default("page_type");
+      const page_type = meta_value;
+      const page_types = Object.values(page_type_default);
+      if (!page_types.includes(page_type)) {
+        throw new invariant_violation_default(`
+				Invalid page type: ${page_type}
+			`);
+      }
+      return page_type;
+    }
+  };
+  var client_default = Client;
+
+  // src/client/bootstrap.ts
+  var client = new client_default();
+  client.start();
+})();