v3 new release (#80)
This commit is contained in:
github-actions[bot]
committed by
GitHub
GitHub
parent
a767c8d3a1
commit
20d2b4f98d
635
node_modules/saxes/saxes.d.ts
generated
vendored
Normal file
635
node_modules/saxes/saxes.d.ts
generated
vendored
Normal file
@ -0,0 +1,635 @@
|
||||
/**
|
||||
* The list of supported events.
|
||||
*/
|
||||
export declare const EVENTS: readonly ["xmldecl", "text", "processinginstruction", "doctype", "comment", "opentagstart", "attribute", "opentag", "closetag", "cdata", "error", "end", "ready"];
|
||||
/**
|
||||
* Event handler for the
|
||||
*
|
||||
* @param text The text data encountered by the parser.
|
||||
*
|
||||
*/
|
||||
export declare type XMLDeclHandler = (decl: XMLDecl) => void;
|
||||
/**
|
||||
* Event handler for text data.
|
||||
*
|
||||
* @param text The text data encountered by the parser.
|
||||
*
|
||||
*/
|
||||
export declare type TextHandler = (text: string) => void;
|
||||
/**
|
||||
* Event handler for processing instructions.
|
||||
*
|
||||
* @param data The target and body of the processing instruction.
|
||||
*/
|
||||
export declare type PIHandler = (data: {
|
||||
target: string;
|
||||
body: string;
|
||||
}) => void;
|
||||
/**
|
||||
* Event handler for doctype.
|
||||
*
|
||||
* @param doctype The doctype contents.
|
||||
*/
|
||||
export declare type DoctypeHandler = (doctype: string) => void;
|
||||
/**
|
||||
* Event handler for comments.
|
||||
*
|
||||
* @param comment The comment contents.
|
||||
*/
|
||||
export declare type CommentHandler = (comment: string) => void;
|
||||
/**
|
||||
* Event handler for the start of an open tag. This is called as soon as we
|
||||
* have a tag name.
|
||||
*
|
||||
* @param tag The tag.
|
||||
*/
|
||||
export declare type OpenTagStartHandler<O> = (tag: StartTagForOptions<O>) => void;
|
||||
export declare type AttributeEventForOptions<O extends SaxesOptions> = O extends {
|
||||
xmlns: true;
|
||||
} ? SaxesAttributeNSIncomplete : O extends {
|
||||
xmlns?: false | undefined;
|
||||
} ? SaxesAttributePlain : SaxesAttribute;
|
||||
/**
|
||||
* Event handler for attributes.
|
||||
*/
|
||||
export declare type AttributeHandler<O> = (attribute: AttributeEventForOptions<O>) => void;
|
||||
/**
|
||||
* Event handler for an open tag. This is called when the open tag is
|
||||
* complete. (We've encountered the ">" that ends the open tag.)
|
||||
*
|
||||
* @param tag The tag.
|
||||
*/
|
||||
export declare type OpenTagHandler<O> = (tag: TagForOptions<O>) => void;
|
||||
/**
|
||||
* Event handler for a close tag. Note that for self-closing tags, this is
|
||||
* called right after ``opentag``.
|
||||
*
|
||||
* @param tag The tag.
|
||||
*/
|
||||
export declare type CloseTagHandler<O> = (tag: TagForOptions<O>) => void;
|
||||
/**
|
||||
* Event handler for a CDATA section. This is called when ending the
|
||||
* CDATA section.
|
||||
*
|
||||
* @param cdata The contents of the CDATA section.
|
||||
*/
|
||||
export declare type CDataHandler = (cdata: string) => void;
|
||||
/**
|
||||
* Event handler for the stream end. This is called when the stream has been
|
||||
* closed with ``close`` or by passing ``null`` to ``write``.
|
||||
*/
|
||||
export declare type EndHandler = () => void;
|
||||
/**
|
||||
* Event handler indicating parser readiness . This is called when the parser
|
||||
* is ready to parse a new document.
|
||||
*/
|
||||
export declare type ReadyHandler = () => void;
|
||||
/**
|
||||
* Event handler indicating an error.
|
||||
*
|
||||
* @param err The error that occurred.
|
||||
*/
|
||||
export declare type ErrorHandler = (err: Error) => void;
|
||||
export declare type EventName = (typeof EVENTS)[number];
|
||||
export declare type EventNameToHandler<O, N extends EventName> = {
|
||||
"xmldecl": XMLDeclHandler;
|
||||
"text": TextHandler;
|
||||
"processinginstruction": PIHandler;
|
||||
"doctype": DoctypeHandler;
|
||||
"comment": CommentHandler;
|
||||
"opentagstart": OpenTagStartHandler<O>;
|
||||
"attribute": AttributeHandler<O>;
|
||||
"opentag": OpenTagHandler<O>;
|
||||
"closetag": CloseTagHandler<O>;
|
||||
"cdata": CDataHandler;
|
||||
"error": ErrorHandler;
|
||||
"end": EndHandler;
|
||||
"ready": ReadyHandler;
|
||||
}[N];
|
||||
/**
|
||||
* This interface defines the structure of attributes when the parser is
|
||||
* processing namespaces (created with ``xmlns: true``).
|
||||
*/
|
||||
export interface SaxesAttributeNS {
|
||||
/**
|
||||
* The attribute's name. This is the combination of prefix and local name.
|
||||
* For instance ``a:b="c"`` would have ``a:b`` for name.
|
||||
*/
|
||||
name: string;
|
||||
/**
|
||||
* The attribute's prefix. For instance ``a:b="c"`` would have ``"a"`` for
|
||||
* ``prefix``.
|
||||
*/
|
||||
prefix: string;
|
||||
/**
|
||||
* The attribute's local name. For instance ``a:b="c"`` would have ``"b"`` for
|
||||
* ``local``.
|
||||
*/
|
||||
local: string;
|
||||
/** The namespace URI of this attribute. */
|
||||
uri: string;
|
||||
/** The attribute's value. */
|
||||
value: string;
|
||||
}
|
||||
/**
|
||||
* This is an attribute, as recorded by a parser which parses namespaces but
|
||||
* prior to the URI being resolvable. This is what is passed to the attribute
|
||||
* event handler.
|
||||
*/
|
||||
export declare type SaxesAttributeNSIncomplete = Exclude<SaxesAttributeNS, "uri">;
|
||||
/**
|
||||
* This interface defines the structure of attributes when the parser is
|
||||
* NOT processing namespaces (created with ``xmlns: false``).
|
||||
*/
|
||||
export interface SaxesAttributePlain {
|
||||
/**
|
||||
* The attribute's name.
|
||||
*/
|
||||
name: string;
|
||||
/** The attribute's value. */
|
||||
value: string;
|
||||
}
|
||||
/**
|
||||
* A saxes attribute, with or without namespace information.
|
||||
*/
|
||||
export declare type SaxesAttribute = SaxesAttributeNS | SaxesAttributePlain;
|
||||
/**
|
||||
* This are the fields that MAY be present on a complete tag.
|
||||
*/
|
||||
export interface SaxesTag {
|
||||
/**
|
||||
* The tag's name. This is the combination of prefix and global name. For
|
||||
* instance ``<a:b>`` would have ``"a:b"`` for ``name``.
|
||||
*/
|
||||
name: string;
|
||||
/**
|
||||
* A map of attribute name to attributes. If namespaces are tracked, the
|
||||
* values in the map are attribute objects. Otherwise, they are strings.
|
||||
*/
|
||||
attributes: Record<string, SaxesAttributeNS> | Record<string, string>;
|
||||
/**
|
||||
* The namespace bindings in effect.
|
||||
*/
|
||||
ns?: Record<string, string>;
|
||||
/**
|
||||
* The tag's prefix. For instance ``<a:b>`` would have ``"a"`` for
|
||||
* ``prefix``. Undefined if we do not track namespaces.
|
||||
*/
|
||||
prefix?: string;
|
||||
/**
|
||||
* The tag's local name. For instance ``<a:b>`` would
|
||||
* have ``"b"`` for ``local``. Undefined if we do not track namespaces.
|
||||
*/
|
||||
local?: string;
|
||||
/**
|
||||
* The namespace URI of this tag. Undefined if we do not track namespaces.
|
||||
*/
|
||||
uri?: string;
|
||||
/** Whether the tag is self-closing (e.g. ``<foo/>``). */
|
||||
isSelfClosing: boolean;
|
||||
}
|
||||
/**
|
||||
* This type defines the fields that are present on a tag object when
|
||||
* ``onopentagstart`` is called. This interface is namespace-agnostic.
|
||||
*/
|
||||
export declare type SaxesStartTag = Pick<SaxesTag, "name" | "attributes" | "ns">;
|
||||
/**
|
||||
* This type defines the fields that are present on a tag object when
|
||||
* ``onopentagstart`` is called on a parser that does not processes namespaces.
|
||||
*/
|
||||
export declare type SaxesStartTagPlain = Pick<SaxesStartTag, "name" | "attributes">;
|
||||
/**
|
||||
* This type defines the fields that are present on a tag object when
|
||||
* ``onopentagstart`` is called on a parser that does process namespaces.
|
||||
*/
|
||||
export declare type SaxesStartTagNS = Required<SaxesStartTag>;
|
||||
/**
|
||||
* This are the fields that are present on a complete tag produced by a parser
|
||||
* that does process namespaces.
|
||||
*/
|
||||
export declare type SaxesTagNS = Required<SaxesTag> & {
|
||||
attributes: Record<string, SaxesAttributeNS>;
|
||||
};
|
||||
/**
|
||||
* This are the fields that are present on a complete tag produced by a parser
|
||||
* that does not process namespaces.
|
||||
*/
|
||||
export declare type SaxesTagPlain = Pick<SaxesTag, "name" | "attributes" | "isSelfClosing"> & {
|
||||
attributes: Record<string, string>;
|
||||
};
|
||||
/**
|
||||
* An XML declaration.
|
||||
*/
|
||||
export interface XMLDecl {
|
||||
/** The version specified by the XML declaration. */
|
||||
version?: string;
|
||||
/** The encoding specified by the XML declaration. */
|
||||
encoding?: string;
|
||||
/** The value of the standalone parameter */
|
||||
standalone?: string;
|
||||
}
|
||||
/**
|
||||
* A callback for resolving name prefixes.
|
||||
*
|
||||
* @param prefix The prefix to check.
|
||||
*
|
||||
* @returns The URI corresponding to the prefix, if any.
|
||||
*/
|
||||
export declare type ResolvePrefix = (prefix: string) => string | undefined;
|
||||
export interface CommonOptions {
|
||||
/** Whether to accept XML fragments. Unset means ``false``. */
|
||||
fragment?: boolean;
|
||||
/** Whether to track positions. Unset means ``true``. */
|
||||
position?: boolean;
|
||||
/**
|
||||
* A file name to use for error reporting. "File name" is a loose concept. You
|
||||
* could use a URL to some resource, or any descriptive name you like.
|
||||
*/
|
||||
fileName?: string;
|
||||
}
|
||||
export interface NSOptions {
|
||||
/** Whether to track namespaces. Unset means ``false``. */
|
||||
xmlns?: boolean;
|
||||
/**
|
||||
* A plain object whose key, value pairs define namespaces known before
|
||||
* parsing the XML file. It is not legal to pass bindings for the namespaces
|
||||
* ``"xml"`` or ``"xmlns"``.
|
||||
*/
|
||||
additionalNamespaces?: Record<string, string>;
|
||||
/**
|
||||
* A function that will be used if the parser cannot resolve a namespace
|
||||
* prefix on its own.
|
||||
*/
|
||||
resolvePrefix?: ResolvePrefix;
|
||||
}
|
||||
export interface NSOptionsWithoutNamespaces extends NSOptions {
|
||||
xmlns?: false;
|
||||
additionalNamespaces?: undefined;
|
||||
resolvePrefix?: undefined;
|
||||
}
|
||||
export interface NSOptionsWithNamespaces extends NSOptions {
|
||||
xmlns: true;
|
||||
}
|
||||
export interface XMLVersionOptions {
|
||||
/**
|
||||
* The default XML version to use. If unspecified, and there is no XML
|
||||
* encoding declaration, the default version is "1.0".
|
||||
*/
|
||||
defaultXMLVersion?: "1.0" | "1.1";
|
||||
/**
|
||||
* A flag indicating whether to force the XML version used for parsing to the
|
||||
* value of ``defaultXMLVersion``. When this flag is ``true``,
|
||||
* ``defaultXMLVersion`` must be specified. If unspecified, the default value
|
||||
* of this flag is ``false``.
|
||||
*/
|
||||
forceXMLVersion?: boolean;
|
||||
}
|
||||
export interface NoForcedXMLVersion extends XMLVersionOptions {
|
||||
forceXMLVersion?: false;
|
||||
}
|
||||
export interface ForcedXMLVersion extends XMLVersionOptions {
|
||||
forceXMLVersion: true;
|
||||
defaultXMLVersion: Exclude<XMLVersionOptions["defaultXMLVersion"], undefined>;
|
||||
}
|
||||
/**
|
||||
* The entire set of options supported by saxes.
|
||||
*/
|
||||
export declare type SaxesOptions = CommonOptions & NSOptions & XMLVersionOptions;
|
||||
export declare type TagForOptions<O extends SaxesOptions> = O extends {
|
||||
xmlns: true;
|
||||
} ? SaxesTagNS : O extends {
|
||||
xmlns?: false | undefined;
|
||||
} ? SaxesTagPlain : SaxesTag;
|
||||
export declare type StartTagForOptions<O extends SaxesOptions> = O extends {
|
||||
xmlns: true;
|
||||
} ? SaxesStartTagNS : O extends {
|
||||
xmlns?: false | undefined;
|
||||
} ? SaxesStartTagPlain : SaxesStartTag;
|
||||
export declare class SaxesParser<O extends SaxesOptions = {}> {
|
||||
private readonly fragmentOpt;
|
||||
private readonly xmlnsOpt;
|
||||
private readonly trackPosition;
|
||||
private readonly fileName?;
|
||||
private readonly nameStartCheck;
|
||||
private readonly nameCheck;
|
||||
private readonly isName;
|
||||
private readonly ns;
|
||||
private openWakaBang;
|
||||
private text;
|
||||
private name;
|
||||
private piTarget;
|
||||
private entity;
|
||||
private q;
|
||||
private tags;
|
||||
private tag;
|
||||
private topNS;
|
||||
private chunk;
|
||||
private chunkPosition;
|
||||
private i;
|
||||
private prevI;
|
||||
private carriedFromPrevious?;
|
||||
private forbiddenState;
|
||||
private attribList;
|
||||
private state;
|
||||
private reportedTextBeforeRoot;
|
||||
private reportedTextAfterRoot;
|
||||
private closedRoot;
|
||||
private sawRoot;
|
||||
private xmlDeclPossible;
|
||||
private xmlDeclExpects;
|
||||
private entityReturnState?;
|
||||
private processAttribs;
|
||||
private positionAtNewLine;
|
||||
private doctype;
|
||||
private getCode;
|
||||
private isChar;
|
||||
private pushAttrib;
|
||||
private _closed;
|
||||
private currentXMLVersion;
|
||||
private readonly stateTable;
|
||||
private xmldeclHandler?;
|
||||
private textHandler?;
|
||||
private piHandler?;
|
||||
private doctypeHandler?;
|
||||
private commentHandler?;
|
||||
private openTagStartHandler?;
|
||||
private openTagHandler?;
|
||||
private closeTagHandler?;
|
||||
private cdataHandler?;
|
||||
private errorHandler?;
|
||||
private endHandler?;
|
||||
private readyHandler?;
|
||||
private attributeHandler?;
|
||||
/**
|
||||
* Indicates whether or not the parser is closed. If ``true``, wait for
|
||||
* the ``ready`` event to write again.
|
||||
*/
|
||||
get closed(): boolean;
|
||||
readonly opt: SaxesOptions;
|
||||
/**
|
||||
* The XML declaration for this document.
|
||||
*/
|
||||
xmlDecl: XMLDecl;
|
||||
/**
|
||||
* The line number of the next character to be read by the parser. This field
|
||||
* is one-based. (The first line is numbered 1.)
|
||||
*/
|
||||
line: number;
|
||||
/**
|
||||
* The column number of the next character to be read by the parser. *
|
||||
* This field is zero-based. (The first column is 0.)
|
||||
*
|
||||
* This field counts columns by *Unicode character*. Note that this *can*
|
||||
* be different from the index of the character in a JavaScript string due
|
||||
* to how JavaScript handles astral plane characters.
|
||||
*
|
||||
* See [[columnIndex]] for a number that corresponds to the JavaScript index.
|
||||
*/
|
||||
column: number;
|
||||
/**
|
||||
* A map of entity name to expansion.
|
||||
*/
|
||||
ENTITIES: Record<string, string>;
|
||||
/**
|
||||
* @param opt The parser options.
|
||||
*/
|
||||
constructor(opt?: O);
|
||||
_init(): void;
|
||||
/**
|
||||
* The stream position the parser is currently looking at. This field is
|
||||
* zero-based.
|
||||
*
|
||||
* This field is not based on counting Unicode characters but is to be
|
||||
* interpreted as a plain index into a JavaScript string.
|
||||
*/
|
||||
get position(): number;
|
||||
/**
|
||||
* The column number of the next character to be read by the parser. *
|
||||
* This field is zero-based. (The first column in a line is 0.)
|
||||
*
|
||||
* This field reports the index at which the next character would be in the
|
||||
* line if the line were represented as a JavaScript string. Note that this
|
||||
* *can* be different to a count based on the number of *Unicode characters*
|
||||
* due to how JavaScript handles astral plane characters.
|
||||
*
|
||||
* See [[column]] for a number that corresponds to a count of Unicode
|
||||
* characters.
|
||||
*/
|
||||
get columnIndex(): number;
|
||||
/**
|
||||
* Set an event listener on an event. The parser supports one handler per
|
||||
* event type. If you try to set an event handler over an existing handler,
|
||||
* the old handler is silently overwritten.
|
||||
*
|
||||
* @param name The event to listen to.
|
||||
*
|
||||
* @param handler The handler to set.
|
||||
*/
|
||||
on<N extends EventName>(name: N, handler: EventNameToHandler<O, N>): void;
|
||||
/**
|
||||
* Unset an event handler.
|
||||
*
|
||||
* @parma name The event to stop listening to.
|
||||
*/
|
||||
off(name: EventName): void;
|
||||
/**
|
||||
* Make an error object. The error object will have a message that contains
|
||||
* the ``fileName`` option passed at the creation of the parser. If position
|
||||
* tracking was turned on, it will also have line and column number
|
||||
* information.
|
||||
*
|
||||
* @param message The message describing the error to report.
|
||||
*
|
||||
* @returns An error object with a properly formatted message.
|
||||
*/
|
||||
makeError(message: string): Error;
|
||||
/**
|
||||
* Report a parsing error. This method is made public so that client code may
|
||||
* check for issues that are outside the scope of this project and can report
|
||||
* errors.
|
||||
*
|
||||
* @param message The error to report.
|
||||
*
|
||||
* @returns this
|
||||
*/
|
||||
fail(message: string): this;
|
||||
/**
|
||||
* Write a XML data to the parser.
|
||||
*
|
||||
* @param chunk The XML data to write.
|
||||
*
|
||||
* @returns this
|
||||
*/
|
||||
write(chunk: string | {} | null): this;
|
||||
/**
|
||||
* Close the current stream. Perform final well-formedness checks and reset
|
||||
* the parser tstate.
|
||||
*
|
||||
* @returns this
|
||||
*/
|
||||
close(): this;
|
||||
/**
|
||||
* Get a single code point out of the current chunk. This updates the current
|
||||
* position if we do position tracking.
|
||||
*
|
||||
* This is the algorithm to use for XML 1.0.
|
||||
*
|
||||
* @returns The character read.
|
||||
*/
|
||||
private getCode10;
|
||||
/**
|
||||
* Get a single code point out of the current chunk. This updates the current
|
||||
* position if we do position tracking.
|
||||
*
|
||||
* This is the algorithm to use for XML 1.1.
|
||||
*
|
||||
* @returns {number} The character read.
|
||||
*/
|
||||
private getCode11;
|
||||
/**
|
||||
* Like ``getCode`` but with the return value normalized so that ``NL`` is
|
||||
* returned for ``NL_LIKE``.
|
||||
*/
|
||||
private getCodeNorm;
|
||||
private unget;
|
||||
/**
|
||||
* Capture characters into a buffer until encountering one of a set of
|
||||
* characters.
|
||||
*
|
||||
* @param chars An array of codepoints. Encountering a character in the array
|
||||
* ends the capture. (``chars`` may safely contain ``NL``.)
|
||||
*
|
||||
* @return The character code that made the capture end, or ``EOC`` if we hit
|
||||
* the end of the chunk. The return value cannot be NL_LIKE: NL is returned
|
||||
* instead.
|
||||
*/
|
||||
private captureTo;
|
||||
/**
|
||||
* Capture characters into a buffer until encountering a character.
|
||||
*
|
||||
* @param char The codepoint that ends the capture. **NOTE ``char`` MAY NOT
|
||||
* CONTAIN ``NL``.** Passing ``NL`` will result in buggy behavior.
|
||||
*
|
||||
* @return ``true`` if we ran into the character. Otherwise, we ran into the
|
||||
* end of the current chunk.
|
||||
*/
|
||||
private captureToChar;
|
||||
/**
|
||||
* Capture characters that satisfy ``isNameChar`` into the ``name`` field of
|
||||
* this parser.
|
||||
*
|
||||
* @return The character code that made the test fail, or ``EOC`` if we hit
|
||||
* the end of the chunk. The return value cannot be NL_LIKE: NL is returned
|
||||
* instead.
|
||||
*/
|
||||
private captureNameChars;
|
||||
/**
|
||||
* Skip white spaces.
|
||||
*
|
||||
* @return The character that ended the skip, or ``EOC`` if we hit
|
||||
* the end of the chunk. The return value cannot be NL_LIKE: NL is returned
|
||||
* instead.
|
||||
*/
|
||||
private skipSpaces;
|
||||
private setXMLVersion;
|
||||
private sBegin;
|
||||
private sBeginWhitespace;
|
||||
private sDoctype;
|
||||
private sDoctypeQuote;
|
||||
private sDTD;
|
||||
private sDTDQuoted;
|
||||
private sDTDOpenWaka;
|
||||
private sDTDOpenWakaBang;
|
||||
private sDTDComment;
|
||||
private sDTDCommentEnding;
|
||||
private sDTDCommentEnded;
|
||||
private sDTDPI;
|
||||
private sDTDPIEnding;
|
||||
private sText;
|
||||
private sEntity;
|
||||
private sOpenWaka;
|
||||
private sOpenWakaBang;
|
||||
private sComment;
|
||||
private sCommentEnding;
|
||||
private sCommentEnded;
|
||||
private sCData;
|
||||
private sCDataEnding;
|
||||
private sCDataEnding2;
|
||||
private sPIFirstChar;
|
||||
private sPIRest;
|
||||
private sPIBody;
|
||||
private sPIEnding;
|
||||
private sXMLDeclNameStart;
|
||||
private sXMLDeclName;
|
||||
private sXMLDeclEq;
|
||||
private sXMLDeclValueStart;
|
||||
private sXMLDeclValue;
|
||||
private sXMLDeclSeparator;
|
||||
private sXMLDeclEnding;
|
||||
private sOpenTag;
|
||||
private sOpenTagSlash;
|
||||
private sAttrib;
|
||||
private sAttribName;
|
||||
private sAttribNameSawWhite;
|
||||
private sAttribValue;
|
||||
private sAttribValueQuoted;
|
||||
private sAttribValueClosed;
|
||||
private sAttribValueUnquoted;
|
||||
private sCloseTag;
|
||||
private sCloseTagSawWhite;
|
||||
private handleTextInRoot;
|
||||
private handleTextOutsideRoot;
|
||||
private pushAttribNS;
|
||||
private pushAttribPlain;
|
||||
/**
|
||||
* End parsing. This performs final well-formedness checks and resets the
|
||||
* parser to a clean state.
|
||||
*
|
||||
* @returns this
|
||||
*/
|
||||
private end;
|
||||
/**
|
||||
* Resolve a namespace prefix.
|
||||
*
|
||||
* @param prefix The prefix to resolve.
|
||||
*
|
||||
* @returns The namespace URI or ``undefined`` if the prefix is not defined.
|
||||
*/
|
||||
resolve(prefix: string): string | undefined;
|
||||
/**
|
||||
* Parse a qname into its prefix and local name parts.
|
||||
*
|
||||
* @param name The name to parse
|
||||
*
|
||||
* @returns
|
||||
*/
|
||||
private qname;
|
||||
private processAttribsNS;
|
||||
private processAttribsPlain;
|
||||
/**
|
||||
* Handle a complete open tag. This parser code calls this once it has seen
|
||||
* the whole tag. This method checks for well-formeness and then emits
|
||||
* ``onopentag``.
|
||||
*/
|
||||
private openTag;
|
||||
/**
|
||||
* Handle a complete self-closing tag. This parser code calls this once it has
|
||||
* seen the whole tag. This method checks for well-formeness and then emits
|
||||
* ``onopentag`` and ``onclosetag``.
|
||||
*/
|
||||
private openSelfClosingTag;
|
||||
/**
|
||||
* Handle a complete close tag. This parser code calls this once it has seen
|
||||
* the whole tag. This method checks for well-formeness and then emits
|
||||
* ``onclosetag``.
|
||||
*/
|
||||
private closeTag;
|
||||
/**
|
||||
* Resolves an entity. Makes any necessary well-formedness checks.
|
||||
*
|
||||
* @param entity The entity to resolve.
|
||||
*
|
||||
* @returns The parsed entity.
|
||||
*/
|
||||
private parseEntity;
|
||||
}
|
||||
Reference in New Issue
Block a user