cloudstructs 0.9.19 → 0.9.21

package/node_modules/parse5/dist/serializer/index.d.ts

@@ -49,7 +49,7 @@ export declare function serialize<T extends TreeAdapterTypeMap = DefaultTreeAdap
  * const document = parse5.parseFragment('<div>Hello, <b>world</b>!</div>');
  *
  * // Serializes the <div> element.
- * const html = parse5.serializeOuter(document.childNodes[0]);
+ * const str = parse5.serializeOuter(document.childNodes[0]);
  *
  * console.log(str); //> '<div>Hello, <b>world</b>!</div>'
  * ```
@@ -58,4 +58,3 @@ export declare function serialize<T extends TreeAdapterTypeMap = DefaultTreeAdap
  * @param options Serialization options.
  */
 export declare function serializeOuter<T extends TreeAdapterTypeMap = DefaultTreeAdapterMap>(node: T['node'], options?: SerializerOptions<T>): string;
-//# sourceMappingURL=index.d.ts.map

package/node_modules/parse5/dist/serializer/index.js

@@ -68,7 +68,7 @@ export function serialize(node, options) {
  * const document = parse5.parseFragment('<div>Hello, <b>world</b>!</div>');
  *
  * // Serializes the <div> element.
- * const html = parse5.serializeOuter(document.childNodes[0]);
+ * const str = parse5.serializeOuter(document.childNodes[0]);
  *
  * console.log(str); //> '<div>Hello, <b>world</b>!</div>'
  * ```
