@xpadev-net/niconicomments 0.2.48 → 0.2.49

package/dist/bundle.d.ts

@@ -1,294 +1,368 @@
-
-
-
-declare class FlashComment implements IComment {
-    private readonly context;
-    readonly comment: formattedCommentWithSize;
-    private readonly _globalScale;
-    private scale;
-    private scaleX;
-    posY: number;
-    image?: HTMLCanvasElement | null;
-    constructor(comment: formattedComment, context: CanvasRenderingContext2D);
-    get invisible(): boolean;
-    get loc(): commentLoc;
-    get long(): number;
-    get vpos(): number;
-    get width(): number;
-    get height(): number;
-    get flash(): boolean;
-    get layer(): number;
-    get owner(): boolean;
-    get mail(): string[];
-    get lineCount(): number;
-    parseCommandAndNicoscript(comment: formattedComment): formattedCommentWithFont;
-    measureText(comment: measureTextInput): measureTextResult;
-    getCommentSize(parsedData: formattedCommentWithFont): formattedCommentWithSize;
-    draw(vpos: number, showCollision: boolean, debug: boolean): void;
-    getTextImage(): HTMLCanvasElement | null;
-}
-
+import type { formattedComment, formattedCommentWithSize, IComment } from "@/@types/";
+import { formattedCommentWithFont, measureTextInput, measureTextResult } from "@/@types/";
+declare class BaseComment implements IComment {
+    protected readonly context: CanvasRenderingContext2D;
+    protected readonly cacheKey: string;
+    comment: formattedCommentWithSize;
+    posY: number;
+    readonly pluginName: string;
+    image?: HTMLCanvasElement | null;
+    constructor(comment: formattedComment, context: CanvasRenderingContext2D);
+    get invisible(): boolean;
+    get loc(): commentLoc;
+    get long(): number;
+    get vpos(): number;
+    get width(): number;
+    get height(): number;
+    get flash(): boolean;
+    get layer(): number;
+    get owner(): boolean;
+    get mail(): string[];
+    protected getCommentSize(parsedData: formattedCommentWithFont): formattedCommentWithSize;
+    protected parseCommandAndNicoscript(comment: formattedComment): formattedCommentWithFont;
+    protected measureText(comment: measureTextInput): measureTextResult;
+    protected convertComment(comment: formattedComment): formattedCommentWithSize;
+    draw(vpos: number, showCollision: boolean, debug: boolean): void;
+    protected _draw(posX: number, posY: number): void;
+    protected _drawRectColor(posX: number, posY: number): void;
+    protected _drawDebugInfo(posX: number, posY: number, debug: boolean): void;
+    protected _drawCollision(posX: number, posY: number, showCollision: boolean): void;
+    protected getTextImage(): HTMLCanvasElement | null;
+    protected _generateTextImage(): HTMLCanvasElement;
+    protected _cacheImage(image: HTMLCanvasElement): void;
+    protected createCanvas(): {
+        image: HTMLCanvasElement;
+        context: CanvasRenderingContext2D;
+    };
+}
 
-
-
-
-declare class HTML5Comment implements IComment {
-    private readonly context;
-    readonly comment: formattedCommentWithSize;
-    posY: number;
-    image?: HTMLCanvasElement | null;
-    constructor(comment: formattedComment, context: CanvasRenderingContext2D);
-    get invisible(): boolean;
-    get loc(): commentLoc;
-    get long(): number;
-    get vpos(): number;
-    get width(): number;
-    get height(): number;
-    get flash(): boolean;
-    get layer(): number;
-    get owner(): boolean;
-    get mail(): string[];
-    get lineCount(): number;
-    parseCommandAndNicoscript(comment: formattedComment): formattedCommentWithFont;
-    measureText(comment: measureTextInput): measureTextResult;
-    getCommentSize(parsedData: formattedCommentWithFont): formattedCommentWithSize;
-    draw(vpos: number, showCollision: boolean, debug: boolean): void;
-    getTextImage(): HTMLCanvasElement | null;
-}
-
 
-declare let imageCache: {
-    [key: string]: {
-        image: HTMLCanvasElement;
-        timeout: number;
-    };
-};
-declare const resetImageCache: () => void;
-
+import type { formattedComment, formattedCommentWithFont, formattedCommentWithSize, measureTextInput, measureTextResult } from "@/@types/";
+import { BaseComment } from "./BaseComment";
+declare class FlashComment extends BaseComment {
+    private _globalScale;
+    private scale;
+    private scaleX;
+    readonly pluginName: string;
+    constructor(comment: formattedComment, context: CanvasRenderingContext2D);
+    convertComment(comment: formattedComment): formattedCommentWithSize;
+    getCommentSize(parsedData: formattedCommentWithFont): formattedCommentWithSize;
+    parseCommandAndNicoscript(comment: formattedComment): formattedCommentWithFont;
+    measureText(comment: measureTextInput): measureTextResult;
+    _drawCollision(posX: number, posY: number, showCollision: boolean): void;
+    _generateTextImage(): HTMLCanvasElement;
+}
 
-
-declare let nicoScripts: nicoScript;
-declare const resetNicoScripts: () => void;
-
 
-
-declare let plugins: IPlugin[];
-declare const setPlugins: (input: IPlugin[]) => void;
-
+import type { formattedComment, formattedCommentWithFont, formattedCommentWithSize, measureTextInput, measureTextResult } from "@/@types/";
+import { BaseComment } from "./BaseComment";
+declare class HTML5Comment extends BaseComment {
+    readonly pluginName: string;
+    constructor(comment: formattedComment, context: CanvasRenderingContext2D);
+    convertComment(comment: formattedComment): formattedCommentWithSize;
+    getCommentSize(parsedData: formattedCommentWithFont): formattedCommentWithSize;
+    parseCommandAndNicoscript(comment: formattedComment): formattedCommentWithFont;
+    measureText(comment: measureTextInput): measureTextResult;
+    private _measureComment;
+    private _processResizeX;
+    _drawCollision(posX: number, posY: number, showCollision: boolean): void;
+    _generateTextImage(): HTMLCanvasElement;
+}
 
