Class PlainTextConversionStream<T>

parser

document

• get document(): T["document"]

  The resulting document node.

  Returns T["document"]

_write

• _write(chunk: string, _encoding: string, callback: () => void): void

  Parameters

  • chunk: string
  • _encoding: string
  • callback: () => void

  Returns void

end

• end(chunk?: any, encoding?: any, callback?: any): any

  Calling the writable.end() method signals that no more data will be written to the Writable. The optional chunk and encoding arguments allow one final additional chunk of data to be written immediately before closing the stream.

  Calling the write method after calling end will raise an error.

  // Write 'hello, ' and then end with 'world!'.
  import fs from 'node:fs';
  const file = fs.createWriteStream('example.txt');
  file.write('hello, ');
  file.end('world!');
  // Writing more now is not allowed!
  Copy

  Parameters

  • Optionalchunk: any

    Optional data to write. For streams not operating in object mode, chunk must be a {string}, {Buffer}, {TypedArray} or {DataView}. For object mode streams, chunk may be any JavaScript value other than null.

  • Optionalencoding: any

    The encoding if chunk is a string

  • Optionalcallback: any

    Callback for when the stream is finished.

  Returns any

  Since

  v0.9.4

getFragment

• getFragment(): T["documentFragment"]

  Returns T["documentFragment"]

on

• on(
      event: "script",
      handler: (
          scriptElement: T["element"],
          documentWrite: (html: string) => void,
          resume: () => void,
      ) => void,
  ): void

  Raised when parser encounters a <script> element. If this event has listeners, parsing will be suspended once it is emitted. So, if <script> has the src attribute, you can fetch it, execute and then resume parsing just like browsers do.

  Parameters

  • event: "script"

    Name of the event

  • handler: (
        scriptElement: T["element"],
        documentWrite: (html: string) => void,
        resume: () => void,
    ) => void

  Returns void

  Example

  const ParserStream = require('parse5-parser-stream');
  const http = require('http');
  
  const parser = new ParserStream();
  
  parser.on('script', (scriptElement, documentWrite, resume) => {
      const src = scriptElement.attrs.find(({ name }) => name === 'src').value;
  
      http.get(src, res => {
          // Fetch the script content, execute it with DOM built around `parser.document` and
          // `document.write` implemented using `documentWrite`.
          ...
          // Then resume parsing.
          resume();
      });
  });
  
  parser.end('<script src="example.com/script.js"></script>');
  Copy

• on(event: string, handler: (...args: any[]) => void): this

  Base event handler.

  Parameters

  • event: string

    Name of the event

  • handler: (...args: any[]) => void

    Event handler

  Returns this

StaticgetFragmentStream

• getFragmentStream<
      T extends
          TreeAdapterTypeMap<
              unknown,
              unknown,
              unknown,
              unknown,
              unknown,
              unknown,
              unknown,
              unknown,
              unknown,
              unknown,
          >,
  >(
      fragmentContext?: T["parentNode"] | null,
      options?: ParserOptions<T>,
  ): ParserStream<T>

  Type Parameters

  • T extends TreeAdapterTypeMap<
        unknown,
        unknown,
        unknown,
        unknown,
        unknown,
        unknown,
        unknown,
        unknown,
        unknown,
        unknown,
    >

  Parameters

  • OptionalfragmentContext: T["parentNode"] | null
  • Optionaloptions: ParserOptions<T>

  Returns ParserStream<T>