@yozora/tokenizer-html-inline 2.0.2 → 2.0.4

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020-2021 guanghechen (me.guanghechen@gmail.com)
+Copyright (c) 2020-2022 guanghechen (me.guanghechen@gmail.com)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yozora/tokenizer-html-inline",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "author": {
     "name": "guanghechen",
     "url": "https://github.com/guanghechen/"
@@ -30,15 +30,15 @@
   ],
   "scripts": {
     "build": "cross-env NODE_ENV=production rollup -c ../../rollup.config.js",
-    "prebuild": "rimraf lib/ && tsc -p tsconfig.src.json --emitDeclarationOnly",
+    "prebuild": "rimraf lib/",
     "prepublishOnly": "cross-env ROLLUP_SHOULD_SOURCEMAP=false yarn build",
     "test": "cross-env TS_NODE_FILES=true jest --config ../../jest.config.js --rootDir ."
   },
   "dependencies": {
-    "@yozora/ast": "^2.0.2",
-    "@yozora/character": "^2.0.2",
-    "@yozora/core-tokenizer": "^2.0.2",
-    "@yozora/tokenizer-html-block": "^2.0.2"
+    "@yozora/ast": "^2.0.4",
+    "@yozora/character": "^2.0.4",
+    "@yozora/core-tokenizer": "^2.0.4",
+    "@yozora/tokenizer-html-block": "^2.0.4"
   },
-  "gitHead": "6911295e9eacfa29563fe93494704190e50625fd"
+  "gitHead": "c980b95254394dcacba0cbb4bea251350b09397c"
 }

package/lib/types/match.d.ts

@@ -1,11 +0,0 @@
-import type { IMatchInlineHookCreator } from '@yozora/core-tokenizer';
-import type { IDelimiter, IThis, IToken, T } from './types';
-/**
- * Text between '<' and '>' that looks like an HTML tag is parsed as a raw HTML
- * tag and will be rendered in HTML without escaping. Tag and attribute names
- * are not limited to current HTML tags, so custom tags (and even, say, DocBook
- * tags) may be used.
- *
- * @see https://github.github.com/gfm/#raw-html
- */
-export declare const match: IMatchInlineHookCreator<T, IDelimiter, IToken, IThis>;

package/lib/types/parse.d.ts

@@ -1,3 +0,0 @@
-import type { IParseInlineHookCreator } from '@yozora/core-tokenizer';
-import type { INode, IThis, IToken, T } from './types';
-export declare const parse: IParseInlineHookCreator<T, IToken, INode, IThis>;

package/lib/types/tokenizer.d.ts

@@ -1,18 +0,0 @@
-import type { IInlineTokenizer, IMatchInlineHookCreator, IParseInlineHookCreator } from '@yozora/core-tokenizer';
-import { BaseInlineTokenizer } from '@yozora/core-tokenizer';
-import type { IDelimiter, INode, IThis, IToken, ITokenizerProps, T } from './types';
-/**
- * Lexical Analyzer for HtmlInline.
- *
- * Text between '<' and '>' that looks like an HTML tag is parsed as a raw HTML
- * tag and will be rendered in HTML without escaping. Tag and attribute names
- * are not limited to current HTML tags, so custom tags (and even, say, DocBook
- * tags) may be used.
- *
- * @see https://github.github.com/gfm/#raw-html
- */
-export declare class HtmlInlineTokenizer extends BaseInlineTokenizer<T, IDelimiter, IToken, INode, IThis> implements IInlineTokenizer<T, IDelimiter, IToken, INode, IThis> {
-    constructor(props?: ITokenizerProps);
-    readonly match: IMatchInlineHookCreator<T, IDelimiter, IToken, IThis>;
-    readonly parse: IParseInlineHookCreator<T, IToken, INode, IThis>;
-}

package/lib/types/types.d.ts

