@xpadev-net/niconicomments 0.2.49 → 0.2.50

package/dist/bundle.d.ts

@@ -1,15 +1,13 @@
-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;
+    comment: FormattedCommentWithSize;
     posY: number;
     readonly pluginName: string;
     image?: HTMLCanvasElement | null;
-    constructor(comment: formattedComment, context: CanvasRenderingContext2D);
+    constructor(comment: FormattedComment, context: CanvasRenderingContext2D);
     get invisible(): boolean;
-    get loc(): commentLoc;
+    get loc(): CommentLoc;
     get long(): number;
     get vpos(): number;
     get width(): number;
@@ -18,10 +16,10 @@ declare class BaseComment implements IComment {
     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;
+    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;
@@ -36,72 +34,71 @@ declare class BaseComment implements IComment {
     };
 }
 
-
-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;
+    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;
 }
 
-
-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;
+    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;
 }
 
+type index_d$3_BaseComment = BaseComment;
+declare const index_d$3_BaseComment: typeof BaseComment;
+type index_d$3_FlashComment = FlashComment;
+declare const index_d$3_FlashComment: typeof FlashComment;
+type index_d$3_HTML5Comment = HTML5Comment;
+declare const index_d$3_HTML5Comment: typeof HTML5Comment;
+declare namespace index_d$3 {
+  export {
+    index_d$3_BaseComment as BaseComment,
+    index_d$3_FlashComment as FlashComment,
+    index_d$3_HTML5Comment as HTML5Comment,
+  };
+}
 
-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 };
 
-type configItem<T> = T | { html5: T; flash: T };
-type configSizeItem<T> = { big: T; medium: T; small: T };
-type configResizedItem<T> = { default: T; resized: T };
-
-type commentStageSize = { width: number; fullWidth: number; height: number };
+type CommentStageSize = {
+  width: number;
+  fullWidth: number;
+  height: number;
+};
 