-declare const colors: {
-    white: string;
-    red: string;
-    pink: string;
-    orange: string;
-    yellow: string;
-    green: string;
-    cyan: string;
-    blue: string;
-    purple: string;
-    black: string;
-    white2: string;
-    niconicowhite: string;
-    red2: string;
-    truered: string;
-    pink2: string;
-    orange2: string;
-    passionorange: string;
-    yellow2: string;
-    madyellow: string;
-    green2: string;
-    elementalgreen: string;
-    cyan2: string;
-    blue2: string;
-    marinblue: string;
-    purple2: string;
-    nobleviolet: string;
-    black2: string;
-};
-
 
+export * from "./BaseComment";
+export * from "./FlashComment";
+export * from "./HTML5Comment";
+
+import type {
+  commentSize,
+  formattedComment,
+  IPluginConstructor,
+  platformFont,
+} from "@/@types/";
+import { BaseComment } from "@/comments/";
 
+type configItem<T> = T | { html5: T; flash: T };
+type configSizeItem<T> = { big: T; medium: T; small: T };
+type configResizedItem<T> = { default: T; resized: T };
 
-declare let defaultConfig: BaseConfig;
-declare const initConfig: () => void;
-declare const defaultOptions: BaseOptions;
-declare let config: BaseConfig;
-declare let options: BaseOptions;
-declare const setConfig: (value: BaseConfig) => BaseConfig;
-declare const setOptions: (value: BaseOptions) => BaseOptions;
+type commentStageSize = { width: number; fullWidth: number; height: number };
 
