use biome to format code

.gitignore

@@ -6,8 +6,3 @@
 # Dist
 node_modules
 dist/
-
-# IDE
-.vscode/*
-!.vscode/extensions.json
-.idea

.vscode/settings.json

@@ -0,0 +1,4 @@
+{
+    "editor.defaultFormatter": "biomejs.biome",
+    "editor.formatOnSave": true
+}

document/components/playboard.tsx

@@ -1,9 +1,9 @@
 import { useEffect, useRef, useState } from 'react';
-import { AnchorQuery } from '../../src/query';
-import { AnchorEditor } from '../../src/editor';
-import { anchorToStrong } from '../../src/helper';
 // biome-ignore lint/style/useImportType: <explanation>
 import React from 'react';
+import { AnchorEditor } from '../../src/editor';
+import { anchorToStrong } from '../../src/helper';
+import { AnchorQuery } from '../../src/query';
 
 interface EditableDivProps {
   initialContent?: string;
@@ -143,7 +143,7 @@ export const EditablePlay: React.FC<EditableDivProps> = ({
               direction: 'right',
               stride: 'char',
             });
-            
+
             if (ret.error && intervalRef.current) {
               console.log('setStartAnchorTo failed');
               clearInterval(intervalRef.current);

document/docs/version.json

@@ -1,4 +1,4 @@
 {
-    "version": "unknown",
-    "buildTime": "unknown"
+  "version": "unknown",
+  "buildTime": "unknown"
 }

package.json

@@ -12,9 +12,7 @@
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "files": [
-    "dist"
-  ],
+  "files": ["dist"],
   "scripts": {
     "build": "rslib build",
     "check": "biome check --write",

src/editor.ts

@@ -1,91 +1,94 @@
-import type { StatefulAnchorEditorInterface, Anchor, Step, NeighborResult } from "./interface";
-import { AnchorQuery } from "./query";
+import type {
+  Anchor,
+  NeighborResult,
+  StatefulAnchorEditorInterface,
+  Step,
+} from './interface';
+import { AnchorQuery } from './query';
 
-
-
-export class AnchorEditor extends AnchorQuery implements StatefulAnchorEditorInterface {
-    lastMoveDirection: "left" | "right" | "up" | "down" | "none" = "none";
-    lastMoveAnchor: "start" | "end" | "none" = "none";
-    // constructor(config: LocConfig, root: HTMLElement) {
-    //     super(config, root);
-    // }
-    resetAnchor(anchor: Anchor): Anchor | null {
-        const selection = document.getSelection();
-        if (selection) {
-            selection.setPosition(anchor.container, anchor.offset);
-            this.lastMoveDirection = "none";
-            this.lastMoveAnchor = "none";
-            return anchor;
-        }
-        return null;
+export class AnchorEditor
+  extends AnchorQuery
+  implements StatefulAnchorEditorInterface
+{
+  lastMoveDirection: 'left' | 'right' | 'up' | 'down' | 'none' = 'none';
+  lastMoveAnchor: 'start' | 'end' | 'none' = 'none';
+  // constructor(config: LocConfig, root: HTMLElement) {
+  //     super(config, root);
+  // }
+  resetAnchor(anchor: Anchor): Anchor | null {
+    const selection = document.getSelection();
+    if (selection) {
+      selection.setPosition(anchor.container, anchor.offset);
+      this.lastMoveDirection = 'none';
+      this.lastMoveAnchor = 'none';
+      return anchor;
     }
-    resetStartAnchor(anchor: Anchor): Anchor | null {
-        const range = document.getSelection()?.getRangeAt(0);
-        if (range) {
-            range.setStart(anchor.container, anchor.offset);
-            this.lastMoveDirection = "none";
-            this.lastMoveAnchor = "start";
-            return anchor;
-        }
-        return null;
+    return null;
+  }
+  resetStartAnchor(anchor: Anchor): Anchor | null {
+    const range = document.getSelection()?.getRangeAt(0);
+    if (range) {
+      range.setStart(anchor.container, anchor.offset);
+      this.lastMoveDirection = 'none';
+      this.lastMoveAnchor = 'start';
+      return anchor;
     }
-    resetEndAnchor(anchor: Anchor): Anchor | null {
-        const range = document.getSelection()?.getRangeAt(0);
-        if (range) {
-            range.setEnd(anchor.container, anchor.offset);
-            this.lastMoveDirection = "none";
-            this.lastMoveAnchor = "end";
-            return anchor;
-        }
-        return null;
+    return null;
+  }
+  resetEndAnchor(anchor: Anchor): Anchor | null {
+    const range = document.getSelection()?.getRangeAt(0);
+    if (range) {
+      range.setEnd(anchor.container, anchor.offset);
+      this.lastMoveDirection = 'none';
+      this.lastMoveAnchor = 'end';
+      return anchor;
     }
+    return null;
+  }
 
-
-    resetRange(start: Anchor, end: Anchor): boolean {
-        const range = document.getSelection()?.getRangeAt(0);
-        if (range) {
-            range.setStart(start.container, start.offset);
-            range.setEnd(end.container, end.offset);
-            this.lastMoveDirection = "none";
-            this.lastMoveAnchor = "none";
-            return true;
-        }
-        return false;
+  resetRange(start: Anchor, end: Anchor): boolean {
+    const range = document.getSelection()?.getRangeAt(0);
+    if (range) {
+      range.setStart(start.container, start.offset);
+      range.setEnd(end.container, end.offset);
+      this.lastMoveDirection = 'none';
+      this.lastMoveAnchor = 'none';
+      return true;
     }
+    return false;
+  }
 
-
-
-    moveEndAnchorTo(step: Step): NeighborResult {
-        const range = document.getSelection()?.getRangeAt(0);
-        if (range) {
-            const result = this.getHorizontalAnchor({
-                anchor: { container: range.endContainer, offset: range.endOffset },
-                step: step,
-            });
-            if (result.next) {
-                this.resetEndAnchor(result.next);
-                this.lastMoveDirection = step.direction;
-                this.lastMoveAnchor = "end";
-                return result;
-            }
-        }
-        throw new Error("no selection");
+  moveEndAnchorTo(step: Step): NeighborResult {
+    const range = document.getSelection()?.getRangeAt(0);
+    if (range) {
+      const result = this.getHorizontalAnchor({
+        anchor: { container: range.endContainer, offset: range.endOffset },
+        step: step,
+      });
+      if (result.next) {
+        this.resetEndAnchor(result.next);
+        this.lastMoveDirection = step.direction;
+        this.lastMoveAnchor = 'end';
+        return result;
+      }
     }
+    throw new Error('no selection');
+  }
 
-    moveStartAnchorTo(step: Step): NeighborResult {
-        const range = document.getSelection()?.getRangeAt(0);
-        if (range) {
-            const result = this.getHorizontalAnchor({
-                anchor: { container: range.startContainer, offset: range.startOffset },
-                step: step,
-            });
-            if (result.next) {
-                this.resetStartAnchor(result.next);
-                this.lastMoveDirection = step.direction;
-                this.lastMoveAnchor = "start";
-            }
-            return result;
-        }
-        throw new Error("no selection");
+  moveStartAnchorTo(step: Step): NeighborResult {
+    const range = document.getSelection()?.getRangeAt(0);
+    if (range) {
+      const result = this.getHorizontalAnchor({
+        anchor: { container: range.startContainer, offset: range.startOffset },
+        step: step,
+      });
+      if (result.next) {
+        this.resetStartAnchor(result.next);
+        this.lastMoveDirection = step.direction;
+        this.lastMoveAnchor = 'start';
+      }
+      return result;
     }
+    throw new Error('no selection');
+  }
 }

src/errors.ts

@@ -1,49 +1,48 @@
-import { NodeToString, anchorToStrong } from "./helper";
-import type { Anchor } from "./interface";
+import { NodeToString, anchorToStrong } from './helper';
+import type { Anchor } from './interface';
 
 export enum ErrorCode {
-    INVALID_NODE = "INVALID_NODE",
-    INVALID_ANCHOR = "INVALID_ANCHOR",
-    INVALID_DIRECTION = "INVALID_DIRECTION",
-    INVALID_OFFSET = "INVALID_OFFSET",
-    AT_BOUNDARY = "AT_BOUNDARY",
-    PARENT_NOT_FOUND = "PARENT_NOT_FOUND",
-    CALCULATION_ERROR = "CALCULATION_ERROR",
-  }
-
-  export interface ErrorLocation {
-    clazz: string;
-    method: string;
-    case?: string;
-  }
-
+  INVALID_NODE = 'INVALID_NODE',
+  INVALID_ANCHOR = 'INVALID_ANCHOR',
+  INVALID_DIRECTION = 'INVALID_DIRECTION',
+  INVALID_OFFSET = 'INVALID_OFFSET',
+  AT_BOUNDARY = 'AT_BOUNDARY',
+  PARENT_NOT_FOUND = 'PARENT_NOT_FOUND',
+  CALCULATION_ERROR = 'CALCULATION_ERROR',
+}
 
-  export interface QueryError {
-    code: ErrorCode;
-    message: string;
-    location: ErrorLocation;
-    context?: { [key: string]: unknown };
-  }
-
+export interface ErrorLocation {
+  clazz: string;
+  method: string;
+  case?: string;
+}
 
+export interface QueryError {
+  code: ErrorCode;
+  message: string;
+  location: ErrorLocation;
+  context?: { [key: string]: unknown };
+}
 
 export class InvalidAnchorError extends Error {
-    constructor(anchor: Anchor) {
-        super(`Anchor: \n ${anchorToStrong(anchor)}`);
-        this.name = "InvalidAnchorError";
-    }
+  constructor(anchor: Anchor) {
+    super(`Anchor: \n ${anchorToStrong(anchor)}`);
+    this.name = 'InvalidAnchorError';
+  }
 }
 
 export class InvalidBoundaryDirectionError extends Error {
-    constructor(container: Node, direction: string) {
-        super(`Invalid boundary direction ${direction} in node: \n${NodeToString(container)}`);
-        this.name = "InvalidBoundaryDirectionError";
-    }
+  constructor(container: Node, direction: string) {
+    super(
+      `Invalid boundary direction ${direction} in node: \n${NodeToString(container)}`,
+    );
+    this.name = 'InvalidBoundaryDirectionError';
+  }
 }
 
 export class InvalidNodeTypeError extends Error {
-    constructor(node: Node) {
-        super(`Invalid node type ${node.nodeName}`);
-        this.name = "InvalidNodeTypeError";
-    }
-}
+  constructor(node: Node) {
+    super(`Invalid node type ${node.nodeName}`);
+    this.name = 'InvalidNodeTypeError';
+  }
+}