-type flashCharList = {
+type FlashCharList = {
   [key in "simsunStrong" | "simsunWeak" | "gulim" | "gothic"]: string;
 };
-type flashMode = "xp" | "vista";
-type flashScriptChar = {
+type FlashMode = "xp" | "vista";
+type FlashScriptChar = {
   [key in "super" | "sub"]: string;
 };
-type fontList = {
+type FontList = {
   [key in "gulim" | "simsun"]: string;
 };
-type lineCounts = {
-  [key in "default" | "resized" | "doubleResized"]: configSizeItem<number>;
+type LineCounts = {
+  [key in "default" | "resized" | "doubleResized"]: ConfigSizeItem<number>;
 };
-type typeDoubleResizeMaxWidth = {
+type TypeDoubleResizeMaxWidth = {
   [key in "full" | "normal"]: number;
 };
 
@@ -113,28 +110,28 @@ type BaseConfig = {
   colors: { [key: string]: string };
   commentDrawPadding: number;
   commentDrawRange: number;
-  commentScale: configItem<number>;
-  commentStageSize: configItem<commentStageSize>;
-  commentYMarginBottom: configSizeItem<number>;
-  commentYOffset: configSizeItem<configResizedItem<number>>;
-  commentYPaddingTop: configResizedItem<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;
+  doubleResizeMaxWidth: ConfigItem<TypeDoubleResizeMaxWidth>;
+  flashChar: FlashCharList;
+  FlashMode: FlashMode;
+  FlashScriptChar: FlashScriptChar;
   flashThreshold: number;
-  font: fontList;
-  fonts: platformFont;
-  fontSize: configItem<configSizeItem<configResizedItem<number>>>;
+  font: FontList;
+  fonts: PlatformFont;
+  fontSize: ConfigItem<ConfigSizeItem<ConfigResizedItem<number>>>;
   fpsInterval: number;
   hiResCommentCorrection: number;
-  lineCounts: configItem<lineCounts>;
-  lineHeight: configItem<configSizeItem<configResizedItem<number>>>;
+  lineCounts: ConfigItem<LineCounts>;
+  lineHeight: ConfigItem<ConfigSizeItem<ConfigResizedItem<number>>>;
   minFontSize: number;
   sameCAGap: number;
   sameCAMinScore: number;
@@ -145,295 +142,80 @@ type BaseConfig = {
   plugins: IPluginConstructor[];
   commentPlugins: {
     class: typeof BaseComment;
-    condition: (comment: formattedComment) => boolean;
+    condition: (comment: FormattedComment) => boolean;
   }[];
   commentLimit: number | undefined;
   hideCommentOrder: "asc" | "desc";
-  lineBreakCount: { [key in commentSize]: number };
+  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;
-
-
-export * from "./cache";
-export * from "./nicoscript";
-export * from "./plugins";
-
-import type { nicoScript } from "@/@types/";
-declare let nicoScripts: nicoScript;
-declare const resetNicoScripts: () => void;
-
-
-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;
-};
-
-
-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;
-    };
-};
-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;
-    };
-};
-
-
-declare const initConfig: () => void;
-
+type Config = Partial<BaseConfig>;
 
-declare class CanvasRenderingContext2DError extends Error {
-    constructor(options?: {
-        [key: string]: unknown;
-    });
+interface CommentEventBase {
+  type: CommentEventName;
+  timeStamp: number;
+  vpos: number;
 }
 
-
-export * from "./CanvasRenderingContext2DError";
-export * from "./InvalidFormatError";
-export * from "./InvalidOptionError";
-export * from "./NotImplementedError";
-
-declare class InvalidFormatError extends Error {
-    constructor(options?: {
-        [key: string]: unknown;
-    });
+interface SeekDisableEvent extends CommentEventBase {
+  type: "seekDisable";
 }
 
+type SeekDisableEventHandler = (event: SeekDisableEvent) => unknown;
 
-declare class InvalidOptionError extends Error {
-    constructor(options?: {
-        [key: string]: unknown;
-    });
+interface SeekEnableEvent extends CommentEventBase {
+  type: "seekEnable";
 }
+type SeekEnableEventHandler = (event: SeekEnableEvent) => unknown;
 
-
-declare class NotImplementedError extends Error {
-    pluginName: string;
-    methodName: string;
-    constructor(pluginName: string, methodName: string, options?: {
-        [key: string]: unknown;
-    });
+interface CommentDisableEvent extends CommentEventBase {
+  type: "commentDisable";
 }
+type CommentDisableEventHandler = (
+  event: CommentDisableEvent
+) => unknown;
 
+interface CommentEnableEvent extends CommentEventBase {
+  type: "commentEnable";
+}
+type CommentEnableEventHandler = (event: CommentEnableEvent) => unknown;
 
-export interface CommentEventBase {
-  type: CommentEventName;
-  timeStamp: number;
-  vpos: number;
-}
-
-export interface SeekDisableEvent extends CommentEventBase {
-  type: "seekDisable";
-}
-
-export type SeekDisableEventHandler = (event: SeekDisableEvent) => unknown;
-
-export interface SeekEnableEvent extends CommentEventBase {
-  type: "seekEnable";
-}
-export type SeekEnableEventHandler = (event: SeekEnableEvent) => unknown;
-
-export interface CommentDisableEvent extends CommentEventBase {
-  type: "commentDisable";
-}
-export type CommentDisableEventHandler = (
-  event: CommentDisableEvent
-) => unknown;
-
-export interface CommentEnableEvent extends CommentEventBase {
-  type: "commentEnable";
-}
-export type CommentEnableEventHandler = (event: CommentEnableEvent) => unknown;
-
-export interface JumpEvent extends CommentEventBase {
-  type: "jump";
-  to: string;
-  message?: string;
-}
-export type JumpEventHandler = (event: JumpEvent) => unknown;
-
-export type CommentEventName =
-  | "seekDisable"
-  | "seekEnable"
-  | "commentDisable"
-  | "commentEnable"
-  | "jump";
-export type CommentEventHandler =
-  | SeekDisableEventHandler
-  | SeekEnableEventHandler
-  | CommentDisableEventHandler
-  | CommentEnableEventHandler
-  | JumpEventHandler;
-export interface CommentEventHandlerMap {
-  seekDisable: SeekDisableEventHandler;
-  seekEnable: SeekEnableEventHandler;
-  commentDisable: CommentDisableEventHandler;
-  commentEnable: CommentEnableEventHandler;
-  jump: JumpEventHandler;
-}
-export interface CommentEventMap {
-  seekDisable: SeekDisableEvent;
-  seekEnable: SeekEnableEvent;
-  commentDisable: CommentDisableEvent;
-  commentEnable: CommentEnableEvent;
-  jump: JumpEvent;
-}
-
-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;
-
+interface JumpEvent extends CommentEventBase {
+  type: "jump";
+  to: string;
+  message?: string;
+}
+type JumpEventHandler = (event: JumpEvent) => unknown;
+
+type CommentEventName =
+  | "seekDisable"
+  | "seekEnable"
+  | "commentDisable"
+  | "commentEnable"
+  | "jump";
+type CommentEventHandler =
+  | SeekDisableEventHandler
+  | SeekEnableEventHandler
+  | CommentDisableEventHandler
+  | CommentEnableEventHandler
+  | JumpEventHandler;
+interface CommentEventHandlerMap {
+  seekDisable: SeekDisableEventHandler;
+  seekEnable: SeekEnableEventHandler;
+  commentDisable: CommentDisableEventHandler;
+  commentEnable: CommentEnableEventHandler;
+  jump: JumpEventHandler;
+}
+interface CommentEventMap {
+  seekDisable: SeekDisableEvent;
+  seekEnable: SeekEnableEvent;
+  commentDisable: CommentDisableEvent;
+  commentEnable: CommentEnableEvent;
+  jump: JumpEvent;
+}
 
-export type platform =
+type Platform =
   | "win7"
   | "win8_1"
   | "win"
@@ -441,17 +223,17 @@ export type platform =
   | "mac10_11"
   | "mac"
   | "other";
-export type HTML5Fonts = "gothic" | "mincho" | "defont";
-export type FontItem = {
+type HTML5Fonts = "gothic" | "mincho" | "defont";
+type FontItem = {
   font: string;
   offset: number;
   weight: number;
 };
-export type platformFont = {
+type PlatformFont = {
   [key in HTML5Fonts]: FontItem;
-};
+};
 
-export type formattedComment = {
+type FormattedComment = {
   id: number;
   vpos: number;
   content: string;
@@ -463,7 +245,7 @@ export type formattedComment = {
   user_id: number;
   layer: number;
 };
-export type formattedLegacyComment = {
+type FormattedLegacyComment = {
   id: number;
   vpos: number;
   content: string;
@@ -473,29 +255,38 @@ export type formattedLegacyComment = {
   premium: boolean;
   mail: string[];
 };
-
-export type rawApiResponse = {
-  [key: string]: apiPing | apiThread | apiLeaf | apiGlobalNumRes | apiChat;
+
+/**
+ * @deprecated
+ */
+type formattedComment = FormattedComment;
+/**
+ * @deprecated
+ */
+type formattedLegacyComment = FormattedLegacyComment;
+
+type RawApiResponse = {
+  [key: string]: ApiPing | ApiThread | ApiLeaf | ApiGlobalNumRes | ApiChat;
 };
-type apiPing = {
+type ApiPing = {
   content: string;
 };
-type apiThread = {
+type ApiThread = {
   resultcode: number;
   thread: string;
   server_time: number;
   ticket: string;
   revision: number;
 };
-type apiLeaf = {
+type ApiLeaf = {
   thread: string;
   count: number;
 };
-type apiGlobalNumRes = {
+type ApiGlobalNumRes = {
   thread: string;
   num_res: number;
 };
-type apiChat = {
+type ApiChat = {
   thread: string;
   no: number;
   vpos: number;
@@ -509,20 +300,30 @@ type apiChat = {
   content: string;
   deleted: number;
 };
+
+/**
+ * @deprecated
+ */
+type rawApiResponse = RawApiResponse;
 
-export type ownerComment = {
+type OwnerComment = {
   time: string;
   command: string;
   comment: string;
 };
+
+/**
+ * @deprecated
+ */
+type ownerComment = OwnerComment;
 
-export type v1Thread = {
+type V1Thread = {
   id: string;
   fork: string;
   commentCount: number;
-  comments: v1Comment[];
+  comments: V1Comment[];
 };
-type v1Comment = {
+type V1Comment = {
   id: string;
   no: number;
   vposMs: number;
@@ -537,13 +338,16 @@ type v1Comment = {
   source: string;
   isMyPost: boolean;
 };
-
-import type { commentLoc, formattedCommentWithSize } from "@/@types/";
 
-export interface IComment {
-  comment: formattedCommentWithSize;
+/**
+ * @deprecated
+ */
+type v1Thread = V1Thread;
+
+interface IComment {
+  comment: FormattedCommentWithSize;
   invisible: boolean;
-  loc: commentLoc;
+  loc: CommentLoc;
   width: number;
   long: number;
   height: number;
@@ -555,156 +359,19 @@ export interface IComment {
   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";
-
-import type { formattedComment, inputFormatType } from "@/@types/";
-declare const convert2formattedComment: (data: unknown, type: inputFormatType) => formattedComment[];
-
-
-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 {
+interface IPluginConstructor {
   id: string;
-  new (Canvas: HTMLCanvasElement, comments: formattedComment[]): IPlugin;
+  new (Canvas: HTMLCanvasElement, comments: FormattedComment[]): IPlugin;
 }
 
-export interface IPlugin {
+interface IPlugin {
   draw(vpos: number): void;
-  addComments(comments: formattedComment[]): 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 =
+type InputFormatType =
   | "XMLDocument"
   | "niconicome"
   | "formatted"
@@ -714,24 +381,24 @@ export type inputFormatType =
   | "v1"
   | "empty"
   | "default";
-export type inputFormat =
+type InputFormat =
   | XMLDocument
-  | formattedComment[]
-  | formattedLegacyComment[]
-  | rawApiResponse[]
-  | ownerComment[]
-  | v1Thread[]
+  | FormattedComment[]
+  | FormattedLegacyComment[]
+  | RawApiResponse[]
+  | OwnerComment[]
+  | V1Thread[]
   | string
   | undefined;
-type modeType = "default" | "html5" | "flash";
+type ModeType = "default" | "html5" | "flash";
 type BaseOptions = {
   config: Config;
   debug: boolean;
   enableLegacyPiP: boolean;
-  format: inputFormatType;
+  format: InputFormatType;
   formatted: boolean;
   keepCA: boolean;
-  mode: modeType;
+  mode: ModeType;
   scale: number;
   showCollision: boolean;
   showCommentCount: boolean;
@@ -739,67 +406,18 @@ type BaseOptions = {
   useLegacy: boolean;
   video: HTMLVideoElement | undefined;
 };
-export type Options = Partial<BaseOptions>;
-
-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>;
-    };
-};
-
-
-import type { IComment } from "@/@types/";
+type Options = Partial<BaseOptions>;
 
-type formattedCommentWithFont = {
+/**
+ * @deprecated
+ */
+type inputFormatType = InputFormatType;
+/**
+ * @deprecated
+ */
+type inputFormat = InputFormat;
+
+type FormattedCommentWithFont = {
   id: number;
   vpos: number;
   date: number;
@@ -809,10 +427,10 @@ type formattedCommentWithFont = {
   mail: string[];
   user_id: number;
   layer: number;
-  loc: commentLoc;
-  size: commentSize;
+  loc: CommentLoc;
+  size: CommentSize;
   fontSize: number;
-  font: commentFont;
+  font: CommentFont;
   color: string;
   strokeColor?: string;
   wakuColor?: string;
@@ -821,100 +439,101 @@ type formattedCommentWithFont = {
   _live: boolean;
   long: number;
   invisible: boolean;
-  content: commentContentItem[];
+  content: CommentContentItem[];
   flash: boolean;
   lineCount: number;
   lineOffset: number;
 };
-type formattedCommentWithSize = formattedCommentWithFont & {
+type FormattedCommentWithSize = FormattedCommentWithFont & {
   height: number;
   width: number;
   lineHeight: number;
   resized: boolean;
   resizedX: boolean;
   resizedY: boolean;
-  content: commentMeasuredContentItem[];
+  content: CommentMeasuredContentItem[];
   charSize: number;
 };
-type parsedComment = formattedCommentWithSize & {
-  posY: number;
-  image?: HTMLCanvasElement | boolean;
-};
-type commentContentItem = {
+type CommentContentItem = {
   content: string;
   slicedContent: string[];
-  font?: commentFlashFont;
+  font?: CommentFlashFont;
   width?: number[];
 };
-type commentMeasuredContentItem = commentContentItem & {
+type CommentMeasuredContentItem = CommentContentItem & {
   width: number[];
 };
-type commentContentIndex = {
+type CommentContentIndex = {
   index: number;
   font: "gothic" | "gulim" | "simsunStrong" | "simsunWeak";
 };
-type commentFont = "defont" | "mincho" | "gothic" | "gulim" | "simsun";
-type commentFlashFont = "defont" | "gulim" | "simsun";
-type commentSize = "big" | "medium" | "small";
-type commentLoc = "ue" | "naka" | "shita";
-type collision = { [key in collisionPos]: collisionItem };
+type CommentFont = "defont" | "mincho" | "gothic" | "gulim" | "simsun";
+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 = {
-  reverse: nicoScriptReverse[];
-  ban: nicoScriptBan[];
-  default: nicoScriptDefault[];
-  replace: nicoScriptReplace[];
-  seekDisable: nicoScriptSeekDisable[];
-  jump: nicoScriptJump[];
+type CollisionPos = "ue" | "shita" | "right" | "left";
+type CollisionItem = { [p: number]: IComment[] };
+type NicoScript = {
+  reverse: NicoScriptReverse[];
+  ban: NicoScriptBan[];
+  default: NicoScriptDefault[];
+  replace: NicoScriptReplace[];
+  seekDisable: NicoScriptSeekDisable[];
+  jump: NicoScriptJump[];
 };
-type nicoScriptSeekDisable = {
+type NicoScriptSeekDisable = {
   start: number;
   end: number;
 };
-type nicoScriptJump = {
+type NicoScriptJump = {
   start: number;
   end?: number;
   to: string;
   message?: string;
 };
-type nicoScriptReverse = {
-  target: nicoScriptReverseTarget;
+type NicoScriptReverse = {
+  target: NicoScriptReverseTarget;
   start: number;
   end: number;
 };
-type nicoScriptReverseTarget = "コメ" | "投コメ" | "全";
-type nicoScriptReplace = {
+type NicoScriptReverseTarget = "コメ" | "投コメ" | "全";
+type NicoScriptReplace = {
   start: number;
   long: number | undefined;
   keyword: string;
   replace: string;
-  range: nicoScriptReplaceRange;
-  target: nicoScriptReplaceTarget;
-  condition: nicoScriptReplaceCondition;
+  range: NicoScriptReplaceRange;
+  target: NicoScriptReplaceTarget;
+  condition: NicoScriptReplaceCondition;
   color: string | undefined;
-  size: commentSize | undefined;
-  font: commentFont | undefined;
-  loc: commentLoc | undefined;
+  size: CommentSize | undefined;
+  font: CommentFont | undefined;
+  loc: CommentLoc | undefined;
   no: number;
 };
-type nicoScriptReplaceRange = "単" | "全";
-type nicoScriptReplaceTarget = "コメ" | "投コメ" | "全" | "含まない" | "含む";
-type nicoScriptReplaceCondition = "完全一致" | "部分一致";
-type nicoScriptBan = {
+type NicoScriptReplaceRange = "単" | "全";
+type NicoScriptReplaceTarget =
+  | "コメ"
+  | "投コメ"
+  | "全"
+  | "含まない"
+  | "含む";
+type NicoScriptReplaceCondition = "完全一致" | "部分一致";
+type NicoScriptBan = {
   start: number;
   end: number;
 };
-type nicoScriptDefault = {
+type NicoScriptDefault = {
   start: number;
   long: number | undefined;
   color: string | undefined;
-  size: commentSize | undefined;
-  font: commentFont | undefined;
-  loc: commentLoc | undefined;
+  size: CommentSize | undefined;
+  font: CommentFont | undefined;
+  loc: CommentLoc | undefined;
 };
-type measureTextResult = {
+type MeasureTextResult = {
   width: number;
   height: number;
   resized: boolean;
@@ -922,17 +541,17 @@ type measureTextResult = {
   resizedY: boolean;
   fontSize: number;
   lineHeight: number;
-  content: commentMeasuredContentItem[];
+  content: CommentMeasuredContentItem[];
   charSize: number;
 };
-type parsedCommand = {
-  loc: commentLoc | undefined;
-  size: commentSize | undefined;
+type ParsedCommand = {
+  loc: CommentLoc | undefined;
+  size: CommentSize | undefined;
   fontSize: number | undefined;
   color: string | undefined;
   strokeColor?: string;
   wakuColor?: string;
-  font: commentFont | undefined;
+  font: CommentFont | undefined;
   full: boolean;
   ender: boolean;
   _live: boolean;
@@ -940,16 +559,16 @@ type parsedCommand = {
   long: number | undefined;
 };
 
-type measureTextInput = {
-  content: commentContentItem[];
+type MeasureTextInput = {
+  content: CommentContentItem[];
   resized?: boolean;
   ender: boolean;
-  size: commentSize;
+  size: CommentSize;
   fontSize: number;
   resizedY?: boolean;
   resizedX?: boolean;
-  font: commentFont;
-  loc: commentLoc;
+  font: CommentFont;
+  loc: CommentLoc;
   full: boolean;
   flash: boolean;
   lineCount: number;
@@ -957,79 +576,400 @@ type measureTextInput = {
   charSize?: number;
 };
 
-type measureInput = {
-  font: commentFont;
-  content: commentContentItem[];
+type MeasureInput = {
+  font: CommentFont;
+  content: CommentContentItem[];
   lineHeight: number;
   charSize: number;
   lineCount: number;
 };
 
-type valueOf<T> = T[keyof T];
+type ValueOf<T> = T[keyof T];
+
+declare let imageCache: {
+    [key: string]: {
+        image: HTMLCanvasElement;
+        timeout: number;
+    };
+};
+declare const resetImageCache: () => void;
+
+declare let nicoScripts: NicoScript;
+declare const resetNicoScripts: () => void;
+
+declare let plugins: IPlugin[];
+declare const setPlugins: (input: IPlugin[]) => void;
+
+declare const index_d$2_imageCache: typeof imageCache;
+declare const index_d$2_nicoScripts: typeof nicoScripts;
+declare const index_d$2_plugins: typeof plugins;
+declare const index_d$2_resetImageCache: typeof resetImageCache;
+declare const index_d$2_resetNicoScripts: typeof resetNicoScripts;
+declare const index_d$2_setPlugins: typeof setPlugins;
+declare namespace index_d$2 {
+  export {
+    index_d$2_imageCache as imageCache,
+    index_d$2_nicoScripts as nicoScripts,
+    index_d$2_plugins as plugins,
+    index_d$2_resetImageCache as resetImageCache,
+    index_d$2_resetNicoScripts as resetNicoScripts,
+    index_d$2_setPlugins as setPlugins,
+  };
+}
+
+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;
+};
+
+declare const colors$1_colors: typeof colors;
+declare namespace colors$1 {
+  export {
+    colors$1_colors as colors,
+  };
+}
+
+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;
+
+declare const config$1_config: typeof config;
+declare const config$1_defaultConfig: typeof defaultConfig;
+declare const config$1_defaultOptions: typeof defaultOptions;
+declare const config$1_options: typeof options;
+declare const config$1_setConfig: typeof setConfig;
+declare const config$1_setOptions: typeof setOptions;
+declare const config$1_updateConfig: typeof updateConfig;
+declare namespace config$1 {
+  export {
+    config$1_config as config,
+    config$1_defaultConfig as defaultConfig,
+    config$1_defaultOptions as defaultOptions,
+    config$1_options as options,
+    config$1_setConfig as setConfig,
+    config$1_setOptions as setOptions,
+    config$1_updateConfig as updateConfig,
+  };
+}
+
+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;
+    };
+};
+
+declare const fonts$1_fontTemplates: typeof fontTemplates;
+declare const fonts$1_fonts: typeof fonts;
+declare namespace fonts$1 {
+  export {
+    fonts$1_fontTemplates as fontTemplates,
+    fonts$1_fonts as fonts,
+  };
+}
+
+declare const initConfig: () => void;
+
+declare const initConfig$1_initConfig: typeof initConfig;
+declare namespace initConfig$1 {
+  export {
+    initConfig$1_initConfig as initConfig,
+  };
+}
+
+declare class CanvasRenderingContext2DError extends Error {
+    constructor(options?: {
+        [key: string]: unknown;
+    });
+}
+
+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;
+    });
+}
+
+type index_d$1_CanvasRenderingContext2DError = CanvasRenderingContext2DError;
+declare const index_d$1_CanvasRenderingContext2DError: typeof CanvasRenderingContext2DError;
+type index_d$1_InvalidFormatError = InvalidFormatError;
+declare const index_d$1_InvalidFormatError: typeof InvalidFormatError;
+type index_d$1_InvalidOptionError = InvalidOptionError;
+declare const index_d$1_InvalidOptionError: typeof InvalidOptionError;
+type index_d$1_NotImplementedError = NotImplementedError;
+declare const index_d$1_NotImplementedError: typeof NotImplementedError;
+declare namespace index_d$1 {
+  export {
+    index_d$1_CanvasRenderingContext2DError as CanvasRenderingContext2DError,
+    index_d$1_InvalidFormatError as InvalidFormatError,
+    index_d$1_InvalidOptionError as InvalidOptionError,
+    index_d$1_NotImplementedError as NotImplementedError,
+  };
+}
+
+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;
+
+declare const eventHandler_d_registerHandler: typeof registerHandler;
+declare const eventHandler_d_removeHandler: typeof removeHandler;
+declare const eventHandler_d_triggerHandler: typeof triggerHandler;
+declare namespace eventHandler_d {
+  export {
+    eventHandler_d_registerHandler as registerHandler,
+    eventHandler_d_removeHandler as removeHandler,
+    eventHandler_d_triggerHandler as triggerHandler,
+  };
+}
+
+declare const convert2formattedComment: (data: unknown, type: InputFormatType) => FormattedComment[];
+
+declare namespace inputParser_d {
+  export {
+    convert2formattedComment as default,
+  };
+}
+
+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>;
+    };
+};
+
+declare namespace typeGuard_d {
+  export {
+    typeGuard as default,
+  };
+}
 
-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;
 
-
-import { formattedCommentWithSize } from "@/@types";
 declare const hex2rgb: (hex: string) => number[];
 declare const hex2rgba: (hex: string) => number[];
-declare const getStrokeColor: (comment: formattedCommentWithSize) => string;
-
+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 isLineBreakResize: (comment: MeasureTextInput) => boolean;
 declare const getDefaultCommand: (vpos: number) => {
     color: string | undefined;
-    size: commentSize | undefined;
-    font: commentFont | undefined;
-    loc: commentLoc | undefined;
+    size: CommentSize | undefined;
+    font: CommentFont | undefined;
+    loc: CommentLoc | undefined;
 };
-declare const parseCommandAndNicoScript: (comment: formattedComment) => formattedCommentWithFont;
-declare const isFlashComment: (comment: formattedComment) => boolean;
+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 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;
-
+declare const getPosX: (comment: FormattedCommentWithSize, vpos: number, isReverse?: boolean) => number;
+declare const parseFont: (font: CommentFont, size: string | number) => string;
 
-import type { commentContentIndex, commentFlashFont } from "@/@types";
-declare const getFlashFontIndex: (part: string) => commentContentIndex[];
-declare const getFlashFontName: (font: string) => commentFlashFont;
+declare const changeCALayer: (rawData: FormattedComment[]) => FormattedComment[];
 
+declare const getConfig: <T>(input: ConfigItem<T>, isFlash?: boolean) => T;
 
-export * from "./array";
-export * from "./color";
-export * from "./comment";
-export * from "./commentArt";
-export * from "./config";
-export * from "./flash";
-export * from "./niconico";
-export * from "./sort";
+declare const getFlashFontIndex: (part: string) => CommentContentIndex[];
+declare const getFlashFontName: (font: string) => CommentFlashFont;
 
-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) => {
+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[];
@@ -1040,14 +980,168 @@ declare const getFontSizeAndScale: (charSize: 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 index_d_ArrayEqual: typeof ArrayEqual;
+declare const index_d_ArrayPush: typeof ArrayPush;
+declare const index_d_changeCALayer: typeof changeCALayer;
+declare const index_d_getCharSize: typeof getCharSize;
+declare const index_d_getConfig: typeof getConfig;
+declare const index_d_getDefaultCommand: typeof getDefaultCommand;
+declare const index_d_getFlashFontIndex: typeof getFlashFontIndex;
+declare const index_d_getFlashFontName: typeof getFlashFontName;
+declare const index_d_getFontSizeAndScale: typeof getFontSizeAndScale;
+declare const index_d_getLineHeight: typeof getLineHeight;
+declare const index_d_getPosX: typeof getPosX;
+declare const index_d_getPosY: typeof getPosY;
+declare const index_d_getStrokeColor: typeof getStrokeColor;
+declare const index_d_hex2rgb: typeof hex2rgb;
+declare const index_d_hex2rgba: typeof hex2rgba;
+declare const index_d_isBanActive: typeof isBanActive;
+declare const index_d_isFlashComment: typeof isFlashComment;
+declare const index_d_isLineBreakResize: typeof isLineBreakResize;
+declare const index_d_isReverseActive: typeof isReverseActive;
+declare const index_d_measure: typeof measure;
+declare const index_d_nativeSort: typeof nativeSort;
+declare const index_d_parseCommandAndNicoScript: typeof parseCommandAndNicoScript;
+declare const index_d_parseFont: typeof parseFont;
+declare const index_d_processFixedComment: typeof processFixedComment;
+declare const index_d_processMovableComment: typeof processMovableComment;
+declare namespace index_d {
+  export {
+    index_d_ArrayEqual as ArrayEqual,
+    index_d_ArrayPush as ArrayPush,
+    index_d_changeCALayer as changeCALayer,
+    index_d_getCharSize as getCharSize,
+    index_d_getConfig as getConfig,
+    index_d_getDefaultCommand as getDefaultCommand,
+    index_d_getFlashFontIndex as getFlashFontIndex,
+    index_d_getFlashFontName as getFlashFontName,
+    index_d_getFontSizeAndScale as getFontSizeAndScale,
+    index_d_getLineHeight as getLineHeight,
+    index_d_getPosX as getPosX,
+    index_d_getPosY as getPosY,
+    index_d_getStrokeColor as getStrokeColor,
+    index_d_hex2rgb as hex2rgb,
+    index_d_hex2rgba as hex2rgba,
+    index_d_isBanActive as isBanActive,
+    index_d_isFlashComment as isFlashComment,
+    index_d_isLineBreakResize as isLineBreakResize,
+    index_d_isReverseActive as isReverseActive,
+    index_d_measure as measure,
+    index_d_nativeSort as nativeSort,
+    index_d_parseCommandAndNicoScript as parseCommandAndNicoScript,
+    index_d_parseFont as parseFont,
+    index_d_processFixedComment as processFixedComment,
+    index_d_processMovableComment as processMovableComment,
+  };
+}
 
+declare const definition: {
+    colors: typeof colors$1;
+    config: typeof config$1;
+    fonts: typeof fonts$1;
+    initConfig: typeof initConfig$1;
+};
 
+declare const internal_definition: typeof definition;
+declare namespace internal {
+  export {
+    index_d$3 as comments,
+    index_d$2 as contexts,
+    internal_definition as definition,
+    index_d$1 as errors,
+    eventHandler_d as eventHandler,
+    inputParser_d as inputParser,
+    typeGuard_d as typeGuard,
+    index_d as utils,
+  };
+}
+
+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;
+            colorCodeAllowAlpha: (i: unknown) => i is string;
+        };
+        config: {
+            initOptions: (item: unknown) => item is Partial<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;
+}
 
-export default NiconiComments;
+export { ApiChat, ApiGlobalNumRes, ApiLeaf, ApiPing, ApiThread, BaseConfig, BaseOptions, Collision, CollisionItem, CollisionPos, CommentContentIndex, CommentContentItem, CommentDisableEvent, CommentDisableEventHandler, CommentEnableEvent, CommentEnableEventHandler, CommentEventBase, CommentEventHandler, CommentEventHandlerMap, CommentEventMap, CommentEventName, CommentFlashFont, CommentFont, CommentLoc, CommentMeasuredContentItem, CommentSize, CommentStageSize, Config, ConfigItem, FlashMode, FlashScriptChar, FontItem, FormattedComment, FormattedCommentWithFont, FormattedCommentWithSize, FormattedLegacyComment, HTML5Fonts, IComment, IPlugin, IPluginConstructor, InputFormat, InputFormatType, JumpEvent, JumpEventHandler, MeasureInput, MeasureTextInput, MeasureTextResult, NicoScript, NicoScriptReplace, NicoScriptReplaceCondition, NicoScriptReplaceRange, NicoScriptReplaceTarget, NicoScriptReverseTarget, Options, OwnerComment, ParsedCommand, Platform, PlatformFont, RawApiResponse, SeekDisableEvent, SeekDisableEventHandler, SeekEnableEvent, SeekEnableEventHandler, Timeline, V1Comment, V1Thread, ValueOf, NiconiComments as default, formattedComment, formattedLegacyComment, inputFormat, inputFormatType, ownerComment, rawApiResponse, v1Thread };