@@ -1,23 +0,0 @@
-import type { Html, HtmlType } from '@yozora/ast';
-import type { IBaseInlineTokenizerProps, IPartialYastInlineToken, ITokenizer } from '@yozora/core-tokenizer';
-import type { IHtmlInlineCDataDelimiter, IHtmlInlineCDataTokenData } from './util/cdata';
-import type { IHtmlInlineClosingDelimiter, IHtmlInlineClosingTokenData } from './util/closing';
-import type { IHtmlInlineCommentDelimiter, IHtmlInlineCommentTokenData } from './util/comment';
-import type { IHtmlInlineDeclarationDelimiter, IHtmlInlineDeclarationTokenData } from './util/declaration';
-import type { IHtmlInlineInstructionDelimiter, IHtmlInlineInstructionTokenData } from './util/instruction';
-import type { IHtmlInlineOpenDelimiter, IHtmlInlineOpenTokenData as IHtmlInlineOpenTokenData } from './util/open';
-export declare type T = HtmlType;
-export declare type INode = Html;
-export declare const uniqueName = "@yozora/tokenizer-html-inline";
-/**
- * Text between '<' and '>' that looks like an HTML tag is parsed as a raw
- * HTML tag and will be rendered in HTML without escaping. Tag and attribute
- * names are not limited to current HTML tags, so custom tags (and even, say,
- * DocBook tags) may be used.
- *
- * @see https://github.github.com/gfm/#raw-html
- */
-export declare type IToken = IPartialYastInlineToken<T> & (IHtmlInlineOpenTokenData | IHtmlInlineClosingTokenData | IHtmlInlineCommentTokenData | IHtmlInlineInstructionTokenData | IHtmlInlineDeclarationTokenData | IHtmlInlineCDataTokenData);
-export declare type IDelimiter = IHtmlInlineOpenDelimiter | IHtmlInlineClosingDelimiter | IHtmlInlineCommentDelimiter | IHtmlInlineInstructionDelimiter | IHtmlInlineDeclarationDelimiter | IHtmlInlineCDataDelimiter;
-export declare type IThis = ITokenizer;
-export declare type ITokenizerProps = Partial<IBaseInlineTokenizerProps>;

package/lib/types/util/cdata.d.ts

@@ -1,21 +0,0 @@
-import type { INodePoint } from '@yozora/character';
-import type { IYastTokenDelimiter } from '@yozora/core-tokenizer';
-export interface IHtmlInlineCDataData {
-    htmlType: 'cdata';
-}
-export interface IHtmlInlineCDataTokenData {
-    htmlType: 'cdata';
-}
-export interface IHtmlInlineCDataDelimiter extends IYastTokenDelimiter, IHtmlInlineCDataTokenData {
-    type: 'full';
-}
-/**
- * A CDATA section consists of the string `<![CDATA[`, a string of characters
- * not including the string `]]>`, and the string `]]>`.
- *
- * @param nodePoints
- * @param startIndex
- * @param endIndex
- * @see https://github.github.com/gfm/#cdata-section
- */
-export declare function eatHtmlInlineCDataDelimiter(nodePoints: ReadonlyArray<INodePoint>, startIndex: number, endIndex: number): IHtmlInlineCDataDelimiter | null;

package/lib/types/util/closing.d.ts

@@ -1,23 +0,0 @@
-import type { INodeInterval, INodePoint } from '@yozora/character';
-import type { IYastTokenDelimiter } from '@yozora/core-tokenizer';
-export interface IHtmlInlineClosingTagData {
-    htmlType: 'closing';
-    tagName: string;
-}
-export interface IHtmlInlineClosingTokenData {
-    htmlType: 'closing';
-    tagName: INodeInterval;
-}
-export interface IHtmlInlineClosingDelimiter extends IYastTokenDelimiter, IHtmlInlineClosingTokenData {
-    type: 'full';
-}
-/**
- * A closing tag consists of the string '</', a tag name, optional whitespace,
- * and the character '>'.
- *
- * @param nodePoints
- * @param startIndex
- * @param endIndex
- * @see https://github.github.com/gfm/#closing-tag
- */
-export declare function eatHtmlInlineClosingDelimiter(nodePoints: ReadonlyArray<INodePoint>, startIndex: number, endIndex: number): IHtmlInlineClosingDelimiter | null;

package/lib/types/util/comment.d.ts

@@ -1,21 +0,0 @@
-import type { INodePoint } from '@yozora/character';
-import type { IYastTokenDelimiter } from '@yozora/core-tokenizer';
-export interface IHtmlInlineCommentData {
-    htmlType: 'comment';
-}
-export interface IHtmlInlineCommentTokenData {
-    htmlType: 'comment';
-}
-export interface IHtmlInlineCommentDelimiter extends IYastTokenDelimiter, IHtmlInlineCommentTokenData {
-    type: 'full';
-}
-/**
- * An HTML comment consists of `<!--` + text + `-->`, where text does not start
- * with `>` or `->`, does not end with `-`, and does not contain `--`.
- *
- * @param nodePoints
- * @param startIndex
- * @param endIndex
- * @see https://github.github.com/gfm/#html-comment
- */
-export declare function eatHtmlInlineCommentDelimiter(nodePoints: ReadonlyArray<INodePoint>, startIndex: number, endIndex: number): IHtmlInlineCommentDelimiter | null;