-
-declare const fontTemplates: {
-    arial: {
-        font: string;
-        offset: number;
-        weight: number;
-    };
-    gothic: {
-        font: string;
-        offset: number;
-        weight: number;
-    };
-    gulim: {
-        font: string;
-        offset: number;
-        weight: number;
-    };
-    mincho: {
-        font: string;
-        offset: number;
-        weight: number;
-    };
-    simsun: {
-        font: string;
-        offset: number;
-        weight: number;
-    };
-    macGothicPro6: {
-        font: string;
-        offset: number;
-        weight: number;
-    };
-    macGothicPro3: {
-        font: string;
-        offset: number;
-        weight: number;
-    };
-    macMincho: {
-        font: string;
-        offset: number;
-        weight: number;
-    };
-    macGothic1: {
-        font: string;
-        offset: number;
-        weight: number;
-    };
-    macGothic2: {
-        font: string;
-        offset: number;
-        weight: number;
-    };
-    sansSerif600: {
-        font: string;
-        offset: number;
-        weight: number;
-    };
-    sansSerif400: {
-        font: string;
-        offset: number;
-        weight: number;
-    };
-    serif: {
-        font: string;
-        offset: number;
-        weight: number;
-    };
-};
-declare const fonts: {
-    win7: {
-        defont: FontItem;
-        gothic: FontItem;
-        mincho: FontItem;
-    };
-    win8_1: {
-        defont: FontItem;
-        gothic: FontItem;
-        mincho: FontItem;
-    };
-    win: {
-        defont: FontItem;
-        gothic: FontItem;
-        mincho: FontItem;
-    };
-    mac10_9: {
-        defont: FontItem;
-        gothic: FontItem;
-        mincho: FontItem;
-    };
-    mac10_11: {
-        defont: FontItem;
-        gothic: FontItem;
-        mincho: FontItem;
-    };
-    mac: {
-        defont: FontItem;
-        gothic: FontItem;
-        mincho: FontItem;
-    };
-    other: {
-        defont: FontItem;
-        gothic: FontItem;
-        mincho: FontItem;
-    };
+type flashCharList = {
+  [key in "simsunStrong" | "simsunWeak" | "gulim" | "gothic"]: string;
+};
+type flashMode = "xp" | "vista";
+type flashScriptChar = {
+  [key in "super" | "sub"]: string;
+};
+type fontList = {
+  [key in "gulim" | "simsun"]: string;
+};
+type lineCounts = {
+  [key in "default" | "resized" | "doubleResized"]: configSizeItem<number>;
+};
+type typeDoubleResizeMaxWidth = {
+  [key in "full" | "normal"]: number;
+};
+
+type BaseConfig = {
+  cacheAge: number;
+  canvasHeight: number;
+  canvasWidth: number;
+  collisionRange: { [key in "left" | "right"]: number };
+  colors: { [key: string]: string };
+  commentDrawPadding: number;
+  commentDrawRange: number;
+  commentScale: configItem<number>;
+  commentStageSize: configItem<commentStageSize>;
+  commentYMarginBottom: configSizeItem<number>;
+  commentYOffset: configSizeItem<configResizedItem<number>>;
+  commentYPaddingTop: configResizedItem<number>;
+  contextFillLiveOpacity: number;
+  contextLineWidth: number;
+  contextStrokeColor: string;
+  contextStrokeInversionColor: string;
+  contextStrokeOpacity: number;
+  doubleResizeMaxWidth: configItem<typeDoubleResizeMaxWidth>;
+  flashChar: flashCharList;
+  flashMode: flashMode;
+  flashScriptChar: flashScriptChar;
+  flashThreshold: number;
+  font: fontList;
+  fonts: platformFont;
+  fontSize: configItem<configSizeItem<configResizedItem<number>>>;
+  fpsInterval: number;
+  hiResCommentCorrection: number;
+  lineCounts: configItem<lineCounts>;
+  lineHeight: configItem<configSizeItem<configResizedItem<number>>>;
+  minFontSize: number;
+  sameCAGap: number;
+  sameCAMinScore: number;
+  sameCARange: number;
+  sameCATimestampRange: number;
+  letterSpacing: number;
+  scriptCharOffset: number;
+  plugins: IPluginConstructor[];
+  commentPlugins: {
+    class: typeof BaseComment;
+    condition: (comment: formattedComment) => boolean;
+  }[];
+  commentLimit: number | undefined;
+  hideCommentOrder: "asc" | "desc";
+  lineBreakCount: { [key in commentSize]: number };
+  nakaCommentSpeedOffset: number;
 };
 
+export type Config = Partial<BaseConfig>;
 
+declare let imageCache: {
+    [key: string]: {
+        image: HTMLCanvasElement;
+        timeout: number;
+    };
+};
+declare const resetImageCache: () => void;
 
 
-type configItem<T> = T | { html5: T; flash: T };
-type configSizeItem<T> = { big: T; medium: T; small: T };
-type configResizedItem<T> = { default: T; resized: T };
+export * from "./cache";
+export * from "./nicoscript";
+export * from "./plugins";
 
-type commentStageSize = { width: number; fullWidth: number; height: number };
+import type { nicoScript } from "@/@types/";
+declare let nicoScripts: nicoScript;
+declare const resetNicoScripts: () => void;
 
-type flashCharList = {
-  [key in "simsunStrong" | "simsunWeak" | "gulim" | "gothic"]: string;
-};
-type flashMode = "xp" | "vista";
-type flashScriptChar = {
-  [key in "super" | "sub"]: string;
-};
-type fontList = {
-  [key in "gulim" | "simsun"]: string;
+
+import type { IPlugin } from "@/@types/";
+declare let plugins: IPlugin[];
+declare const setPlugins: (input: IPlugin[]) => void;
+
+
+declare const colors: {
+    white: string;
+    red: string;
+    pink: string;
+    orange: string;
+    yellow: string;
+    green: string;
+    cyan: string;
+    blue: string;
+    purple: string;
+    black: string;
+    white2: string;
+    niconicowhite: string;
+    red2: string;
+    truered: string;
+    pink2: string;
+    orange2: string;
+    passionorange: string;
+    yellow2: string;
+    madyellow: string;
+    green2: string;
+    elementalgreen: string;
+    cyan2: string;
+    blue2: string;
+    marinblue: string;
+    purple2: string;
+    nobleviolet: string;
+    black2: string;
 };
-type lineCounts = {
-  [key in "default" | "resized" | "doubleResized"]: configSizeItem<number>;
+
+
+import type { BaseConfig, BaseOptions } from "@/@types/";
+declare let defaultConfig: BaseConfig;
+declare const updateConfig: (config: BaseConfig) => void;
+declare const defaultOptions: BaseOptions;
+declare let config: BaseConfig;
+declare let options: BaseOptions;
+declare const setConfig: (value: BaseConfig) => BaseConfig;
+declare const setOptions: (value: BaseOptions) => BaseOptions;
+
+
+import { FontItem } from "@/@types";
+declare const fontTemplates: {
+    arial: {
+        font: string;
+        offset: number;
+        weight: number;
+    };
+    gothic: {
+        font: string;
+        offset: number;
+        weight: number;
+    };
+    gulim: {
+        font: string;
+        offset: number;
+        weight: number;
+    };
+    mincho: {
+        font: string;
+        offset: number;
+        weight: number;
+    };
+    simsun: {
+        font: string;
+        offset: number;
+        weight: number;
+    };
+    macGothicPro6: {
+        font: string;
+        offset: number;
+        weight: number;
+    };
+    macGothicPro3: {
+        font: string;
+        offset: number;
+        weight: number;
+    };
+    macMincho: {
+        font: string;
+        offset: number;
+        weight: number;
+    };
+    macGothic1: {
+        font: string;
+        offset: number;
+        weight: number;
+    };
+    macGothic2: {
+        font: string;
+        offset: number;
+        weight: number;
+    };
+    sansSerif600: {
+        font: string;
+        offset: number;
+        weight: number;
+    };
+    sansSerif400: {
+        font: string;
+        offset: number;
+        weight: number;
+    };
+    serif: {
+        font: string;
+        offset: number;
+        weight: number;
+    };
 };
-type typeDoubleResizeMaxWidth = {
-  [key in "full" | "normal"]: number;
+declare const fonts: {
+    win7: {
+        defont: FontItem;
+        gothic: FontItem;
+        mincho: FontItem;
+    };
+    win8_1: {
+        defont: FontItem;
+        gothic: FontItem;
+        mincho: FontItem;
+    };
+    win: {
+        defont: FontItem;
+        gothic: FontItem;
+        mincho: FontItem;
+    };
+    mac10_9: {
+        defont: FontItem;
+        gothic: FontItem;
+        mincho: FontItem;
+    };
+    mac10_11: {
+        defont: FontItem;
+        gothic: FontItem;
+        mincho: FontItem;
+    };
+    mac: {
+        defont: FontItem;
+        gothic: FontItem;
+        mincho: FontItem;
+    };
+    other: {
+        defont: FontItem;
+        gothic: FontItem;
+        mincho: FontItem;
+    };
 };
 
-type BaseConfig = {
-  cacheAge: number;
-  canvasHeight: number;
-  canvasWidth: number;
-  collisionRange: { [key in "left" | "right"]: number };
-  colors: { [key: string]: string };
-  commentDrawPadding: number;
-  commentDrawRange: number;
-  commentScale: configItem<number>;
-  commentStageSize: configItem<commentStageSize>;
-  commentYMarginBottom: configSizeItem<number>;
-  commentYOffset: configSizeItem<configResizedItem<number>>;
-  commentYPaddingTop: configResizedItem<number>;
-  contextFillLiveOpacity: number;
-  contextLineWidth: number;
-  contextStrokeColor: string;
-  contextStrokeInversionColor: string;
-  contextStrokeOpacity: number;
-  doubleResizeMaxWidth: configItem<typeDoubleResizeMaxWidth>;
-  flashChar: flashCharList;
-  flashMode: flashMode;
-  flashScriptChar: flashScriptChar;
-  flashThreshold: number;
-  font: fontList;
-  fonts: platformFont;
-  fontSize: configItem<configSizeItem<configResizedItem<number>>>;
-  fpsInterval: number;
-  hiResCommentCorrection: number;
-  lineCounts: configItem<lineCounts>;
-  lineHeight: configItem<configSizeItem<configResizedItem<number>>>;
-  minFontSize: number;
-  sameCAGap: number;
-  sameCAMinScore: number;
-  sameCARange: number;
-  letterSpacing: number;
-  scriptCharOffset: number;
-  plugins: IPluginConstructor[];
-};
 
-export type Config = Partial<BaseConfig>;
+declare const initConfig: () => void;
+
+
+declare class CanvasRenderingContext2DError extends Error {
+    constructor(options?: {
+        [key: string]: unknown;
+    });
+}
+
+
+export * from "./CanvasRenderingContext2DError";
+export * from "./InvalidFormatError";
+export * from "./InvalidOptionError";
+export * from "./NotImplementedError";
+
+declare class InvalidFormatError extends Error {
+    constructor(options?: {
+        [key: string]: unknown;
+    });
+}
+
+
+declare class InvalidOptionError extends Error {
+    constructor(options?: {
+        [key: string]: unknown;
+    });
+}
+
+
+declare class NotImplementedError extends Error {
+    pluginName: string;
+    methodName: string;
+    constructor(pluginName: string, methodName: string, options?: {
+        [key: string]: unknown;
+    });
+}
+
 
 export interface CommentEventBase {
   type: CommentEventName;
@@ -332,6 +406,12 @@ export type CommentEventName =
   | "commentDisable"
   | "commentEnable"
   | "jump";
+export type CommentEventHandler =
+  | SeekDisableEventHandler
+  | SeekEnableEventHandler
+  | CommentDisableEventHandler
+  | CommentEnableEventHandler
+  | JumpEventHandler;
 export interface CommentEventHandlerMap {
   seekDisable: SeekDisableEventHandler;
   seekEnable: SeekEnableEventHandler;
@@ -347,187 +427,377 @@ export interface CommentEventMap {
   jump: JumpEvent;
 }
 
-type platform =
-  | "win7"
-  | "win8_1"
-  | "win"
-  | "mac10_9"
-  | "mac10_11"
-  | "mac"
-  | "other";
-type HTML5Fonts = "gothic" | "mincho" | "defont";
-type FontItem = {
-  font: string;
-  offset: number;
-  weight: number;
-};
-type platformFont = {
-  [key in HTML5Fonts]: FontItem;
-};
-
-export type formattedComment = {
-  id: number;
-  vpos: number;
-  content: string;
-  date: number;
-  date_usec: number;
-  owner: boolean;
-  premium: boolean;
-  mail: string[];
-  user_id: number;
-  layer: number;
-};
-export type formattedLegacyComment = {
-  id: number;
-  vpos: number;
-  content: string;
-  date: number;
-  date_usec: number;
-  owner: boolean;
-  premium: boolean;
-  mail: string[];
-};
+import type { CommentEventHandlerMap } from "@/@types/";
+declare const registerHandler: <K extends keyof CommentEventHandlerMap>(eventName: K, handler: CommentEventHandlerMap[K]) => void;
+declare const removeHandler: <K extends keyof CommentEventHandlerMap>(eventName: K, handler: CommentEventHandlerMap[K]) => void;
+declare const triggerHandler: (vpos: number, lastVpos: number) => void;
 
-export type rawApiResponse = {
-  [key: string]: apiPing | apiThread | apiLeaf | apiGlobalNumRes | apiChat;
-};
-type apiPing = {
-  content: string;
-};
-type apiThread = {
-  resultcode: number;
-  thread: string;
-  server_time: number;
-  ticket: string;
-  revision: number;
-};
-type apiLeaf = {
-  thread: string;
-  count: number;
-};
-type apiGlobalNumRes = {
-  thread: string;
-  num_res: number;
-};
-type apiChat = {
-  thread: string;
-  no: number;
-  vpos: number;
-  date: number;
-  date_usec: number;
-  nicoru: number;
-  premium: number;
-  anonymity: number;
-  user_id: string;
-  mail: string;
-  content: string;
-  deleted: number;
-};
 
-export type ownerComment = {
-  time: string;
-  command: string;
-  comment: string;
-};
+export type platform =
+  | "win7"
+  | "win8_1"
+  | "win"
+  | "mac10_9"
+  | "mac10_11"
+  | "mac"
+  | "other";
+export type HTML5Fonts = "gothic" | "mincho" | "defont";
+export type FontItem = {
+  font: string;
+  offset: number;
+  weight: number;
+};
+export type platformFont = {
+  [key in HTML5Fonts]: FontItem;
+};
 
-export type v1Thread = {
-  id: string;
-  fork: string;
-  commentCount: number;
-  comments: v1Comment[];
-};
-type v1Comment = {
-  id: string;
-  no: number;
-  vposMs: number;
-  body: string;
-  commands: string[];
-  userId: string;
-  isPremium: boolean;
-  score: number;
-  postedAt: string;
-  nicoruCount: number;
-  nicoruId: undefined;
-  source: string;
-  isMyPost: boolean;
-};
+export type formattedComment = {
+  id: number;
+  vpos: number;
+  content: string;
+  date: number;
+  date_usec: number;
+  owner: boolean;
+  premium: boolean;
+  mail: string[];
+  user_id: number;
+  layer: number;
+};
+export type formattedLegacyComment = {
+  id: number;
+  vpos: number;
+  content: string;
+  date: number;
+  date_usec: number;
+  owner: boolean;
+  premium: boolean;
+  mail: string[];
+};
 
+export type rawApiResponse = {
+  [key: string]: apiPing | apiThread | apiLeaf | apiGlobalNumRes | apiChat;
+};
+type apiPing = {
+  content: string;
+};
+type apiThread = {
+  resultcode: number;
+  thread: string;
+  server_time: number;
+  ticket: string;
+  revision: number;
+};
+type apiLeaf = {
+  thread: string;
+  count: number;
+};
+type apiGlobalNumRes = {
+  thread: string;
+  num_res: number;
+};
+type apiChat = {
+  thread: string;
+  no: number;
+  vpos: number;
+  date: number;
+  date_usec: number;
+  nicoru: number;
+  premium: number;
+  anonymity: number;
+  user_id: string;
+  mail: string;
+  content: string;
+  deleted: number;
+};
 
+export type ownerComment = {
+  time: string;
+  command: string;
+  comment: string;
+};
 
-export interface IComment {
-  comment: formattedCommentWithSize;
-  invisible: boolean;
-  loc: commentLoc;
-  width: number;
-  long: number;
-  height: number;
-  vpos: number;
-  flash: boolean;
-  posY: number;
-  owner: boolean;
-  layer: number;
-  mail: string[];
-  image?: HTMLCanvasElement | null;
-  getTextImage: (vpos: number) => void;
-  draw: (vpos: number, showCollision: boolean, isDebug: boolean) => void;
-}
+export type v1Thread = {
+  id: string;
+  fork: string;
+  commentCount: number;
+  comments: v1Comment[];
+};
+type v1Comment = {
+  id: string;
+  no: number;
+  vposMs: number;
+  body: string;
+  commands: string[];
+  userId: string;
+  isPremium: boolean;
+  score: number;
+  postedAt: string;
+  nicoruCount: number;
+  nicoruId: undefined;
+  source: string;
+  isMyPost: boolean;
+};
 
+import type { commentLoc, formattedCommentWithSize } from "@/@types/";
+
+export interface IComment {
+  comment: formattedCommentWithSize;
+  invisible: boolean;
+  loc: commentLoc;
+  width: number;
+  long: number;
+  height: number;
+  vpos: number;
+  flash: boolean;
+  posY: number;
+  owner: boolean;
+  layer: number;
+  mail: string[];
+  image?: HTMLCanvasElement | null;
+  draw: (vpos: number, showCollision: boolean, isDebug: boolean) => void;
+}
 
+export * from "./config";
+export * from "./event";
+export * from "./fonts";
+export * from "./format.formatted";
+export * from "./format.legacy";
+export * from "./format.owner";
+export * from "./format.v1";
+export * from "./IComment";
+export * from "./IPlugins";
+export * from "./options";
+export * from "./types";
 
-export interface IPluginConstructor {
-  id: string;
-  new (Canvas: HTMLCanvasElement, comments: formattedComment[]): IPlugin;
-}
+import type { formattedComment, inputFormatType } from "@/@types/";
+declare const convert2formattedComment: (data: unknown, type: inputFormatType) => formattedComment[];
 
-export interface IPlugin {
-  draw(vpos: number): void;
-  addComments(comments: formattedComment[]): void;
-}
 
+import type * as types from "@/@types/";
+import * as comments from "@/comments";
+import * as contexts from "@/contexts";
+import * as colors from "@/definition/colors";
+import * as config from "@/definition/config";
+import * as fonts from "@/definition/fonts";
+import * as initConfig from "@/definition/initConfig";
+import * as errors from "@/errors";
+import * as eventHandler from "@/eventHandler";
+import * as inputParser from "@/inputParser";
+import * as typeGuard from "@/typeGuard";
+import * as utils from "@/utils";
+declare const definition: {
+    colors: typeof colors;
+    config: typeof config;
+    fonts: typeof fonts;
+    initConfig: typeof initConfig;
+};
 
 
+import type { formattedComment } from "@/@types/";
+
+export interface IPluginConstructor {
+  id: string;
+  new (Canvas: HTMLCanvasElement, comments: formattedComment[]): IPlugin;
+}
+
+export interface IPlugin {
+  draw(vpos: number): void;
+  addComments(comments: formattedComment[]): void;
+}
 
+import type { CommentEventHandlerMap, formattedComment, inputFormat, Options } from "@/@types/";
+import { FlashComment } from "@/comments/";
+import * as internal from "./internal";
+declare class NiconiComments {
+    enableLegacyPiP: boolean;
+    showCollision: boolean;
+    showFPS: boolean;
+    showCommentCount: boolean;
+    video: HTMLVideoElement | undefined;
+    private lastVpos;
+    private readonly canvas;
+    private readonly collision;
+    private readonly context;
+    private readonly timeline;
+    static typeGuard: {
+        formatted: {
+            comment: (i: unknown) => i is formattedComment;
+            comments: (i: unknown) => i is formattedComment[];
+            legacyComment: (i: unknown) => i is internal.types.formattedLegacyComment;
+            legacyComments: (i: unknown) => i is internal.types.formattedLegacyComment[];
+        };
+        legacy: {
+            rawApiResponses: (i: unknown) => i is internal.types.rawApiResponse[];
+            apiChat: (i: unknown) => i is internal.types.apiChat;
+            apiGlobalNumRes: (i: unknown) => i is internal.types.apiGlobalNumRes;
+            apiLeaf: (i: unknown) => i is internal.types.apiLeaf;
+            apiPing: (i: unknown) => i is internal.types.apiPing;
+            apiThread: (i: unknown) => i is internal.types.apiThread;
+        };
+        xmlDocument: (i: unknown) => i is XMLDocument;
+        legacyOwner: {
+            comments: (i: unknown) => i is string;
+        };
+        owner: {
+            comment: (i: unknown) => i is internal.types.ownerComment;
+            comments: (i: unknown) => i is internal.types.ownerComment[];
+        };
+        v1: {
+            comment: (i: unknown) => i is internal.types.v1Comment;
+            thread: (i: unknown) => i is internal.types.v1Thread;
+            threads: (i: unknown) => i is internal.types.v1Thread[];
+        };
+        nicoScript: {
+            range: {
+                target: (i: unknown) => i is internal.types.nicoScriptReverseTarget;
+            };
+            replace: {
+                range: (i: unknown) => i is internal.types.nicoScriptReplaceRange;
+                target: (i: unknown) => i is internal.types.nicoScriptReplaceTarget;
+                condition: (i: unknown) => i is internal.types.nicoScriptReplaceCondition;
+            };
+        };
+        comment: {
+            font: (i: unknown) => i is internal.types.commentFont;
+            loc: (i: unknown) => i is internal.types.commentLoc;
+            size: (i: unknown) => i is internal.types.commentSize;
+            command: {
+                key: (i: unknown) => i is "full" | "ender" | "_live" | "invisible";
+            };
+            color: (i: unknown) => i is "white" | "red" | "pink" | "orange" | "yellow" | "green" | "cyan" | "blue" | "purple" | "black" | "white2" | "niconicowhite" | "red2" | "truered" | "pink2" | "orange2" | "passionorange" | "yellow2" | "madyellow" | "green2" | "elementalgreen" | "cyan2" | "blue2" | "marinblue" | "purple2" | "nobleviolet" | "black2";
+            colorCode: (i: unknown) => i is string;
+            colorCodeAllowAlpha: (i: unknown) => i is string;
+        };
+        config: {
+            initOptions: (item: unknown) => item is Partial<internal.types.BaseOptions>;
+        };
+    };
+    static default: typeof NiconiComments;
+    static FlashComment: {
+        condition: (comment: formattedComment) => boolean;
+        class: typeof FlashComment;
+    };
+    static internal: typeof internal;
+    constructor(canvas: HTMLCanvasElement, data: inputFormat, initOptions?: Options);
+    private preRendering;
+    private getCommentPos;
+    private sortComment;
+    addComments(...rawComments: formattedComment[]): void;
+    drawCanvas(vpos: number, forceRendering?: boolean): boolean;
+    private _drawVideo;
+    private _drawComments;
+    private _drawCollision;
+    private _drawFPS;
+    private _drawCommentCount;
+    addEventListener<K extends keyof CommentEventHandlerMap>(eventName: K, handler: CommentEventHandlerMap[K]): void;
+    removeEventListener<K extends keyof CommentEventHandlerMap>(eventName: K, handler: CommentEventHandlerMap[K]): void;
+    clear(): void;
+}
 
 
+import type {
+  Config,
+  formattedComment,
+  formattedLegacyComment,
+  ownerComment,
+  rawApiResponse,
+  v1Thread,
+} from "@/@types/";
+
+export type inputFormatType =
+  | "XMLDocument"
+  | "niconicome"
+  | "formatted"
+  | "legacy"
+  | "legacyOwner"
+  | "owner"
+  | "v1"
+  | "empty"
+  | "default";
+export type inputFormat =
+  | XMLDocument
+  | formattedComment[]
+  | formattedLegacyComment[]
+  | rawApiResponse[]
+  | ownerComment[]
+  | v1Thread[]
+  | string
+  | undefined;
+type modeType = "default" | "html5" | "flash";
+type BaseOptions = {
+  config: Config;
+  debug: boolean;
+  enableLegacyPiP: boolean;
+  format: inputFormatType;
+  formatted: boolean;
+  keepCA: boolean;
+  mode: modeType;
+  scale: number;
+  showCollision: boolean;
+  showCommentCount: boolean;
+  showFPS: boolean;
+  useLegacy: boolean;
+  video: HTMLVideoElement | undefined;
+};
+export type Options = Partial<BaseOptions>;
 
-export type inputFormatType =
-  | "XMLDocument"
-  | "niconicome"
-  | "formatted"
-  | "legacy"
-  | "legacyOwner"
-  | "owner"
-  | "v1"
-  | "empty"
-  | "default";
-export type inputFormat =
-  | XMLDocument
-  | formattedComment[]
-  | formattedLegacyComment[]
-  | rawApiResponse[]
-  | ownerComment[]
-  | v1Thread[]
-  | string
-  | undefined;
-type modeType = "default" | "html5" | "flash";
-type BaseOptions = {
-  config: Config;
-  debug: boolean;
-  enableLegacyPiP: boolean;
-  format: inputFormatType;
-  formatted: boolean;
-  keepCA: boolean;
-  mode: modeType;
-  scale: number;
-  showCollision: boolean;
-  showCommentCount: boolean;
-  showFPS: boolean;
-  useLegacy: boolean;
-  video: HTMLVideoElement | undefined;
+import type { apiChat, apiGlobalNumRes, apiLeaf, apiPing, apiThread, commentFont, commentLoc, commentSize, formattedComment, formattedLegacyComment, nicoScriptReplaceCondition, nicoScriptReplaceRange, nicoScriptReplaceTarget, nicoScriptReverseTarget, ownerComment, rawApiResponse, v1Comment, v1Thread } from "@/@types/";
+declare const typeGuard: {
+    formatted: {
+        comment: (i: unknown) => i is formattedComment;
+        comments: (i: unknown) => i is formattedComment[];
+        legacyComment: (i: unknown) => i is formattedLegacyComment;
+        legacyComments: (i: unknown) => i is formattedLegacyComment[];
+    };
+    legacy: {
+        rawApiResponses: (i: unknown) => i is rawApiResponse[];
+        apiChat: (i: unknown) => i is apiChat;
+        apiGlobalNumRes: (i: unknown) => i is apiGlobalNumRes;
+        apiLeaf: (i: unknown) => i is apiLeaf;
+        apiPing: (i: unknown) => i is apiPing;
+        apiThread: (i: unknown) => i is apiThread;
+    };
+    xmlDocument: (i: unknown) => i is XMLDocument;
+    legacyOwner: {
+        comments: (i: unknown) => i is string;
+    };
+    owner: {
+        comment: (i: unknown) => i is ownerComment;
+        comments: (i: unknown) => i is ownerComment[];
+    };
+    v1: {
+        comment: (i: unknown) => i is v1Comment;
+        thread: (i: unknown) => i is v1Thread;
+        threads: (i: unknown) => i is v1Thread[];
+    };
+    nicoScript: {
+        range: {
+            target: (i: unknown) => i is nicoScriptReverseTarget;
+        };
+        replace: {
+            range: (i: unknown) => i is nicoScriptReplaceRange;
+            target: (i: unknown) => i is nicoScriptReplaceTarget;
+            condition: (i: unknown) => i is nicoScriptReplaceCondition;
+        };
+    };
+    comment: {
+        font: (i: unknown) => i is commentFont;
+        loc: (i: unknown) => i is commentLoc;
+        size: (i: unknown) => i is commentSize;
+        command: {
+            key: (i: unknown) => i is "full" | "ender" | "_live" | "invisible";
+        };
+        color: (i: unknown) => i is "white" | "red" | "pink" | "orange" | "yellow" | "green" | "cyan" | "blue" | "purple" | "black" | "white2" | "niconicowhite" | "red2" | "truered" | "pink2" | "orange2" | "passionorange" | "yellow2" | "madyellow" | "green2" | "elementalgreen" | "cyan2" | "blue2" | "marinblue" | "purple2" | "nobleviolet" | "black2";
+        colorCode: (i: unknown) => i is string;
+        colorCodeAllowAlpha: (i: unknown) => i is string;
+    };
+    config: {
+        initOptions: (item: unknown) => item is Partial<BaseOptions>;
+    };
 };
-export type Options = Partial<BaseOptions>;
 
-
+
+import type { IComment } from "@/@types/";
 
 type formattedCommentWithFont = {
   id: number;
@@ -572,6 +842,7 @@ type parsedComment = formattedCommentWithSize & {
 };
 type commentContentItem = {
   content: string;
+  slicedContent: string[];
   font?: commentFlashFont;
   width?: number[];
 };
@@ -587,6 +858,7 @@ type commentFlashFont = "defont" | "gulim" | "simsun";
 type commentSize = "big" | "medium" | "small";
 type commentLoc = "ue" | "naka" | "shita";
 type collision = { [key in collisionPos]: collisionItem };
+type Timeline = { [key: number]: IComment[] };
 type collisionPos = "ue" | "shita" | "right" | "left";
 type collisionItem = { [p: number]: IComment[] };
 type nicoScript = {
@@ -695,197 +967,87 @@ type measureInput = {
 
 type valueOf<T> = T[keyof T];
 
-
-declare const registerHandler: <K extends keyof CommentEventHandlerMap>(eventName: K, handler: CommentEventHandlerMap[K]) => void;
-declare const removeHandler: <K extends keyof CommentEventHandlerMap>(eventName: K, handler: CommentEventHandlerMap[K]) => void;
-declare const triggerHandler: (vpos: number, lastVpos: number) => void;
-
+import type { IComment } from "@/@types";
+declare const ArrayPush: (array: {
+    [key: number]: IComment[];
+}, key: string | number, push: IComment) => void;
+declare const ArrayEqual: (a: unknown[], b: unknown[]) => boolean;
 
-
-
-declare const convert2formattedComment: (data: unknown, type: inputFormatType) => formattedComment[];
-
 
-
-
-
-declare class NiconiComments {
-    enableLegacyPiP: boolean;
-    showCollision: boolean;
-    showFPS: boolean;
-    showCommentCount: boolean;
-    video: HTMLVideoElement | undefined;
-    private lastVpos;
-    private readonly canvas;
-    private readonly collision;
-    private readonly context;
-    private readonly timeline;
-    static typeGuard: {
-        formatted: {
-            comment: (i: unknown) => i is formattedComment;
-            comments: (i: unknown) => i is formattedComment[];
-            legacyComment: (i: unknown) => i is formattedLegacyComment;
-            legacyComments: (i: unknown) => i is formattedLegacyComment[];
-        };
-        legacy: {
-            rawApiResponses: (i: unknown) => i is rawApiResponse[];
-            apiChat: (i: unknown) => i is apiChat;
-            apiGlobalNumRes: (i: unknown) => i is apiGlobalNumRes;
-            apiLeaf: (i: unknown) => i is apiLeaf;
-            apiPing: (i: unknown) => i is apiPing;
-            apiThread: (i: unknown) => i is apiThread;
-        };
-        xmlDocument: (i: unknown) => i is XMLDocument;
-        legacyOwner: {
-            comments: (i: unknown) => i is string;
-        };
-        owner: {
-            comment: (i: unknown) => i is ownerComment;
-            comments: (i: unknown) => i is ownerComment[];
-        };
-        v1: {
-            comment: (i: unknown) => i is v1Comment;
-            thread: (i: unknown) => i is v1Thread;
-            threads: (i: unknown) => i is v1Thread[];
-        };
-        nicoScript: {
-            range: {
-                target: (i: unknown) => i is nicoScriptReverseTarget;
-            };
-            replace: {
-                range: (i: unknown) => i is nicoScriptReplaceRange;
-                target: (i: unknown) => i is nicoScriptReplaceTarget;
-                condition: (i: unknown) => i is nicoScriptReplaceCondition;
-            };
-        };
-        comment: {
-            font: (i: unknown) => i is commentFont;
-            loc: (i: unknown) => i is commentLoc;
-            size: (i: unknown) => i is commentSize;
-            command: {
-                key: (i: unknown) => i is "full" | "ender" | "_live" | "invisible";
-            };
-            color: (i: unknown) => i is "white" | "red" | "pink" | "orange" | "yellow" | "green" | "cyan" | "blue" | "purple" | "black" | "white2" | "niconicowhite" | "red2" | "truered" | "pink2" | "orange2" | "passionorange" | "yellow2" | "madyellow" | "green2" | "elementalgreen" | "cyan2" | "blue2" | "marinblue" | "purple2" | "nobleviolet" | "black2";
-            colorCode: (i: unknown) => i is string;
-        };
-        config: {
-            initOptions: (item: unknown) => item is Partial<BaseOptions>;
-        };
-    };
-    static default: typeof NiconiComments;
-    constructor(canvas: HTMLCanvasElement, data: inputFormat, initOptions?: Options);
-    private preRendering;
-    private getCommentPos;
-    private sortComment;
-    addComments(...rawComments: formattedComment[]): void;
-    drawCanvas(vpos: number, forceRendering?: boolean): boolean;
-    addEventListener<K extends keyof CommentEventHandlerMap>(eventName: K, handler: CommentEventHandlerMap[K]): void;
-    removeEventListener<K extends keyof CommentEventHandlerMap>(eventName: K, handler: CommentEventHandlerMap[K]): void;
-    clear(): void;
-}
-
+import { formattedCommentWithSize } from "@/@types";
+declare const hex2rgb: (hex: string) => number[];
+declare const hex2rgba: (hex: string) => number[];
+declare const getStrokeColor: (comment: formattedCommentWithSize) => string;
+
+
+import type { collision, commentFont, commentLoc, commentSize, formattedComment, formattedCommentWithFont, formattedCommentWithSize, measureTextInput } from "@/@types/";
+import { collisionItem, IComment, Timeline } from "@/@types/";
+declare const isLineBreakResize: (comment: measureTextInput) => boolean;
+declare const getDefaultCommand: (vpos: number) => {
+    color: string | undefined;
+    size: commentSize | undefined;
+    font: commentFont | undefined;
+    loc: commentLoc | undefined;
+};
+declare const parseCommandAndNicoScript: (comment: formattedComment) => formattedCommentWithFont;
+declare const isFlashComment: (comment: formattedComment) => boolean;
+declare const isReverseActive: (vpos: number, isOwner: boolean) => boolean;
+declare const isBanActive: (vpos: number) => boolean;
+declare const processFixedComment: (comment: IComment, collision: collisionItem, timeline: Timeline) => void;
+declare const processMovableComment: (comment: IComment, collision: collision, timeline: Timeline) => void;
+declare const getPosY: (currentPos: number, targetComment: IComment, collision: IComment[] | undefined) => {
+    currentPos: number;
+    isChanged: boolean;
+    isBreak: boolean;
+};
+declare const getPosX: (comment: formattedCommentWithSize, vpos: number, isReverse?: boolean) => number;
+declare const parseFont: (font: commentFont, size: string | number) => string;
+
+
+import { formattedComment } from "@/@types";
+declare const changeCALayer: (rawData: formattedComment[]) => formattedComment[];
+
+
+import { configItem } from "@/@types";
+declare const getConfig: <T>(input: configItem<T>, isFlash?: boolean) => T;
+
+
+import type { commentContentIndex, commentFlashFont } from "@/@types";
+declare const getFlashFontIndex: (part: string) => commentContentIndex[];
+declare const getFlashFontName: (font: string) => commentFlashFont;
+
+
+export * from "./array";
+export * from "./color";
+export * from "./comment";
+export * from "./commentArt";
+export * from "./config";
+export * from "./flash";
+export * from "./niconico";
+export * from "./sort";
+
+import type { commentSize, measureInput } from "@/@types";
+declare const getLineHeight: (fontSize: commentSize, isFlash: boolean, resized?: boolean) => number;
+declare const getCharSize: (fontSize: commentSize, isFlash: boolean) => number;
+declare const measure: (comment: measureInput, context: CanvasRenderingContext2D) => {
+    height: number;
+    width: number;
+    lineWidth: number[];
+    itemWidth: number[][];
+};
+declare const getFontSizeAndScale: (charSize: number) => {
+    scale: number;
+    fontSize: number;
+};
+
+
+import { formattedComment } from "@/@types";
+declare const createCommentInstance: (comment: formattedComment, context: CanvasRenderingContext2D) => BaseComment;
+
+
+declare const nativeSort: <T>(getter: (input: T) => number) => (a: T, b: T) => 1 | 0 | -1;
 
-
-declare const getLineHeight: (fontSize: commentSize, isFlash: boolean, resized?: boolean) => number;
-declare const getCharSize: (fontSize: commentSize, isFlash: boolean) => number;
-declare const measure: (comment: measureInput, context: CanvasRenderingContext2D) => {
-    height: number;
-    width: number;
-    lineWidth: number[];
-    itemWidth: number[][];
-};
-declare const getFontSizeAndScale: (charSize: number) => {
-    scale: number;
-    fontSize: number;
-};
-
 
-
-
-
-
-
-declare const typeGuard: {
-    formatted: {
-        comment: (i: unknown) => i is formattedComment;
-        comments: (i: unknown) => i is formattedComment[];
-        legacyComment: (i: unknown) => i is formattedLegacyComment;
-        legacyComments: (i: unknown) => i is formattedLegacyComment[];
-    };
-    legacy: {
-        rawApiResponses: (i: unknown) => i is rawApiResponse[];
-        apiChat: (i: unknown) => i is apiChat;
-        apiGlobalNumRes: (i: unknown) => i is apiGlobalNumRes;
-        apiLeaf: (i: unknown) => i is apiLeaf;
-        apiPing: (i: unknown) => i is apiPing;
-        apiThread: (i: unknown) => i is apiThread;
-    };
-    xmlDocument: (i: unknown) => i is XMLDocument;
-    legacyOwner: {
-        comments: (i: unknown) => i is string;
-    };
-    owner: {
-        comment: (i: unknown) => i is ownerComment;
-        comments: (i: unknown) => i is ownerComment[];
-    };
-    v1: {
-        comment: (i: unknown) => i is v1Comment;
-        thread: (i: unknown) => i is v1Thread;
-        threads: (i: unknown) => i is v1Thread[];
-    };
-    nicoScript: {
-        range: {
-            target: (i: unknown) => i is nicoScriptReverseTarget;
-        };
-        replace: {
-            range: (i: unknown) => i is nicoScriptReplaceRange;
-            target: (i: unknown) => i is nicoScriptReplaceTarget;
-            condition: (i: unknown) => i is nicoScriptReplaceCondition;
-        };
-    };
-    comment: {
-        font: (i: unknown) => i is commentFont;
-        loc: (i: unknown) => i is commentLoc;
-        size: (i: unknown) => i is commentSize;
-        command: {
-            key: (i: unknown) => i is "full" | "ender" | "_live" | "invisible";
-        };
-        color: (i: unknown) => i is "white" | "red" | "pink" | "orange" | "yellow" | "green" | "cyan" | "blue" | "purple" | "black" | "white2" | "niconicowhite" | "red2" | "truered" | "pink2" | "orange2" | "passionorange" | "yellow2" | "madyellow" | "green2" | "elementalgreen" | "cyan2" | "blue2" | "marinblue" | "purple2" | "nobleviolet" | "black2";
-        colorCode: (i: unknown) => i is string;
-    };
-    config: {
-        initOptions: (item: unknown) => item is Partial<BaseOptions>;
-    };
-};
-
 
-
-
-
-
-
-declare const getPosY: (currentPos: number, targetComment: IComment, collision: IComment[] | undefined) => {
-    currentPos: number;
-    isChanged: boolean;
-    isBreak: boolean;
-};
-declare const getPosX: (width: number, vpos: number, long: number) => number;
-declare const parseFont: (font: commentFont, size: string | number) => string;
-declare const arrayPush: (array: {
-    [key: number]: IComment[];
-}, key: string | number, push: IComment) => void;
-declare const hex2rgb: (hex: string) => number[];
-declare const hex2rgba: (hex: string) => number[];
-declare const changeCALayer: (rawData: formattedComment[]) => formattedComment[];
-declare const getConfig: <T>(input: configItem<T>, isFlash?: boolean) => T;
-declare const isFlashComment: (comment: formattedComment) => boolean;
-declare const parseCommandAndNicoScript: (comment: formattedComment) => formattedCommentWithFont;
-declare const getStrokeColor: (comment: formattedCommentWithSize) => string;
-declare const ArrayEqual: (a: unknown[], b: unknown[]) => boolean;
-declare const getFlashFontIndex: (part: string) => commentContentIndex[];
-declare const getFlashFontName: (font: string) => commentFlashFont;
-declare const getValue: <T>(value: T | null | undefined, alternative: T) => T;
-declare const nativeSort: <T>(getter: (input: T) => number) => (a: T, b: T) => 0 | 1 | -1;
-
 
 export default NiconiComments;