@@ -120,10 +120,7 @@ function serializeAttributes(node, { treeAdapter }) {
     let html = '';
     for (const attr of treeAdapter.getAttrList(node)) {
         html += ' ';
-        if (!attr.namespace) {
-            html += attr.name;
-        }
-        else
+        if (attr.namespace) {
             switch (attr.namespace) {
                 case NS.XML: {
                     html += `xml:${attr.name}`;
@@ -144,6 +141,10 @@ function serializeAttributes(node, { treeAdapter }) {
                     html += `${attr.prefix}:${attr.name}`;
                 }
             }
+        }
+        else {
+            html += attr.name;
+        }
         html += `="${escapeAttribute(attr.value)}"`;
     }
     return html;
@@ -165,4 +166,3 @@ function serializeCommentNode(node, { treeAdapter }) {
 function serializeDocumentTypeNode(node, { treeAdapter }) {
     return `<!DOCTYPE ${treeAdapter.getDocumentTypeNodeName(node)}>`;
 }
-//# sourceMappingURL=index.js.map

package/node_modules/parse5/dist/tokenizer/index.d.ts

@@ -1,6 +1,7 @@
 import { Preprocessor } from './preprocessor.js';
-import { type CharacterToken, type DoctypeToken, type TagToken, type EOFToken, type CommentToken } from '../common/token.js';
-import { type ParserErrorHandler } from '../common/error-codes.js';
+import { type Token, type CharacterToken, type DoctypeToken, type TagToken, type EOFToken, type CommentToken, type Attribute, type Location } from '../common/token.js';
+import { EntityDecoder } from 'entities/lib/decode.js';
+import { ERR, type ParserErrorHandler } from '../common/error-codes.js';
 declare const enum State {
     DATA = 0,
     RCDATA = 1,
@@ -74,13 +75,7 @@ declare const enum State {
     CDATA_SECTION_BRACKET = 69,
     CDATA_SECTION_END = 70,
     CHARACTER_REFERENCE = 71,
-    NAMED_CHARACTER_REFERENCE = 72,
-    AMBIGUOUS_AMPERSAND = 73,
-    NUMERIC_CHARACTER_REFERENCE = 74,
-    HEXADEMICAL_CHARACTER_REFERENCE_START = 75,
-    HEXADEMICAL_CHARACTER_REFERENCE = 76,
-    DECIMAL_CHARACTER_REFERENCE = 77,
-    NUMERIC_CHARACTER_REFERENCE_END = 78
+    AMBIGUOUS_AMPERSAND = 72
 }
 export declare const TokenizerMode: {
     readonly DATA: State.DATA;
@@ -105,12 +100,12 @@ export interface TokenHandler {
     onParseError?: ParserErrorHandler | null;
 }
 export declare class Tokenizer {
-    private options;
-    private handler;
+    protected options: TokenizerOptions;
+    protected handler: TokenHandler;
     preprocessor: Preprocessor;
-    private paused;
+    protected paused: boolean;
     /** Ensures that the parsing loop isn't run multiple times at once. */
-    private inLoop;
+    protected inLoop: boolean;
     /**
      * Indicates that the current adjusted node exists, is not an element in the HTML namespace,
      * and that it is not an integration point for either MathML or HTML.
@@ -121,128 +116,132 @@ export declare class Tokenizer {
     lastStartTagName: string;
     active: boolean;
     state: State;
-    private returnState;
-    private charRefCode;
-    private consumedAfterSnapshot;
-    private currentLocation;
-    private currentCharacterToken;
-    private currentToken;
-    private currentAttr;
+    protected returnState: State;
+    /**
+     * We use `entities`' `EntityDecoder` to parse character references.
+     *
+     * All of the following states are handled by the `EntityDecoder`:
+     *
+     * - Named character reference state
+     * - Numeric character reference state
+     * - Hexademical character reference start state
+     * - Hexademical character reference state
+     * - Decimal character reference state
+     * - Numeric character reference end state
+     */
+    protected entityDecoder: EntityDecoder;
+    protected entityStartPos: number;
+    protected consumedAfterSnapshot: number;
+    protected currentLocation: Location | null;
+    protected currentCharacterToken: CharacterToken | null;
+    protected currentToken: Token | null;
+    protected currentAttr: Attribute;
     constructor(options: TokenizerOptions, handler: TokenHandler);
-    private _err;
-    private getCurrentLocation;
-    private _runParsingLoop;
+    protected _err(code: ERR, cpOffset?: number): void;
+    protected getCurrentLocation(offset: number): Location | null;
+    protected _runParsingLoop(): void;
     pause(): void;
     resume(writeCallback?: () => void): void;
     write(chunk: string, isLastChunk: boolean, writeCallback?: () => void): void;
     insertHtmlAtCurrentPos(chunk: string): void;
-    private _ensureHibernation;
-    private _consume;
-    private _unconsume;
-    private _reconsumeInState;
-    private _advanceBy;
-    private _consumeSequenceIfMatch;
-    private _createStartTagToken;
-    private _createEndTagToken;
-    private _createCommentToken;
-    private _createDoctypeToken;
-    private _createCharacterToken;
-    private _createAttr;
-    private _leaveAttrName;
-    private _leaveAttrValue;
-    private prepareToken;
-    private emitCurrentTagToken;
-    private emitCurrentComment;
-    private emitCurrentDoctype;
-    private _emitCurrentCharacterToken;
-    private _emitEOFToken;
-    private _appendCharToCurrentCharacterToken;
-    private _emitCodePoint;
-    private _emitChars;
-    private _matchNamedCharacterReference;
-    private _isCharacterReferenceInAttribute;
-    private _flushCodePointConsumedAsCharacterReference;
-    private _callState;
-    private _stateData;
-    private _stateRcdata;
-    private _stateRawtext;
-    private _stateScriptData;
-    private _statePlaintext;
-    private _stateTagOpen;
-    private _stateEndTagOpen;
-    private _stateTagName;
-    private _stateRcdataLessThanSign;
-    private _stateRcdataEndTagOpen;
-    private handleSpecialEndTag;
-    private _stateRcdataEndTagName;
-    private _stateRawtextLessThanSign;
-    private _stateRawtextEndTagOpen;
-    private _stateRawtextEndTagName;
-    private _stateScriptDataLessThanSign;
-    private _stateScriptDataEndTagOpen;
-    private _stateScriptDataEndTagName;
-    private _stateScriptDataEscapeStart;
-    private _stateScriptDataEscapeStartDash;
-    private _stateScriptDataEscaped;
-    private _stateScriptDataEscapedDash;
-    private _stateScriptDataEscapedDashDash;
-    private _stateScriptDataEscapedLessThanSign;
-    private _stateScriptDataEscapedEndTagOpen;
-    private _stateScriptDataEscapedEndTagName;
-    private _stateScriptDataDoubleEscapeStart;
-    private _stateScriptDataDoubleEscaped;
-    private _stateScriptDataDoubleEscapedDash;
-    private _stateScriptDataDoubleEscapedDashDash;
-    private _stateScriptDataDoubleEscapedLessThanSign;
-    private _stateScriptDataDoubleEscapeEnd;
-    private _stateBeforeAttributeName;
-    private _stateAttributeName;
-    private _stateAfterAttributeName;
-    private _stateBeforeAttributeValue;
-    private _stateAttributeValueDoubleQuoted;
-    private _stateAttributeValueSingleQuoted;
-    private _stateAttributeValueUnquoted;
-    private _stateAfterAttributeValueQuoted;
-    private _stateSelfClosingStartTag;
-    private _stateBogusComment;
-    private _stateMarkupDeclarationOpen;
-    private _stateCommentStart;
-    private _stateCommentStartDash;
-    private _stateComment;
-    private _stateCommentLessThanSign;
-    private _stateCommentLessThanSignBang;
-    private _stateCommentLessThanSignBangDash;
-    private _stateCommentLessThanSignBangDashDash;
-    private _stateCommentEndDash;
-    private _stateCommentEnd;
-    private _stateCommentEndBang;
-    private _stateDoctype;
-    private _stateBeforeDoctypeName;
-    private _stateDoctypeName;
-    private _stateAfterDoctypeName;
-    private _stateAfterDoctypePublicKeyword;
-    private _stateBeforeDoctypePublicIdentifier;
-    private _stateDoctypePublicIdentifierDoubleQuoted;
-    private _stateDoctypePublicIdentifierSingleQuoted;
-    private _stateAfterDoctypePublicIdentifier;
-    private _stateBetweenDoctypePublicAndSystemIdentifiers;
-    private _stateAfterDoctypeSystemKeyword;
-    private _stateBeforeDoctypeSystemIdentifier;
-    private _stateDoctypeSystemIdentifierDoubleQuoted;
-    private _stateDoctypeSystemIdentifierSingleQuoted;
-    private _stateAfterDoctypeSystemIdentifier;
-    private _stateBogusDoctype;
-    private _stateCdataSection;
-    private _stateCdataSectionBracket;
-    private _stateCdataSectionEnd;
-    private _stateCharacterReference;
-    private _stateNamedCharacterReference;
-    private _stateAmbiguousAmpersand;
-    private _stateNumericCharacterReference;
-    private _stateHexademicalCharacterReferenceStart;
-    private _stateHexademicalCharacterReference;
-    private _stateDecimalCharacterReference;
-    private _stateNumericCharacterReferenceEnd;
+    protected _ensureHibernation(): boolean;
+    protected _consume(): number;
+    protected _advanceBy(count: number): void;
+    protected _consumeSequenceIfMatch(pattern: string, caseSensitive: boolean): boolean;
+    protected _createStartTagToken(): void;
+    protected _createEndTagToken(): void;
+    protected _createCommentToken(offset: number): void;
+    protected _createDoctypeToken(initialName: string | null): void;
+    protected _createCharacterToken(type: CharacterToken['type'], chars: string): void;
+    protected _createAttr(attrNameFirstCh: string): void;
+    protected _leaveAttrName(): void;
+    protected _leaveAttrValue(): void;
+    protected prepareToken(ct: Token): void;
+    protected emitCurrentTagToken(): void;
+    protected emitCurrentComment(ct: CommentToken): void;
+    protected emitCurrentDoctype(ct: DoctypeToken): void;
+    protected _emitCurrentCharacterToken(nextLocation: Location | null): void;
+    protected _emitEOFToken(): void;
+    protected _appendCharToCurrentCharacterToken(type: CharacterToken['type'], ch: string): void;
+    protected _emitCodePoint(cp: number): void;
+    protected _emitChars(ch: string): void;
+    protected _startCharacterReference(): void;
+    protected _isCharacterReferenceInAttribute(): boolean;
+    protected _flushCodePointConsumedAsCharacterReference(cp: number): void;
+    protected _callState(cp: number): void;
+    protected _stateData(cp: number): void;
+    protected _stateRcdata(cp: number): void;
+    protected _stateRawtext(cp: number): void;
+    protected _stateScriptData(cp: number): void;
+    protected _statePlaintext(cp: number): void;
+    protected _stateTagOpen(cp: number): void;
+    protected _stateEndTagOpen(cp: number): void;
+    protected _stateTagName(cp: number): void;
+    protected _stateRcdataLessThanSign(cp: number): void;
+    protected _stateRcdataEndTagOpen(cp: number): void;
+    protected handleSpecialEndTag(_cp: number): boolean;
+    protected _stateRcdataEndTagName(cp: number): void;
+    protected _stateRawtextLessThanSign(cp: number): void;
+    protected _stateRawtextEndTagOpen(cp: number): void;
+    protected _stateRawtextEndTagName(cp: number): void;
+    protected _stateScriptDataLessThanSign(cp: number): void;
+    protected _stateScriptDataEndTagOpen(cp: number): void;
+    protected _stateScriptDataEndTagName(cp: number): void;
+    protected _stateScriptDataEscapeStart(cp: number): void;
+    protected _stateScriptDataEscapeStartDash(cp: number): void;
+    protected _stateScriptDataEscaped(cp: number): void;
+    protected _stateScriptDataEscapedDash(cp: number): void;
+    protected _stateScriptDataEscapedDashDash(cp: number): void;
+    protected _stateScriptDataEscapedLessThanSign(cp: number): void;
+    protected _stateScriptDataEscapedEndTagOpen(cp: number): void;
+    protected _stateScriptDataEscapedEndTagName(cp: number): void;
+    protected _stateScriptDataDoubleEscapeStart(cp: number): void;
+    protected _stateScriptDataDoubleEscaped(cp: number): void;
+    protected _stateScriptDataDoubleEscapedDash(cp: number): void;
+    protected _stateScriptDataDoubleEscapedDashDash(cp: number): void;
+    protected _stateScriptDataDoubleEscapedLessThanSign(cp: number): void;
+    protected _stateScriptDataDoubleEscapeEnd(cp: number): void;
+    protected _stateBeforeAttributeName(cp: number): void;
+    protected _stateAttributeName(cp: number): void;
+    protected _stateAfterAttributeName(cp: number): void;
+    protected _stateBeforeAttributeValue(cp: number): void;
+    protected _stateAttributeValueDoubleQuoted(cp: number): void;
+    protected _stateAttributeValueSingleQuoted(cp: number): void;
+    protected _stateAttributeValueUnquoted(cp: number): void;
+    protected _stateAfterAttributeValueQuoted(cp: number): void;
+    protected _stateSelfClosingStartTag(cp: number): void;
+    protected _stateBogusComment(cp: number): void;
+    protected _stateMarkupDeclarationOpen(cp: number): void;
+    protected _stateCommentStart(cp: number): void;
+    protected _stateCommentStartDash(cp: number): void;
+    protected _stateComment(cp: number): void;
+    protected _stateCommentLessThanSign(cp: number): void;
+    protected _stateCommentLessThanSignBang(cp: number): void;
+    protected _stateCommentLessThanSignBangDash(cp: number): void;
+    protected _stateCommentLessThanSignBangDashDash(cp: number): void;
+    protected _stateCommentEndDash(cp: number): void;
+    protected _stateCommentEnd(cp: number): void;
+    protected _stateCommentEndBang(cp: number): void;
+    protected _stateDoctype(cp: number): void;
+    protected _stateBeforeDoctypeName(cp: number): void;
+    protected _stateDoctypeName(cp: number): void;
+    protected _stateAfterDoctypeName(cp: number): void;
+    protected _stateAfterDoctypePublicKeyword(cp: number): void;
+    protected _stateBeforeDoctypePublicIdentifier(cp: number): void;
+    protected _stateDoctypePublicIdentifierDoubleQuoted(cp: number): void;
+    protected _stateDoctypePublicIdentifierSingleQuoted(cp: number): void;
+    protected _stateAfterDoctypePublicIdentifier(cp: number): void;
+    protected _stateBetweenDoctypePublicAndSystemIdentifiers(cp: number): void;
+    protected _stateAfterDoctypeSystemKeyword(cp: number): void;
+    protected _stateBeforeDoctypeSystemIdentifier(cp: number): void;
+    protected _stateDoctypeSystemIdentifierDoubleQuoted(cp: number): void;
+    protected _stateDoctypeSystemIdentifierSingleQuoted(cp: number): void;
+    protected _stateAfterDoctypeSystemIdentifier(cp: number): void;
+    protected _stateBogusDoctype(cp: number): void;
+    protected _stateCdataSection(cp: number): void;
+    protected _stateCdataSectionBracket(cp: number): void;
+    protected _stateCdataSectionEnd(cp: number): void;
+    protected _stateCharacterReference(): void;
+    protected _stateAmbiguousAmpersand(cp: number): void;
 }
 export {};
-//# sourceMappingURL=index.d.ts.map