package/lib/types/util/declaration.d.ts

@@ -1,23 +0,0 @@
-import type { INodeInterval, INodePoint } from '@yozora/character';
-import type { IYastTokenDelimiter } from '@yozora/core-tokenizer';
-export interface IHtmlInlineDeclarationData {
-    htmlType: 'declaration';
-}
-export interface IHtmlInlineDeclarationTokenData {
-    htmlType: 'declaration';
-    tagName: INodeInterval;
-}
-export interface IHtmlInlineDeclarationDelimiter extends IYastTokenDelimiter, IHtmlInlineDeclarationTokenData {
-    type: 'full';
-}
-/**
- * A declaration consists of the string `<!`, a name consisting of one or more
- * uppercase ASCII letters, whitespace, a string of characters not including
- * the character `>`, and the character `>`.
- *
- * @param nodePoints
- * @param startIndex
- * @param endIndex
- * @see https://github.github.com/gfm/#declaration
- */
-export declare function eatHtmlInlineDeclarationDelimiter(nodePoints: ReadonlyArray<INodePoint>, startIndex: number, endIndex: number): IHtmlInlineDeclarationDelimiter | null;

package/lib/types/util/instruction.d.ts

@@ -1,25 +0,0 @@
-import type { INodePoint } from '@yozora/character';
-import type { IYastTokenDelimiter } from '@yozora/core-tokenizer';
-/**
- *
- * @see https://github.github.com/gfm/#processing-instruction
- */
-export interface IHtmlInlineInstructionData {
-    htmlType: 'instruction';
-}
-export interface IHtmlInlineInstructionTokenData {
-    htmlType: 'instruction';
-}
-export interface IHtmlInlineInstructionDelimiter extends IYastTokenDelimiter, IHtmlInlineInstructionTokenData {
-    type: 'full';
-}
-/**
- * A processing instruction consists of the string `<?`, a string of characters
- * not including the string `?>`, and the string `?>`.
- *
- * @param nodePoints
- * @param startIndex
- * @param endIndex
- * @see https://github.github.com/gfm/#processing-instruction
- */
-export declare function eatHtmlInlineInstructionDelimiter(nodePoints: ReadonlyArray<INodePoint>, startIndex: number, endIndex: number): IHtmlInlineInstructionDelimiter | null;

package/lib/types/util/open.d.ts

@@ -1,40 +0,0 @@
-import type { INodeInterval, INodePoint } from '@yozora/character';
-import type { IYastTokenDelimiter } from '@yozora/core-tokenizer';
-import type { RawHTMLAttribute } from '@yozora/tokenizer-html-block';
-export interface IHtmlInlineOpenTagData {
-    htmlType: 'open';
-    /**
-     * HTML tag name.
-     */
-    tagName: string;
-    /**
-     * HTML attributes.
-     */
-    attributes: Array<{
-        name: string;
-        value?: string;
-    }>;
-    /**
-     * Whether if a html tag is self closed.
-     */
-    selfClosed: boolean;
-}
-export interface IHtmlInlineOpenTokenData {
-    htmlType: 'open';
-    tagName: INodeInterval;
-    attributes: RawHTMLAttribute[];
-    selfClosed: boolean;
-}
-export interface IHtmlInlineOpenDelimiter extends IYastTokenDelimiter, IHtmlInlineOpenTokenData {
-    type: 'full';
-}
-/**
- * An open tag consists of a '<' character, a tag name, zero or more attributes,
- * optional whitespace, an optional '/' character, and a '>' character.
- *
- * @param nodePoints
- * @param startIndex
- * @param endIndex
- * @see https://github.github.com/gfm/#open-tag
- */
-export declare function eatHtmlInlineTokenOpenDelimiter(nodePoints: ReadonlyArray<INodePoint>, startIndex: number, endIndex: number): IHtmlInlineOpenDelimiter | null;