[elpa] externals/org-remark 92d3b17bf3 099/173: change name org-hana to org-remark

[ELPA Syncer]

branch: externals/org-remark
commit 92d3b17bf372887f2d5f35861b45bcada9f46b4d
Author: Noboru Ota <me@nobiot.com>
Commit: Noboru Ota <me@nobiot.com>

    change name org-hana to org-remark
---
 org-hana-global-tracking.el   | 107 ---------
 org-remark-global-tracking.el | 107 +++++++++
 org-hana.el => org-remark.el  | 527 +++++++++++++++++++++---------------------
 3 files changed, 373 insertions(+), 368 deletions(-)

diff --git a/org-hana-global-tracking.el b/org-hana-global-tracking.el
deleted file mode 100644
index d484ef17e8..0000000000
--- a/org-hana-global-tracking.el
+++ /dev/null
@@ -1,107 +0,0 @@
-;;; org-hana-global-tracking.el --- Track files with highlights & annotations 
-*- lexical-binding: t; -*-
-
-;; Copyright (C) 2020 Noboru Ota
-
-;; Author: Noboru Ota <me@nobiot.com>
-;; URL: https://github.com/nobiot/org-hana
-;; Last modified: 02 January 2022
-;; Package-Requires: ((emacs "27.1") (org "9.4"))
-;; Keywords: org-mode, annotation, writing, note-taking, marginal-notes
-
-;; This file is not part of GNU Emacs.
-
-;; This program is free software; you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation, either version 3 of the License, or
-;; (at your option) any later version.
-
-;; This program is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-;;; Commentary:
-;;  This file is part of org-hana
-
-;;; Code:
-
-(declare-function org-hana-mode "org-hana")
-
-(defcustom org-hana-tracking-file
-  (locate-user-emacs-file ".org-hana-tracking" nil)
-  "File name where the files `org-hana' tracks is saved.
-When `org-hana-global-tracking-mode' is active, opening a file
-saved in `org-hana-tracking-file' automatically loads highlights."
-  :group 'org-hana
-  :type 'file)
-
-(defvar org-hana-tracking-file-loaded nil)
-
-(defvar org-hana-files-tracked nil)
-
-;;;###autoload
-(define-minor-mode org-hana-global-tracking-mode
-  "Track files saved in `org-hana-tracking-file'.
-When opening any of them, automatically activates `org-hana-mode'
-locally for the file opened."
-  :init-value nil
-  :group 'org-hana
-  :lighter " ❦-tracking"
-  :global t
-  (cond
-   (org-hana-global-tracking-mode
-    ;; Activate
-    (when (and (not org-hana-tracking-file-loaded)
-              (file-exists-p org-hana-tracking-file))
-      (org-hana-tracking-load))
-    (add-hook 'find-file-hook #'org-hana-tracking-auto-on)
-    (add-hook 'kill-emacs-hook #'org-hana-tracking-save))
-   (t
-    ;; Deactivate
-    (setq org-hana-files-tracked nil)
-    (setq org-hana-tracking-file-loaded nil)
-    (remove-hook 'find-file-hook #'org-hana-tracking-auto-on)
-    (remove-hook 'kill-emacs-hook #'org-hana-tracking-save))))
-
-;;;; Private Functions
-
-(defun org-hana-tracking-auto-on ()
-  "Activate `org-hana-mode' when file is being tracked.
-The files being tracked are loaded on to
-`org-hana-files-tracked'.  Refer to
-`org-hana-tracking-load'."
-  (when (and org-hana-files-tracked
-            (member (abbreviate-file-name (buffer-file-name))
-                    org-hana-files-tracked))
-    (unless (featurep 'org-hana) (require 'org-hana))
-    (org-hana-mode +1)))
-
-(defun org-hana-tracking-load ()
-  "Load files being tracked from `org-hana-tracking-file'.
-It has one filename each line.  The filename is obtrained
-`abbreviated-file-names'.  This function reloads the content of
-the file regardless if it is already done in this Emacs session
-or not."
-  (with-temp-buffer
-    (condition-case nil
-       (progn
-         (insert-file-contents org-hana-tracking-file)
-         (setq org-hana-files-tracked
-               (split-string (buffer-string) "\n"))
-          (setq org-hana-tracking-file-loaded t)))))
-
-(defun org-hana-tracking-save ()
-  "Save files being tracked in `org-hana-tracking-file'.
-Files with marginal notes are tracked with variable
-`org-hana-files-tracked'."
-  (interactive)
-  (when org-hana-files-tracked
-    (with-temp-file org-hana-tracking-file
-      (insert (mapconcat 'identity org-hana-files-tracked "\n")))))
-
-(provide 'org-hana-global-tracking)
-
-;;; org-hana-global-tracking.el ends here
diff --git a/org-remark-global-tracking.el b/org-remark-global-tracking.el
new file mode 100644
index 0000000000..7ca8664165
--- /dev/null
+++ b/org-remark-global-tracking.el
@@ -0,0 +1,107 @@
+;;; org-remark-global-tracking.el --- Track files with highlights & 
annotations -*- lexical-binding: t; -*-
+
+;; Copyright (C) 2020 Noboru Ota
+
+;; Author: Noboru Ota <me@nobiot.com>
+;; URL: https://github.com/nobiot/org-remark
+;; Last modified: 03 January 2022
+;; Package-Requires: ((emacs "27.1") (org "9.4"))
+;; Keywords: org-mode, annotation, writing, note-taking, marginal-notes
+
+;; This file is not part of GNU Emacs.
+
+;; This program is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+;;  This file is part of org-remark
+
+;;; Code:
+
+(declare-function org-remark-mode "org-remark")
+
+(defcustom org-remark-tracking-file
+  (locate-user-emacs-file ".org-remark-tracking" nil)
+  "File name where the files `org-remark' tracks is saved.
+When `org-remark-global-tracking-mode' is active, opening a file
+saved in `org-remark-tracking-file' automatically loads highlights."
+  :group 'org-remark
+  :type 'file)
+
+(defvar org-remark-tracking-file-loaded nil)
+
+(defvar org-remark-files-tracked nil)
+
+;;;###autoload
+(define-minor-mode org-remark-global-tracking-mode
+  "Track files saved in `org-remark-tracking-file'.
+When opening any of them, automatically activates `org-remark-mode'
+locally for the file opened."
+  :init-value nil
+  :group 'org-remark
+  :lighter " ormk-auto"
+  :global t
+  (cond
+   (org-remark-global-tracking-mode
+    ;; Activate
+    (when (and (not org-remark-tracking-file-loaded)
+              (file-exists-p org-remark-tracking-file))
+      (org-remark-tracking-load))
+    (add-hook 'find-file-hook #'org-remark-tracking-auto-on)
+    (add-hook 'kill-emacs-hook #'org-remark-tracking-save))
+   (t
+    ;; Deactivate
+    (setq org-remark-files-tracked nil)
+    (setq org-remark-tracking-file-loaded nil)
+    (remove-hook 'find-file-hook #'org-remark-tracking-auto-on)
+    (remove-hook 'kill-emacs-hook #'org-remark-tracking-save))))
+
+;;;; Private Functions
+
+(defun org-remark-tracking-auto-on ()
+  "Activate `org-remark-mode' when file is being tracked.
+The files being tracked are loaded on to
+`org-remark-files-tracked'.  Refer to
+`org-remark-tracking-load'."
+  (when (and org-remark-files-tracked
+            (member (abbreviate-file-name (buffer-file-name))
+                    org-remark-files-tracked))
+    (unless (featurep 'org-remark) (require 'org-remark))
+    (org-remark-mode +1)))
+
+(defun org-remark-tracking-load ()
+  "Load files being tracked from `org-remark-tracking-file'.
+It has one filename each line.  The filename is obtrained
+`abbreviated-file-names'.  This function reloads the content of
+the file regardless if it is already done in this Emacs session
+or not."
+  (with-temp-buffer
+    (condition-case nil
+       (progn
+         (insert-file-contents org-remark-tracking-file)
+         (setq org-remark-files-tracked
+               (split-string (buffer-string) "\n"))
+          (setq org-remark-tracking-file-loaded t)))))
+
+(defun org-remark-tracking-save ()
+  "Save files being tracked in `org-remark-tracking-file'.
+Files with marginal notes are tracked with variable
+`org-remark-files-tracked'."
+  (interactive)
+  (when org-remark-files-tracked
+    (with-temp-file org-remark-tracking-file
+      (insert (mapconcat 'identity org-remark-files-tracked "\n")))))
+
+(provide 'org-remark-global-tracking)
+
+;;; org-remark-global-tracking.el ends here
diff --git a/org-hana.el b/org-remark.el
similarity index 58%
rename from org-hana.el
rename to org-remark.el
index f601815c28..46591c782d 100644
--- a/org-hana.el
+++ b/org-remark.el
@@ -1,11 +1,11 @@
-;;; org-hana.el --- Highlight & ANnotate Any text file (HANA) -*- 
lexical-binding: t; -*-
+;;; org-remark.el --- Highlight & annotate text file -*- lexical-binding: t; 
-*-
 
 ;; Copyright (C) 2020-2022 Noboru Ota
 
 ;; Author: Noboru Ota <me@nobiot.com>
-;; URL: https://github.com/nobiot/org-hana
+;; URL: https://github.com/nobiot/org-remark
 ;; Version: 0.0.7
-;; Last modified: 03 January 2022
+;; Last modified: 2022-01-03T191527
 ;; Package-Requires: ((emacs "27.1") (org "9.4"))
 ;; Keywords: org-mode, annotation, writing, note-taking, marginal-notes
 
@@ -26,8 +26,8 @@
 
 ;;; Commentary:
 
-;; This package lets you highlight and annote any text file in a separate Org
-;; file.  Refer to README.org and docstring for detail.
+;; This package lets you highlight and annote any text file with using Org 
mode.
+;; Refer to README.org and docstring for detail.
 
 ;;; Code:
 
@@ -35,18 +35,18 @@
 
 (require 'org)
 (require 'org-id)
-(require 'org-hana-global-tracking)
+(require 'org-remark-global-tracking)
 (declare-function org-collect-keywords "org")
 
 ;;;; Customization
 
-(defgroup org-hana nil
+(defgroup org-remark nil
   "Highlight and annote any text file in a separate Org file."
   :group 'org
-  :prefix "org-hana-"
-  :link '(url-link :tag "Github" "https://github.com/nobiot/org-hana";))
+  :prefix "org-remark-"
+  :link '(url-link :tag "Github" "https://github.com/nobiot/org-remark";))
 
-(defface org-hana-highlighter
+(defface org-remark-highlighter
   '((((class color) (min-colors 88) (background light))
      :underline "#aecf90" :background "#ecf7ed")
     (((class color) (min-colors 88) (background dark))
@@ -55,115 +55,115 @@
      :inherit highlight))
   "Face for the default highlighter pen.")
 
-(defcustom org-hana-notes-file-path "marginalia.org"
+(defcustom org-remark-notes-file-path "marginal-notes.org"
   "Specify the file path to store the location of highlights and annotations.
 The default is one file per directory.  Ensure that it is an Org
 file."
   :type 'file)
 
-(defcustom org-hana-use-org-id t
-  "Define if Org-HANA use Org-ID to link back to the main note."
+(defcustom org-remark-use-org-id t
+  "Define if Org-remark use Org-ID to link back to the main note."
   :type 'boolean)
 
 ;;;; Variables
 
-(defvar-local org-hana-loaded nil
+(defvar-local org-remark-loaded nil
   "Indicate if hightlights have been loaded onto current buffer.")
 
-(defvar-local org-hana-highlights '()
+(defvar-local org-remark-highlights '()
   "Keep track of all the highlights in current buffer.
 It is a local variable and is a list of overlays.  Each overlay
 represents a highlighted text region.
 
 On `save-buffer' each highlight will be save in the notes file at
-`org-hana-notes-file-path'.")
+`org-remark-notes-file-path'.")
 
-(defvar org-hana-last-notes-buffer nil
+(defvar org-remark-last-notes-buffer nil
   "Stores the cloned indirect buffer visting the notes file.
 It is meant to exist only one of these in each Emacs session.")
 
 ;; Const for the names of properties in Org Mode
 ;; Kept for backward compatiblity reasons
-(defconst org-hana-prop-id "marginalia-id")
-(defconst org-hana-prop-source-file "marginalia-source-file")
-(defconst org-hana-prop-source-beg "marginalia-source-beg")
-(defconst org-hana-prop-source-end "marginalia-source-end")
+(defconst org-remark-prop-id "org-remark-id")
+(defconst org-remark-prop-source-file "org-remark-file")
+(defconst org-remark-prop-source-beg "org-remark-beg")
+(defconst org-remark-prop-source-end "org-remark-end")
 
 ;;;; Commands
 
 ;;;###autoload
-(define-minor-mode org-hana-mode
-    "Highlight text, write margin notes for any text file in Org Mode.
+(define-minor-mode org-remark-mode
+    "Highlight and annote any text file with using Org mode.
 This is a local minor-mode.
 
 On activation, it loads your saved highlights from the marginalia
 file and enables automatic saving of highlights.
 
 The automatic saving is achieved via function
-`org-hana-save' added to `after-save-hook'.
+`org-remark-save' added to `after-save-hook'.
 
 On deactivation, it removes all the overlays and stops tracking
 the highlights in this buffer by setting variable
-`org-hana-highlights' to nil.  Be careful of behavior, if
+`org-remark-highlights' to nil.  Be careful of behavior, if
 you still wish to retain the locations of highlights.
 
-It is recommended to use `org-hana-toggle' if you wish to
+It is recommended to use `org-remark-toggle' if you wish to
 temporarily hide highlights in the current buffer.  It keeps
-`org-hana-highlights' unchanged.
+`org-remark-highlights' unchanged.
 
 While the tracking of highlights is stopped,
 editing the buffer will likely result in mismatch between the
 saved highlights' locations and the current buffer's text
 content.
 
-Highlights tracked by variable `org-hana-highlights' cannot
+Highlights tracked by variable `org-remark-highlights' cannot
 persist when you kill the buffer or quit Emacs.  When you
 re-launch Emacs and visit the same file, ensure to turn on
-`org-hana-mode' to load the highlights from the marginalia
-file.  `org-hana-global-tracking-mode' can automate this.
+`org-remark-mode' to load the highlights from the marginalia
+file.  `org-remark-global-tracking-mode' can automate this.
 
-\\{org-hana-mode-map}"
+\\{org-remark-mode-map}"
     :init-value nil
-    :lighter " ❦"
+    :lighter " ormk"
     :global nil
     :keymap (let ((map (make-sparse-keymap)))
               map)
     (cond
-     (org-hana-mode
+     (org-remark-mode
       ;; Activate
-      (org-hana-load)
-      (add-hook 'after-save-hook #'org-hana-save nil t)
-      (add-hook 'kill-buffer-hook #'org-hana-tracking-save nil t))
+      (org-remark-load)
+      (add-hook 'after-save-hook #'org-remark-save nil t)
+      (add-hook 'kill-buffer-hook #'org-remark-tracking-save nil t))
      (t
       ;; Deactivate
-      (when org-hana-highlights
-       (dolist (highlight org-hana-highlights)
+      (when org-remark-highlights
+       (dolist (highlight org-remark-highlights)
          (delete-overlay highlight)))
-      (setq org-hana-highlights nil)
-      (setq org-hana-loaded nil)
-      (org-hana-tracking-save)
-      (remove-hook 'after-save-hook #'org-hana-save t)
-      (remove-hook 'kill-buffer-hook #'org-hana-tracking-save t))))
-
-;;; `org-hana-create-pen' macro lets you create commands for different 
highlighter pens
-;;; Org-HANA provides three default ones. See below after `org-hana-create-pen'
-(defmacro org-hana-create-pen (&optional label face properties)
+      (setq org-remark-highlights nil)
+      (setq org-remark-loaded nil)
+      (org-remark-tracking-save)
+      (remove-hook 'after-save-hook #'org-remark-save t)
+      (remove-hook 'kill-buffer-hook #'org-remark-tracking-save t))))
+
+;;; `org-remark-create-pen' macro lets you create commands for different 
highlighter pens
+;;; Org-remark provides three default ones. See below after 
`org-remark-create-pen'
+(defmacro org-remark-create-pen (&optional label face properties)
   "Create a user-defined highlighter function.
 LABEL is the name of the highlighter.  The function will be called
-`org-hana-mark-LABEL', or, when LABEL is nil, the default
-`org-hana-mark'.
+`org-remark-mark-LABEL', or, when LABEL is nil, the default
+`org-remark-mark'.
 
 The highlighter function will apply FACE to the selected region.
 FACE can be an anonymous face.  When it is nil, this macro uses
-the default face `org-hana-highlight'.
+the default face `org-remark-highlight'.
 
 PROPERTIES is a list of pairs of a symbol and value.  Each
 highlighted text region will have a corresponding Org headline in
 the notes file, and it can have properties from the highlighter
-pen.  To do this, prefix property names with \"org-hana-\" or use
+pen.  To do this, prefix property names with \"org-remark-\" or use
 \"CATEGORY\"."
-  `(defun ,(intern (or (when label (format "org-hana-mark-%s" label))
-                       "org-hana-mark"))
+  `(defun ,(intern (or (when label (format "org-remark-mark-%s" label))
+                       "org-remark-mark"))
        (beg end &optional id)
      ,(format "Apply the following face to the region selected by BEG and END.
 %s
@@ -177,125 +177,78 @@ start tracking the highlight's location, so that you can 
edit the
 text around.
 
 It will not create a marginalia entry yet. Save the current
-buffer or call `org-hana-save' to create a new entry (it is
+buffer or call `org-remark-save' to create a new entry (it is
 automatic with `after-save-hook').
 
 When this function is called from Elisp, ID can be optionally
 passed. If so, no new ID gets generated.
 
 Every highlighted text region in the current buffer is tracked by
-local variable `org-hana-highlights'. The highlights are
+local variable `org-remark-highlights'. The highlights are
 sorted in the ascending order; this is a property of the variable
-used for `org-hana-next' and `org-hana-prev'."
-              (or face "`org-hana-highlight'") properties)
+used for `org-remark-next' and `org-remark-prev'."
+              (or face "`org-remark-highlight'") properties)
      (interactive "r")
-     (org-hana-highlight beg end ,label ,face ,properties id)))
+     (org-remark-highlight beg end ,label ,face ,properties id)))
 
 ;; Don't use category (symbol) as a property -- it's a special one of text
 ;; properties. If you use it, the value also need to be a symbol; otherwise, 
you
 ;; will get an error. You can use CATEGORY (symbol and all uppercase).
 
-(org-hana-create-pen) ;; create the default mark function with default face
-                      ;; `org-hana-highlight' with no properties.
-(org-hana-create-pen "orange"
+(org-remark-create-pen) ;; create the default mark function with default face
+                      ;; `org-remark-highlight' with no properties.
+(org-remark-create-pen "orange"
                            '(:underline (:color "dark red" :style wave) 
:weight bold)
-                           '(CATEGORY "must" help-echo "high impact"))
-(org-hana-create-pen "yellow"
+                           '(CATEGORY "correction" help-echo "Fix this"))
+(org-remark-create-pen "yellow"
                            '(:underline "gold" :background "lemon chiffon") 
'(CATEGORY "important"))
 
 ;;;###autoload
-(defun org-hana-load ()
-  "Visit `org-hana-notes-file' & load the saved highlights onto current buffer.
+(defun org-remark-load ()
+  "Visit `org-remark-notes-file' & load the saved highlights onto current 
buffer.
 If there is no highligths or annotations for current buffer,
 output a message in the echo.
 
-Highlights tracked locally by variable `org-hana-highlights'
+Highlights tracked locally by variable `org-remark-highlights'
 cannot persist when you kill current buffer or quit Emacs.  It is
-recommended to set `org-hana-global-tracking-mode' in your
-configuration.  It automatically turns on `org-hana-mode', which
-runs `org-hana-load' for current buffer.
+recommended to set `org-remark-global-tracking-mode' in your
+configuration.  It automatically turns on `org-remark-mode', which
+runs `org-remark-load' for current buffer.
 
-Otherwise, do not forget to turn on `org-hana-mode' manually to
+Otherwise, do not forget to turn on `org-remark-mode' manually to
 load the highlights"
   (interactive)
-  (unless org-hana-mode (org-hana-mode +1))
-  (unless org-hana-loaded
-    (when-let* ((filename (buffer-file-name))
-               (notes-buf (find-file-noselect org-hana-notes-file-path))
-               (source-path (abbreviate-file-name filename)))
-      ;; Get hilights: each highlighlight is stored as an alist
-      ;; TODO check if there is any relevant notes for the current file
-      (let ((highlights '()))
-       (with-current-buffer notes-buf
-          (org-with-wide-buffer
-           (let ((heading (org-find-property
-                          org-hana-prop-source-file source-path)))
-             (if (not heading)
-                (message "No highlights or annotations found for %s." 
source-path)
-               (goto-char (org-find-property
-                          org-hana-prop-source-file source-path))
-               ;; Narrow to only subtree for a single file.  
`org-find-property'
-               ;; ensures that it is the beginning of a headline
-               (org-narrow-to-subtree)
-               ;; It's important that the headline levels are fixed
-               ;; H1: File
-               ;; H2: Higlighted region (each one has a dedicated H2 subtree)
-               (while (not (org-next-visible-heading 1))
-                 ;; The `or' for backward compatibility.  The consts are no
-                 ;; longer used in the current version
-                (when-let ((id (or
-                                 (org-entry-get (point) "org-hana-id")
-                                 (org-entry-get (point) org-hana-prop-id)))
-                            (beg (string-to-number
-                                  (or
-                                   (org-entry-get (point)
-                                                 "org-hana-source-beg")
-                                  (org-entry-get (point)
-                                                 org-hana-prop-source-beg))))
-                            (end (string-to-number
-                                  (or
-                                   (org-entry-get (point)
-                                                 "org-hana-source-end")
-                                  (org-entry-get (point)
-                                                 org-hana-prop-source-end)))))
-                   (push (list id
-                               (cons beg end)
-                               (org-entry-get (point) "org-hana-label"))
-                         highlights)))))))
-       ;; Back to the current buffer
-       ;; Loop highilights and add them to the current buffer
-        ;; Each highlight is a list in the following structure:
-        ;;
-        ;;     (id (beg . end) label)
-        ;;
-       (dolist (highlight highlights)
-          (let ((id (car highlight))
-               (beg (caadr highlight))
-               (end (cdadr highlight))
-                (label (caddr highlight)))
-            (let ((fn (intern (concat "org-hana-mark-" label))))
-              (unless (functionp fn) (setq fn #'org-hana-mark))
-              (funcall fn beg end id))))))
-    ;; Tracking
-    (when org-hana-global-tracking-mode
-      (add-to-list 'org-hana-files-tracked
-                  (abbreviate-file-name (buffer-file-name))))
-    (setq org-hana-loaded t)))
-
-(defun org-hana-save ()
+  (unless org-remark-mode (org-remark-mode 1+1))
+  (unless org-remark-loaded
+    ;; Loop highilights and add them to the current buffer
+    (dolist (highlight (org-remark-highlights-get))
+      (let ((id (car highlight))
+           (beg (caadr highlight))
+           (end (cdadr highlight))
+            (label (caddr highlight)))
+        (let ((fn (intern (concat "org-remark-mark-" label))))
+          (unless (functionp fn) (setq fn #'org-remark-mark))
+          (funcall fn beg end id)))))
+  ;; Tracking
+  (when org-remark-global-tracking-mode
+    (add-to-list 'org-remark-files-tracked
+                (abbreviate-file-name (buffer-file-name))))
+  (setq org-remark-loaded t))
+
+(defun org-remark-save ()
   "Save all the highlights tracked in current buffer to notes file.
-Variable`org-hana-notes-file-path' defines the file path.
+Variable`org-remark-notes-file-path' defines the file path.
 
 This funcion is automatically called when you save the current
 buffer via `after-save-hook'.  This function is added to it by
-function `org-hana-mode' when you activate the minor mode.
+function `org-remark-mode' when you activate the minor mode.
 
-When `org-hana-global-tracking-mode' is on, this function also
-adds current buffer to variable `org-hana-files-tracked' so that
-next time you visit this file, `org-hana-mode' can be
+When `org-remark-global-tracking-mode' is on, this function also
+adds current buffer to variable `org-remark-files-tracked' so that
+next time you visit this file, `org-remark-mode' can be
 automatically turned on to load the highlights.
 
-`org-hana-highlights' is the local variable that tracks every highlight
+`org-remark-highlights' is the local variable that tracks every highlight
 in the current buffer.  Each highlight is represented by an overlay."
   (interactive)
   (let* ((filename (buffer-file-name))
@@ -303,41 +256,41 @@ in the current buffer.  Each highlight is represented by 
an overlay."
          (title (or (cadr (assoc "TITLE" (org-collect-keywords '("TITLE"))))
                     (file-name-sans-extension
                     (file-name-nondirectory (buffer-file-name))))))
-    (org-hana-housekeep)
-    (org-hana-sort-highlights-list)
-    (dolist (h org-hana-highlights)
-      (let ((orgid (and org-hana-use-org-id
+    (org-remark-housekeep)
+    (org-remark-sort-highlights-list)
+    (dolist (h org-remark-highlights)
+      (let ((orgid (and org-remark-use-org-id
                        (org-entry-get (overlay-start h) "ID" 'INHERIT))))
-       (org-hana-save-single-highlight h title source-path orgid)))
+       (org-remark-save-single-highlight h title source-path orgid)))
     ;; Tracking
-    (when org-hana-global-tracking-mode
-      (add-to-list 'org-hana-files-tracked
+    (when org-remark-global-tracking-mode
+      (add-to-list 'org-remark-files-tracked
                   (abbreviate-file-name (buffer-file-name))))))
 
-(defun org-hana-open (point)
+(defun org-remark-open (point)
   "Open hightlight and annocation at POINT, narrowed to the relevant headline.
 It creates a cloned indirect buffer of the notes file
-\(`org-hana-notes-file-path'\).  You can edit notes file as a in
+\(`org-remark-notes-file-path'\).  You can edit notes file as a in
 a normal Org file.  Once you have done editing, you can simply
 save and kill the buffer.
 
 This package ensures that there is only one cloned buffer for
 notes file by tracking it."
   (interactive "d")
-  (when (buffer-live-p org-hana-last-notes-buffer)
-    (kill-buffer org-hana-last-notes-buffer))
-  (when-let ((id (get-char-property point 'org-hana-id))
+  (when (buffer-live-p org-remark-last-notes-buffer)
+    (kill-buffer org-remark-last-notes-buffer))
+  (when-let ((id (get-char-property point 'org-remark-id))
              (ibuf (make-indirect-buffer
-                    (find-file-noselect org-hana-notes-file-path)
+                    (find-file-noselect org-remark-notes-file-path)
                    "*marginal notes*" 'clone)))
-    (setq org-hana-last-notes-buffer ibuf)
+    (setq org-remark-last-notes-buffer ibuf)
     (org-switch-to-buffer-other-window ibuf)
     (widen)(goto-char (point-min))
-    (when (org-find-property org-hana-prop-id id)
-      (goto-char (org-find-property org-hana-prop-id id))
-      (org-narrow-to-subtree))))
+    (when-let (p (or (org-find-property org-remark-prop-id id)
+                     (org-find-property "marginalia-id" id)))
+      (goto-char p)(org-narrow-to-subtree))))
 
-(defun org-hana-remove (point &optional arg)
+(defun org-remark-remove (point &optional arg)
   "Remove the highlight at POINT.
 It will remove the highlight and the properties from the
 marginalia, but will keep the headline and notes.  This is to
@@ -351,20 +304,20 @@ buffer, but not in the current buffer as adding and 
removing overlays
 are not part of the undo tree."
   (interactive "d\nP")
   ;; TODO There may be multiple overlays
-  (when-let* ((id (get-char-property point 'org-hana-id)))
+  (when-let* ((id (get-char-property point 'org-remark-id)))
     ;; Remove the highlight overlay and id
     (dolist (ov (overlays-at (point)))
-      ;; Remove the element in the variable org-hana-highlights
-      (when (overlay-get ov 'org-hana-id)
-       (delete ov org-hana-highlights)
+      ;; Remove the element in the variable org-remark-highlights
+      (when (overlay-get ov 'org-remark-id)
+       (delete ov org-remark-highlights)
        (delete-overlay ov)))
-    (org-hana-housekeep)
-    (org-hana-sort-highlights-list)
+    (org-remark-housekeep)
+    (org-remark-sort-highlights-list)
     ;; Update the notes file accordingly
-    (org-hana-remove-single-highlight id arg)
+    (org-remark-remove-single-highlight id arg)
     t))
 
-(defun org-hana-next ()
+(defun org-remark-next ()
   "Move to the next highlight, if any.
 If there is none below the point but there is a highlight in the
 buffer, cycle back to the first one.
@@ -377,20 +330,20 @@ this example:
 
 This is achieved by transient map with `set-transient-map'.
 
-If you have the same prefix for `org-hana-prev', you can combine it in
+If you have the same prefix for `org-remark-prev', you can combine it in
 the sequence like so:
 
    C-n \] \] \] \[ \["
   (interactive)
-  (if (not org-hana-highlights)
+  (if (not org-remark-highlights)
       (progn (message "No highlights present in this buffer.") nil)
-    (let ((p (org-hana-find-next-highlight)))
+    (let ((p (org-remark-find-next-highlight)))
       (if p (progn
               (goto-char p)
               ;; Setup the overriding keymap.
               (unless overriding-terminal-local-map
                 (let ((prefix-keys (substring (this-single-command-keys) 0 -1))
-                      (map (cdr org-hana-mode-map)))
+                      (map (cdr org-remark-mode-map)))
                   (when (< 0 (length prefix-keys))
                     (mapc (lambda (k) (setq map (assq k map))) prefix-keys)
                     (setq map (cdr-safe map))
@@ -398,7 +351,7 @@ the sequence like so:
               t)
         (message "Nothing done. No more visible highlights exist") nil))))
 
-(defun org-hana-prev ()
+(defun org-remark-prev ()
   "Move to the previous highlight, if any.
 If there is none above the point, but there is a highlight in the
 buffer, cycle back to the last one.
@@ -411,20 +364,20 @@ this example:
 
 This is achieved by transient map with `set-transient-map'.
 
-If you have the same prefix for `org-hana-next', you can combine it in
+If you have the same prefix for `org-remark-next', you can combine it in
 the sequence like so:
 
    C-n \] \] \] \[ \["
   (interactive)
-  (if (not org-hana-highlights)
+  (if (not org-remark-highlights)
       (progn (message "No highlights present in this buffer.") nil)
-    (let ((p (org-hana-find-prev-highlight)))
+    (let ((p (org-remark-find-prev-highlight)))
       (if p (progn
               (goto-char p)
               ;; Setup the overriding keymap.
               (unless overriding-terminal-local-map
                 (let ((prefix-keys (substring (this-single-command-keys) 0 -1))
-                      (map (cdr org-hana-mode-map)))
+                      (map (cdr org-remark-mode-map)))
                   (when (< 0 (length prefix-keys))
                     (mapc (lambda (k) (setq map (assq k map))) prefix-keys)
                     (setq map (cdr-safe map))
@@ -432,74 +385,75 @@ the sequence like so:
               t)
         (message "Nothing done. No more visible highlights exist") nil))))
 
-(defun org-hana-toggle ()
+(defun org-remark-toggle ()
   "Toggle showing/hiding of highlighters in current buffer.
 It only affects the display of the highlighters.  Their locations
 are still kept tracked; upon buffer-save the correct locations
 are still recorded in the marginalia file."
   (interactive)
-  (when-let ((highlights org-hana-highlights))
+  (when-let ((highlights org-remark-highlights))
     ;; Check the first highlight in the buffer
     ;; If it's hidden, all hidden. Show them.
     ;; If not, all shown. Hide them.
     (if-let* ((beg (overlay-start (nth 0 highlights)))
-              (hidden-p (get-char-property beg 'org-hana-hidden)))
-        (org-hana-show)
-      (org-hana-hide))
+              (hidden-p (get-char-property beg 'org-remark-hidden)))
+        (org-remark-show)
+      (org-remark-hide))
     t))
 
 ;;;; Functions
 
 ;;;;; Private
 
-(defun org-hana-highlight (beg end label face properties &optional id)
+
+(defun org-remark-highlight (beg end label face properties &optional id)
   "Highlight the selected region between BEG and END.
 This function performs the main work for the command created via
-`org-hana-create-pen'.
+`org-remark-create-pen'.
 
 Create a user-defined highlighter function.
 LABEL is the name of the highlighter.  The function will be called
-`org-hana-mark-LABEL', or, when LABEL is nil, the default
-`org-hana-mark'.
+`org-remark-mark-LABEL', or, when LABEL is nil, the default
+`org-remark-mark'.
 
 The highlighter function will apply FACE to the selected
 region.  FACE can be an anonymous face.  When it is nil, this
-macro uses the default face `org-hana-highlight'.
+macro uses the default face `org-remark-highlight'.
 
 PROPERTIES is a list of pairs of a symbol and value.  Each
 highlighted text region will have a corresponding Org headline in
 the notes file, and it can have properties from the highlighter
-pen.  To do this, prefix property names with \"org-hana-\" or use
+pen.  To do this, prefix property names with \"org-remark-\" or use
 \"CATEGORY\".
 
 When this function is called from Elisp, ID can be optionally
 passed. If so, no new ID gets generated."
   ;; Ensure to turn on the local minor mode
-  (unless org-hana-mode (org-hana-mode +1))
+  (unless org-remark-mode (org-remark-mode +1))
   ;; UUID is too long; does not have to be the full length
   (when (not id) (setq id (substring (org-id-uuid) 0 8)))
   ;; Add highlight to the text
   (org-with-wide-buffer
    (let ((ov (make-overlay beg end nil 'FRONT-ADVANCE)))
-     (overlay-put ov 'face (if face face 'org-hana-highlighter))
+     (overlay-put ov 'face (if face face 'org-remark-highlighter))
      (while properties
        (let ((prop (pop properties))
              (val (pop properties)))
          (overlay-put ov prop val)))
-     (when label (overlay-put ov 'org-hana-label label))
-     (overlay-put ov 'org-hana-id id)
+     (when label (overlay-put ov 'org-remark-label label))
+     (overlay-put ov 'org-remark-id id)
      ;; Keep track of the overlay in a local variable. It's a list that is
-     ;; guranteed to contain only org-hana overlays as opposed to the one
+     ;; guranteed to contain only org-remark overlays as opposed to the one
      ;; returned by `overlay-lists' that lists any overlays.
-     (push ov org-hana-highlights)
+     (push ov org-remark-highlights)
      ;; Adding overlay to the buffer does not set the buffer modified. You
      ;; cannot use `undo' to undo highlighter, either.
      (deactivate-mark)
      (unless (buffer-modified-p) (restore-buffer-modified-p t))))
-  (org-hana-housekeep)
-  (org-hana-sort-highlights-list))
+  (org-remark-housekeep)
+  (org-remark-sort-highlights-list))
 
-(defun org-hana-save-single-highlight (highlight title path orgid)
+(defun org-remark-save-single-highlight (highlight title path orgid)
   "Save a single HIGHLIGHT in the notes file with properties.
 The notes file is specified by PATH.
 
@@ -515,37 +469,37 @@ while keep the headline text intact, because the user 
might have
 changed it to their needs.
 
 ORGID can be passed to this function.  If user option
-`org-hana-use-org-id' is non-nil, this function will create a
+`org-remark-use-org-id' is non-nil, this function will create a
 link back to the source via an Org-ID link with using ORGID
 instead of the normal file link.
 
-When a new notes file is created and `org-hana-use-org-id' is
+When a new notes file is created and `org-remark-use-org-id' is
 non-nil, this function adds ID property to the file level.  This
 can be helpful with other packages such as Org-roam's backlink
 feature."
   (let* ((beg (overlay-start highlight))
          (end (overlay-end highlight))
-        (id (overlay-get highlight 'org-hana-id))
+        (id (overlay-get highlight 'org-remark-id))
          ;;`org-with-wide-buffer is a macro that should work for non-Org file'
          (text (org-with-wide-buffer (buffer-substring-no-properties beg end)))
          (props (overlay-properties highlight)))
     ;; TODO Want to add a check if save is applicable here.
-    (with-current-buffer (find-file-noselect org-hana-notes-file-path)
+    (with-current-buffer (find-file-noselect org-remark-notes-file-path)
       ;; If it is a new empty marginalia file
-      (when (and (org-hana-empty-buffer-p) org-hana-use-org-id)
+      (when (and (org-remark-empty-buffer-p) org-remark-use-org-id)
        (org-id-get-create))
       (org-with-wide-buffer
        (let ((file-headline (or (org-find-property
-                                org-hana-prop-source-file path)
+                                org-remark-prop-source-file path)
                                 (progn
                                   ;; If file-headline does not exist, create 
one at the bottom
                                   (goto-char (point-max))
                                   ;; Ensure to be in the beginning of line to 
add a new headline
                                   (when (eolp) (open-line 1) (forward-line 1) 
(beginning-of-line))
                                   (insert (concat "* " title "\n"))
-                                  (org-set-property org-hana-prop-source-file 
path)
+                                  (org-set-property 
org-remark-prop-source-file path)
                                   (org-up-heading-safe) (point))))
-             (id-headline (org-find-property org-hana-prop-id id)))
+             (id-headline (org-find-property org-remark-prop-id id)))
          (if id-headline
              (progn
                (goto-char id-headline)
@@ -553,7 +507,7 @@ feature."
                 ;; Don't update the headline text when it already exists
                 ;; Let the user decide how to manage the headlines
                 ;; (org-edit-headline text)
-               (org-hana-notes-set-properties nil beg end props))
+               (org-remark-notes-set-properties nil beg end props))
            ;; No headline with the marginal notes ID property. Create a new one
            ;; at the end of the file's entry
            (goto-char file-headline)
@@ -564,41 +518,91 @@ feature."
            ;; Create a headline
            ;; Add a properties
            (insert (concat "** " text "\n"))
-           (org-hana-notes-set-properties id beg end props)
-          (if (and org-hana-use-org-id orgid)
+           (org-remark-notes-set-properties id beg end props)
+          (if (and org-remark-use-org-id orgid)
               (insert (concat "[[id:" orgid "]" "[" title "]]"))
             (insert (concat "[[file:" path "]" "[" title "]]"))))))
       (when (buffer-modified-p) (save-buffer) t))))
 
-(defun org-hana-notes-set-properties (id beg end &optional props)
+(defun org-remark-notes-set-properties (id beg end &optional props)
   "Set properties for the headline in the notes file.
 Return t.
 
 Minimal properties are:
 
-- org-hana-id :: ID
-- org-hana-source-beg :: BEG
-- org-hana-source-end :: END
+- org-remark-id :: ID
+- org-remark-source-beg :: BEG
+- org-remark-source-end :: END
 
 For PROPS, if the property name is CATEGORY \(case-sensitive\) or
-prefixed with org-hana- set them to to headline's property
+prefixed with org-remark- set them to to headline's property
 drawer."
-  ;;(when id (org-set-property org-hana-prop-id id))
-  (org-set-property org-hana-prop-source-beg
+  ;;(when id (org-set-property org-remark-prop-id id))
+  (org-set-property org-remark-prop-source-beg
                    (number-to-string beg))
-  (org-set-property org-hana-prop-source-end
+  (org-set-property org-remark-prop-source-end
                    (number-to-string end))
   (while props
     (let ((p (pop props))
           (v (pop props)))
       (when (symbolp p) (setq p (symbol-name p)))
       (when (or (string-equal "CATEGORY" (upcase p))
-                (and (> (length p) 9)
-                     (string-equal "org-hana-" (downcase (substring p 0 9)))))
+                (and (> (length p) 11)
+                     (string-equal "org-remark-" (downcase (substring p 0 
11)))))
         (org-set-property p v))))
   t)
 
-(defun org-hana-list-highlights-positions (&optional reverse)
+(defun org-remark-highlights-get ()
+  "Return a list of highlights from `org-remark-notes-file-path'.
+Each highlight is a list in the following structure:
+    (id (beg . end) label)"  
+  (when-let ((notes-buf (find-file-noselect org-remark-notes-file-path))
+            (source-path (abbreviate-file-name (buffer-file-name))))
+    ;; TODO check if there is any relevant notes for the current file
+    (let ((highlights))
+      (with-current-buffer notes-buf
+        (org-with-wide-buffer
+         ;; The `or' for backward compatibility.
+         ;; "marginalia-xx" is no longer used in the current version
+         (let ((heading (or (org-find-property
+                            org-remark-prop-source-file source-path)
+                            (org-find-property
+                            "marginalia-source-file" source-path))))
+           (if (not heading)
+              (message "No highlights or annotations found for %s."
+                        source-path)
+             (goto-char heading)
+             ;; Narrow to only subtree for a single file.  `org-find-property'
+             ;; ensures that it is the beginning of a headline
+             (org-narrow-to-subtree)
+             ;; It's important that the headline levels are fixed
+             ;; H1: File
+             ;; H2: Higlighted region (each one has a dedicated H2 subtree)
+             (while (not (org-next-visible-heading 1))
+               ;; The `or' for backward compatibility.  "marginalia-xx" is no
+               ;; longer used in the current version
+              (when-let ((id (or
+                               (org-entry-get (point) org-remark-prop-id)
+                               (org-entry-get (point) "marginalia-id")))
+                          (beg (string-to-number
+                                (or
+                                 (org-entry-get (point)
+                                               org-remark-prop-source-beg)
+                                (org-entry-get (point)
+                                               "marginalia-source-beg"))))
+                          (end (string-to-number
+                                (or
+                                 (org-entry-get (point)
+                                               org-remark-prop-source-end)
+                                (org-entry-get (point)
+                                               "marginalia-source-end")))))
+                 (push (list id
+                             (cons beg end)
+                             (org-entry-get (point) "org-remark-label"))
+                       highlights))))
+           highlights))))))
+
+(defun org-remark-list-highlights-positions (&optional reverse)
   "Return list of beg points of highlights in this buffer.
 By default, the list is in ascending order.
 If REVERSE is non-nil, return list in the descending order.
@@ -607,8 +611,8 @@ It also checks if the position is visible or not.  Return 
only
 visible ones.
 
 If none, return nil."
-  (when org-hana-highlights
-    (let ((list org-hana-highlights))
+  (when org-remark-highlights
+    (let ((list org-remark-highlights))
       (setq list (mapcar
                   (lambda (h)
                     (let ((p (overlay-start h)))
@@ -625,80 +629,81 @@ If none, return nil."
       (when list
         (if reverse (reverse list) list)))))
 
-(defun org-hana-sort-highlights-list ()
-  "Utility function to sort `org-hana-sort-highlights'.
-It checks if there is any element exists for `org-hana-highlights'.
+(defun org-remark-sort-highlights-list ()
+  "Utility function to sort `org-remark-sort-highlights'.
+It checks if there is any element exists for `org-remark-highlights'.
 Instead of receiving it as an arg, it assumes its existence.  It
-also distructively updates `org-hana-highlights'.
+also distructively updates `org-remark-highlights'.
 It returns t when sorting is done."
-  (when org-hana-highlights
-    (setq org-hana-highlights
+  (when org-remark-highlights
+    (setq org-remark-highlights
          (seq-sort-by (lambda (ov) (overlay-start ov))
                       #'<
-                      org-hana-highlights))
+                      org-remark-highlights))
     t))
 
-(defun org-hana-find-next-highlight ()
+(defun org-remark-find-next-highlight ()
   "Return the beg point of the next highlight.
-Look through `org-hana-highlights' list."
-  (when-let ((points (org-hana-list-highlights-positions)))
+Look through `org-remark-highlights' list."
+  (when-let ((points (org-remark-list-highlights-positions)))
       ;; Find the first occurance of p > (point). If none, this means all the
       ;; points occur before the current point. Take the first one. Assume
-      ;; `org-hana-highlights' is sorted in the ascending order (it is).
+      ;; `org-remark-highlights' is sorted in the ascending order (it is).
     (seq-find (lambda (p) (> p (point))) points (nth 0 points))))
 
-(defun org-hana-find-prev-highlight ()
+(defun org-remark-find-prev-highlight ()
   "Return the beg point of the previous highlight.
-Look through `org-hana-highlights' list (in descending order)."
-  (when-let ((points (org-hana-list-highlights-positions 'reverse)))
+Look through `org-remark-highlights' list (in descending order)."
+  (when-let ((points (org-remark-list-highlights-positions 'reverse)))
       ;; Find the first occurance of p < (point). If none, this means all the
       ;; points occur before the current point. Take the first one. Assume
-      ;; `org-hana-highlights' is sorted in the descending order .
+      ;; `org-remark-highlights' is sorted in the descending order .
     (seq-find (lambda (p) (< p (point))) points (nth 0 points))))
 
-(defun org-hana-hide ()
+(defun org-remark-hide ()
   "Hide highlights.
 This function removes the font-lock-face of all the highlights,
-and add org-hana-hidden property with value t. It does not
+and add org-remark-hidden property with value t. It does not
 check the current hidden state, thus not interactive.  Use
-`org-hana-toggle' command to manually toggle the show/hide
+`org-remark-toggle' command to manually toggle the show/hide
 state."
-  (when-let ((highlights org-hana-highlights))
+  (when-let ((highlights org-remark-highlights))
     (dolist (highlight highlights)
+      (overlay-put highlight 'org-remark-face (overlay-get highlight 'face))
       (overlay-put highlight 'face nil)
-      (overlay-put highlight 'org-hana-hidden t))
+      (overlay-put highlight 'org-remark-hidden t))
     t))
 
-(defun org-hana-show ()
+(defun org-remark-show ()
   "Show highlights.
 This function adds the font-lock-face to all the highlighted text
 regions.  It does not check the current hidden state, thus not
-interactive.  Use `org-hana-toggle' command to manually toggle
+interactive.  Use `org-remark-toggle' command to manually toggle
 the show/hide state."
-  (when-let ((highlights org-hana-highlights))
+  (when-let ((highlights org-remark-highlights))
     (dolist (highlight highlights)
-      (overlay-put highlight 'org-hana-hidden nil)
+      (overlay-put highlight 'org-remark-hidden nil)
       ;; TODO it does not work wtih new pens
-      (overlay-put highlight 'face 'org-hana-highlighter))
+      (overlay-put highlight 'face (overlay-get highlight 'org-remark-face)))
     t))
 
-(defun org-hana-remove-single-highlight (id &optional delete-notes)
+(defun org-remark-remove-single-highlight (id &optional delete-notes)
   "Remove the highlight entry for ID for current buffer.
 By default, it deletes only the properties of the entry keeping
 the headline intact.  You can pass DELETE-NOTES and delete the
 all notes of the entry."
-  (with-current-buffer (find-file-noselect org-hana-notes-file-path)
+  (with-current-buffer (find-file-noselect org-remark-notes-file-path)
       (org-with-wide-buffer
-       (when-let ((id-headline (org-find-property org-hana-prop-id id)))
+       (when-let ((id-headline (org-find-property org-remark-prop-id id)))
          (goto-char id-headline)
         (org-narrow-to-subtree)
          (dolist (prop (org-entry-properties))
-           (when (string-prefix-p "org-hana-" (downcase (car prop)))
+           (when (string-prefix-p "org-remark-" (downcase (car prop)))
              (org-delete-property (car prop))))
          ;; Backward compatible
-         (org-delete-property org-hana-prop-id)
-         (org-delete-property org-hana-prop-source-beg)
-         (org-delete-property org-hana-prop-source-end)
+         (org-delete-property org-remark-prop-id)
+         (org-delete-property org-remark-prop-source-beg)
+         (org-delete-property org-remark-prop-source-end)
          (when delete-notes
            ;; TODO I would love to add the y-n prompt if there is any notes 
written
            (delete-region (point-min)(point-max))
@@ -706,8 +711,8 @@ all notes of the entry."
         (when (buffer-modified-p) (save-buffer))))
       t))
 
-(defun org-hana-housekeep ()
-  "Housekeep the internal variable `org-hana-highlights'.
+(defun org-remark-housekeep ()
+  "Housekeep the internal variable `org-remark-highlights'.
 This is a private function; housekeep is automatically done on
 mark, save, and remove -- before sort-highlights.
 
@@ -721,19 +726,19 @@ Case 2. The overlay points to no buffer
 
         This case happens when overlay is deleted by
         `overlay-delete' but the variable not cleared."
-  (dolist (ov org-hana-highlights)
+  (dolist (ov org-remark-highlights)
     ;; Both start and end of an overlay are indentical; this should not happen
     ;; when you manually mark a text region. A typical cause of this case is
     ;; when you delete a region that contains a highlight overlay.
     (when (and (overlay-buffer ov)
               (= (overlay-start ov) (overlay-end ov)))
-      (org-hana-remove-single-highlight (overlay-get ov 'org-hana-id))
+      (org-remark-remove-single-highlight (overlay-get ov 'org-remark-id))
       (delete-overlay ov))
     (unless (overlay-buffer ov)
-      (setq org-hana-highlights (delete ov org-hana-highlights))))
+      (setq org-remark-highlights (delete ov org-remark-highlights))))
   t)
 
-(defun org-hana-empty-buffer-p ()
+(defun org-remark-empty-buffer-p ()
   "Return non-nil when the current buffer is empty."
   (save-excursion
     (goto-char (point-max))
@@ -741,10 +746,10 @@ Case 2. The overlay points to no buffer
 
 ;;;; Footer
 
-(provide 'org-hana)
+(provide 'org-remark)
 
-;;; org-hana.el ends here
+;;; org-remark.el ends here
 
 ;; Local Variables:
-;; eval: (setq-local org-hana-notes-file-path "README.org")
+;; eval: (setq-local org-remark-notes-file-path "README.org")
 ;; End: