@ryanyahya/opendoc 0.4.0

package/node_modules/parse5/dist/tree-adapters/interface.d.ts

@@ -0,0 +1,255 @@
+import type { DOCUMENT_MODE, NS } from '../common/html.js';
+import type { Attribute, ElementLocation } from '../common/token.js';
+export interface TreeAdapterTypeMap<Node = unknown, ParentNode = unknown, ChildNode = unknown, Document = unknown, DocumentFragment = unknown, Element = unknown, CommentNode = unknown, TextNode = unknown, Template = unknown, DocumentType = unknown> {
+    node: Node;
+    parentNode: ParentNode;
+    childNode: ChildNode;
+    document: Document;
+    documentFragment: DocumentFragment;
+    element: Element;
+    commentNode: CommentNode;
+    textNode: TextNode;
+    template: Template;
+    documentType: DocumentType;
+}
+/**
+ * Tree adapter is a set of utility functions that provides minimal required abstraction layer beetween parser and a specific AST format.
+ * Note that `TreeAdapter` is not designed to be a general purpose AST manipulation library. You can build such library
+ * on top of existing `TreeAdapter` or use one of the existing libraries from npm.
+ *
+ * @see Have a look at the default tree adapter for reference.
+ */
+export interface TreeAdapter<T extends TreeAdapterTypeMap = TreeAdapterTypeMap> {
+    /**
+     * Copies attributes to the given element. Only attributes that are not yet present in the element are copied.
+     *
+     * @param recipient - Element to copy attributes into.
+     * @param attrs - Attributes to copy.
+     */
+    adoptAttributes(recipient: T['element'], attrs: Attribute[]): void;
+    /**
+     * Appends a child node to the given parent node.
+     *
+     * @param parentNode - Parent node.
+     * @param newNode -  Child node.
+     */
+    appendChild(parentNode: T['parentNode'], newNode: T['childNode']): void;
+    /**
+     * Creates a comment node.
+     *
+     * @param data - Comment text.
+     */
+    createCommentNode(data: string): T['commentNode'];
+    /**
+     * Creates a text node.
+     *
+     * @param value - Text.
+     */
+    createTextNode(value: string): T['textNode'];
+    /**
+     * Creates a document node.
+     */
+    createDocument(): T['document'];
+    /**
+     * Creates a document fragment node.
+     */
+    createDocumentFragment(): T['documentFragment'];
+    /**
+     * Creates an element node.
+     *
+     * @param tagName - Tag name of the element.
+     * @param namespaceURI - Namespace of the element.
+     * @param attrs - Attribute name-value pair array. Foreign attributes may contain `namespace` and `prefix` fields as well.
+     */
+    createElement(tagName: string, namespaceURI: NS, attrs: Attribute[]): T['element'];
+    /**
+     * Removes a node from its parent.
+     *
+     * @param node - Node to remove.
+     */
+    detachNode(node: T['childNode']): void;
+    /**
+     * Returns the given element's attributes in an array, in the form of name-value pairs.
+     * Foreign attributes may contain `namespace` and `prefix` fields as well.
+     *
+     * @param element - Element.
+     */
+    getAttrList(element: T['element']): Attribute[];
+    /**
+     * Returns the given node's children in an array.
+     *
+     * @param node - Node.
+     */
+    getChildNodes(node: T['parentNode']): T['childNode'][];
+    /**
+     * Returns the given comment node's content.
+     *
+     * @param commentNode - Comment node.
+     */
+    getCommentNodeContent(commentNode: T['commentNode']): string;
+    /**
+     * Returns [document mode](https://dom.spec.whatwg.org/#concept-document-limited-quirks).
+     *
+     * @param document - Document node.
+     */
+    getDocumentMode(document: T['document']): DOCUMENT_MODE;
+    /**
+     * Returns the given document type node's name.
+     *
+     * @param doctypeNode - Document type node.
+     */
+    getDocumentTypeNodeName(doctypeNode: T['documentType']): string;
+    /**
+     * Returns the given document type node's public identifier.
+     *
+     * @param doctypeNode - Document type node.
+     */
+    getDocumentTypeNodePublicId(doctypeNode: T['documentType']): string;
+    /**
+     * Returns the given document type node's system identifier.
+     *
+     * @param doctypeNode - Document type node.
+     */
+    getDocumentTypeNodeSystemId(doctypeNode: T['documentType']): string;
+    /**
+     * Returns the first child of the given node.
+     *
+     * @param node - Node.
+     */
+    getFirstChild(node: T['parentNode']): T['childNode'] | null;
+    /**
+     * Returns the given element's namespace.
+     *
+     * @param element - Element.
+     */
+    getNamespaceURI(element: T['element']): NS;
+    /**
+     * Returns the given node's source code location information.
+     *
+     * @param node - Node.
+     */
+    getNodeSourceCodeLocation(node: T['node']): ElementLocation | undefined | null;
+    /**
+     * Returns the given node's parent.
+     *
+     * @param node - Node.
+     */
+    getParentNode(node: T['node']): T['parentNode'] | null;
+    /**
+     * Returns the given element's tag name.
+     *
+     * @param element - Element.
+     */
+    getTagName(element: T['element']): string;
+    /**
+     * Returns the given text node's content.
+     *
+     * @param textNode - Text node.
+     */
+    getTextNodeContent(textNode: T['textNode']): string;
+    /**
+     * Returns the `<template>` element content element.
+     *
+     * @param templateElement - `<template>` element.
+     */
+    getTemplateContent(templateElement: T['template']): T['documentFragment'];
+    /**
+     * Inserts a child node to the given parent node before the given reference node.
+     *
+     * @param parentNode - Parent node.
+     * @param newNode -  Child node.
+     * @param referenceNode -  Reference node.
+     */
+    insertBefore(parentNode: T['parentNode'], newNode: T['childNode'], referenceNode: T['childNode']): void;
+    /**
+     * Inserts text into a node. If the last child of the node is a text node, the provided text will be appended to the
+     * text node content. Otherwise, inserts a new text node with the given text.
+     *
+     * @param parentNode - Node to insert text into.
+     * @param text - Text to insert.
+     */
+    insertText(parentNode: T['parentNode'], text: string): void;
+    /**
+     * Inserts text into a sibling node that goes before the reference node. If this sibling node is the text node,
+     * the provided text will be appended to the text node content. Otherwise, inserts a new sibling text node with
+     * the given text before the reference node.
+     *
+     * @param parentNode - Node to insert text into.
+     * @param text - Text to insert.
+     * @param referenceNode - Node to insert text before.
+     */
+    insertTextBefore(parentNode: T['parentNode'], text: string, referenceNode: T['childNode']): void;
+    /**
+     * Determines if the given node is a comment node.
+     *
+     * @param node - Node.
+     */
+    isCommentNode(node: T['node']): node is T['commentNode'];
+    /**
+     * Determines if the given node is a document type node.
+     *
+     * @param node - Node.
+     */
+    isDocumentTypeNode(node: T['node']): node is T['documentType'];
+    /**
+     * Determines if the given node is an element.
+     *
+     * @param node - Node.
+     */
+    isElementNode(node: T['node']): node is T['element'];
+    /**
+     * Determines if the given node is a text node.
+     *
+     * @param node - Node.
+     */
+    isTextNode(node: T['node']): node is T['textNode'];
+    /**
+     * Sets the [document mode](https://dom.spec.whatwg.org/#concept-document-limited-quirks).
+     *
+     * @param document - Document node.
+     * @param mode - Document mode.
+     */
+    setDocumentMode(document: T['document'], mode: DOCUMENT_MODE): void;
+    /**
+     * Sets the document type. If the `document` already contains a document type node, the `name`, `publicId` and `systemId`
+     * properties of this node will be updated with the provided values. Otherwise, creates a new document type node
+     * with the given properties and inserts it into the `document`.
+     *
+     * @param document - Document node.
+     * @param name -  Document type name.
+     * @param publicId - Document type public identifier.
+     * @param systemId - Document type system identifier.
+     */
+    setDocumentType(document: T['document'], name: string, publicId: string, systemId: string): void;
+    /**
+     * Attaches source code location information to the node.
+     *
+     * @param node - Node.
+     */
+    setNodeSourceCodeLocation(node: T['node'], location: ElementLocation | null): void;
+    /**
+     * Updates the source code location information of the node.
+     *
+     * @param node - Node.
+     */
+    updateNodeSourceCodeLocation(node: T['node'], location: Partial<ElementLocation>): void;
+    /**
+     * Sets the `<template>` element content element.
+     *
+     * @param templateElement - `<template>` element.
+     * @param contentElement -  Content element.
+     */
+    setTemplateContent(templateElement: T['template'], contentElement: T['documentFragment']): void;
+    /**
+     * Optional callback for elements being pushed to the stack of open elements.
+     *
+     * @param element The element being pushed to the stack of open elements.
+     */
+    onItemPush?: (item: T['element']) => void;
+    /**
+     * Optional callback for elements being popped from the stack of open elements.
+     *
+     * @param item The element being popped.
+     */
+    onItemPop?: (item: T['element'], newTop: T['parentNode']) => void;
+}

package/node_modules/parse5/dist/tree-adapters/interface.js

@@ -0,0 +1 @@
+export {};

package/node_modules/parse5/package.json

@@ -0,0 +1,50 @@
+{
+    "name": "parse5",
+    "type": "module",
+    "description": "HTML parser and serializer.",
+    "version": "7.3.0",
+    "author": "Ivan Nikulin <ifaaan@gmail.com> (https://github.com/inikulin)",
+    "contributors": "https://github.com/inikulin/parse5/graphs/contributors",
+    "homepage": "https://parse5.js.org",
+    "funding": "https://github.com/inikulin/parse5?sponsor=1",
+    "dependencies": {
+        "entities": "^6.0.0"
+    },
+    "keywords": [
+        "html",
+        "parser",
+        "html5",
+        "WHATWG",
+        "specification",
+        "fast",
+        "html parser",
+        "html5 parser",
+        "htmlparser",
+        "parse5",
+        "serializer",
+        "html serializer",
+        "htmlserializer",
+        "parse",
+        "serialize"
+    ],
+    "license": "MIT",
+    "main": "dist/cjs/index.js",
+    "module": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "exports": {
+        "import": "./dist/index.js",
+        "require": "./dist/cjs/index.js"
+    },
+    "scripts": {
+        "build:cjs": "tsc --noCheck --moduleResolution node10 --module CommonJS --target ES6 --outDir dist/cjs && echo '{\"type\":\"commonjs\"}' > dist/cjs/package.json"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git://github.com/inikulin/parse5.git"
+    },
+    "files": [
+        "dist/cjs/package.json",
+        "dist/**/*.js",
+        "dist/**/*.d.ts"
+    ]
+}

package/node_modules/undici-types/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Matteo Collina and Undici contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/undici-types/README.md

@@ -0,0 +1,6 @@
+# undici-types
+
+This package is a dual-publish of the [undici](https://www.npmjs.com/package/undici) library types. The `undici` package **still contains types**. This package is for users who _only_ need undici types (such as for `@types/node`). It is published alongside every release of `undici`, so you can always use the same version.
+
+- [GitHub nodejs/undici](https://github.com/nodejs/undici)
+- [Undici Documentation](https://undici.nodejs.org/#/)

package/node_modules/undici-types/agent.d.ts

@@ -0,0 +1,31 @@
+import { URL } from 'url'
+import Pool from './pool'
+import Dispatcher from "./dispatcher";
+
+export default Agent
+
+declare class Agent extends Dispatcher{
+  constructor(opts?: Agent.Options)
+  /** `true` after `dispatcher.close()` has been called. */
+  closed: boolean;
+  /** `true` after `dispatcher.destroyed()` has been called or `dispatcher.close()` has been called and the dispatcher shutdown has completed. */
+  destroyed: boolean;
+  /** Dispatches a request. */
+  dispatch(options: Agent.DispatchOptions, handler: Dispatcher.DispatchHandlers): boolean;
+}
+
+declare namespace Agent {
+  export interface Options extends Pool.Options {
+    /** Default: `(origin, opts) => new Pool(origin, opts)`. */
+    factory?(origin: string | URL, opts: Object): Dispatcher;
+    /** Integer. Default: `0` */
+    maxRedirections?: number;
+
+    interceptors?: { Agent?: readonly Dispatcher.DispatchInterceptor[] } & Pool.Options["interceptors"]
+  }
+
+  export interface DispatchOptions extends Dispatcher.DispatchOptions {
+    /** Integer. */
+    maxRedirections?: number;
+  }
+}

package/node_modules/undici-types/api.d.ts

@@ -0,0 +1,43 @@
+import { URL, UrlObject } from 'url'
+import { Duplex } from 'stream'
+import Dispatcher from './dispatcher'
+
+export {
+  request,
+  stream,
+  pipeline,
+  connect,
+  upgrade,
+}
+
+/** Performs an HTTP request. */
+declare function request(
+  url: string | URL | UrlObject,
+  options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.RequestOptions, 'origin' | 'path' | 'method'> & Partial<Pick<Dispatcher.RequestOptions, 'method'>>,
+): Promise<Dispatcher.ResponseData>;
+
+/** A faster version of `request`. */
+declare function stream(
+  url: string | URL | UrlObject,
+  options: { dispatcher?: Dispatcher } & Omit<Dispatcher.RequestOptions, 'origin' | 'path'>,
+  factory: Dispatcher.StreamFactory
+): Promise<Dispatcher.StreamData>;
+
+/** For easy use with `stream.pipeline`. */
+declare function pipeline(
+  url: string | URL | UrlObject,
+  options: { dispatcher?: Dispatcher } & Omit<Dispatcher.PipelineOptions, 'origin' | 'path'>,
+  handler: Dispatcher.PipelineHandler
+): Duplex;
+
+/** Starts two-way communications with the requested resource. */
+declare function connect(
+  url: string | URL | UrlObject,
+  options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.ConnectOptions, 'origin' | 'path'>
+): Promise<Dispatcher.ConnectData>;
+
+/** Upgrade to a different protocol. */
+declare function upgrade(
+  url: string | URL | UrlObject,
+  options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.UpgradeOptions, 'origin' | 'path'>
+): Promise<Dispatcher.UpgradeData>;

package/node_modules/undici-types/balanced-pool.d.ts

@@ -0,0 +1,29 @@
+import Pool from './pool'
+import Dispatcher from './dispatcher'
+import { URL } from 'url'
+
+export default BalancedPool
+
+type BalancedPoolConnectOptions = Omit<Dispatcher.ConnectOptions, "origin">;
+
+declare class BalancedPool extends Dispatcher {
+  constructor(url: string | string[] | URL | URL[], options?: Pool.Options);
+
+  addUpstream(upstream: string | URL): BalancedPool;
+  removeUpstream(upstream: string | URL): BalancedPool;
+  upstreams: Array<string>;
+
+  /** `true` after `pool.close()` has been called. */
+  closed: boolean;
+  /** `true` after `pool.destroyed()` has been called or `pool.close()` has been called and the pool shutdown has completed. */
+  destroyed: boolean;
+
+  // Override dispatcher APIs.
+  override connect(
+    options: BalancedPoolConnectOptions
+  ): Promise<Dispatcher.ConnectData>;
+  override connect(
+    options: BalancedPoolConnectOptions,
+    callback: (err: Error | null, data: Dispatcher.ConnectData) => void
+  ): void;
+}

package/node_modules/undici-types/cache.d.ts

@@ -0,0 +1,36 @@
+import type { RequestInfo, Response, Request } from './fetch'
+
+export interface CacheStorage {
+  match (request: RequestInfo, options?: MultiCacheQueryOptions): Promise<Response | undefined>,
+  has (cacheName: string): Promise<boolean>,
+  open (cacheName: string): Promise<Cache>,
+  delete (cacheName: string): Promise<boolean>,
+  keys (): Promise<string[]>
+}
+
+declare const CacheStorage: {
+  prototype: CacheStorage
+  new(): CacheStorage
+}
+
+export interface Cache {
+  match (request: RequestInfo, options?: CacheQueryOptions): Promise<Response | undefined>,
+  matchAll (request?: RequestInfo, options?: CacheQueryOptions): Promise<readonly Response[]>,
+  add (request: RequestInfo): Promise<undefined>,
+  addAll (requests: RequestInfo[]): Promise<undefined>,
+  put (request: RequestInfo, response: Response): Promise<undefined>,
+  delete (request: RequestInfo, options?: CacheQueryOptions): Promise<boolean>,
+  keys (request?: RequestInfo, options?: CacheQueryOptions): Promise<readonly Request[]>
+}
+
+export interface CacheQueryOptions {
+  ignoreSearch?: boolean,
+  ignoreMethod?: boolean,
+  ignoreVary?: boolean
+}
+
+export interface MultiCacheQueryOptions extends CacheQueryOptions {
+  cacheName?: string
+}
+
+export declare const caches: CacheStorage

package/node_modules/undici-types/client.d.ts

@@ -0,0 +1,108 @@
+import { URL } from 'url'
+import { TlsOptions } from 'tls'
+import Dispatcher from './dispatcher'
+import buildConnector from "./connector";
+
+type ClientConnectOptions = Omit<Dispatcher.ConnectOptions, "origin">;
+
+/**
+ * A basic HTTP/1.1 client, mapped on top a single TCP/TLS connection. Pipelining is disabled by default.
+ */
+export class Client extends Dispatcher {
+  constructor(url: string | URL, options?: Client.Options);
+  /** Property to get and set the pipelining factor. */
+  pipelining: number;
+  /** `true` after `client.close()` has been called. */
+  closed: boolean;
+  /** `true` after `client.destroyed()` has been called or `client.close()` has been called and the client shutdown has completed. */
+  destroyed: boolean;
+
+  // Override dispatcher APIs.
+  override connect(
+    options: ClientConnectOptions
+  ): Promise<Dispatcher.ConnectData>;
+  override connect(
+    options: ClientConnectOptions,
+    callback: (err: Error | null, data: Dispatcher.ConnectData) => void
+  ): void;
+}
+
+export declare namespace Client {
+  export interface OptionsInterceptors {
+    Client: readonly Dispatcher.DispatchInterceptor[];
+  }
+  export interface Options {
+    /** TODO */
+    interceptors?: OptionsInterceptors;
+    /** The maximum length of request headers in bytes. Default: Node.js' `--max-http-header-size` or `16384` (16KiB). */
+    maxHeaderSize?: number;
+    /** The amount of time, in milliseconds, the parser will wait to receive the complete HTTP headers (Node 14 and above only). Default: `300e3` milliseconds (300s). */
+    headersTimeout?: number;
+    /** @deprecated unsupported socketTimeout, use headersTimeout & bodyTimeout instead */
+    socketTimeout?: never;
+    /** @deprecated unsupported requestTimeout, use headersTimeout & bodyTimeout instead */
+    requestTimeout?: never;
+    /** TODO */
+    connectTimeout?: number;
+    /** The timeout after which a request will time out, in milliseconds. Monitors time between receiving body data. Use `0` to disable it entirely. Default: `300e3` milliseconds (300s). */
+    bodyTimeout?: number;
+    /** @deprecated unsupported idleTimeout, use keepAliveTimeout instead */
+    idleTimeout?: never;
+    /** @deprecated unsupported keepAlive, use pipelining=0 instead */
+    keepAlive?: never;
+    /** the timeout, in milliseconds, after which a socket without active requests will time out. Monitors time between activity on a connected socket. This value may be overridden by *keep-alive* hints from the server. Default: `4e3` milliseconds (4s). */
+    keepAliveTimeout?: number;
+    /** @deprecated unsupported maxKeepAliveTimeout, use keepAliveMaxTimeout instead */
+    maxKeepAliveTimeout?: never;
+    /** the maximum allowed `idleTimeout`, in milliseconds, when overridden by *keep-alive* hints from the server. Default: `600e3` milliseconds (10min). */
+    keepAliveMaxTimeout?: number;
+    /** A number of milliseconds subtracted from server *keep-alive* hints when overriding `idleTimeout` to account for timing inaccuracies caused by e.g. transport latency. Default: `1e3` milliseconds (1s). */
+    keepAliveTimeoutThreshold?: number;
+    /** TODO */
+    socketPath?: string;
+    /** The amount of concurrent requests to be sent over the single TCP/TLS connection according to [RFC7230](https://tools.ietf.org/html/rfc7230#section-6.3.2). Default: `1`. */
+    pipelining?: number;
+    /** @deprecated use the connect option instead */
+    tls?: never;
+    /** If `true`, an error is thrown when the request content-length header doesn't match the length of the request body. Default: `true`. */
+    strictContentLength?: boolean;
+    /** TODO */
+    maxCachedSessions?: number;
+    /** TODO */
+    maxRedirections?: number;
+    /** TODO */
+    connect?: buildConnector.BuildOptions | buildConnector.connector;
+    /** TODO */
+    maxRequestsPerClient?: number;
+    /** TODO */
+    localAddress?: string;
+    /** Max response body size in bytes, -1 is disabled */
+    maxResponseSize?: number;
+    /** Enables a family autodetection algorithm that loosely implements section 5 of RFC 8305. */
+    autoSelectFamily?: boolean;
+    /** The amount of time in milliseconds to wait for a connection attempt to finish before trying the next address when using the `autoSelectFamily` option. */
+    autoSelectFamilyAttemptTimeout?: number;
+    /**
+     * @description Enables support for H2 if the server has assigned bigger priority to it through ALPN negotiation.
+     * @default false
+    */
+    allowH2?: boolean;
+    /**
+     * @description Dictates the maximum number of concurrent streams for a single H2 session. It can be overridden by a SETTINGS remote frame.
+     * @default 100
+    */
+    maxConcurrentStreams?: number
+  }
+  export interface SocketInfo {
+    localAddress?: string
+    localPort?: number
+    remoteAddress?: string
+    remotePort?: number
+    remoteFamily?: string
+    timeout?: number
+    bytesWritten?: number
+    bytesRead?: number
+  }
+}
+
+export default Client;

package/node_modules/undici-types/connector.d.ts

@@ -0,0 +1,34 @@
+import { TLSSocket, ConnectionOptions } from 'tls'
+import { IpcNetConnectOpts, Socket, TcpNetConnectOpts } from 'net'
+
+export default buildConnector
+declare function buildConnector (options?: buildConnector.BuildOptions): buildConnector.connector
+
+declare namespace buildConnector {
+  export type BuildOptions = (ConnectionOptions | TcpNetConnectOpts | IpcNetConnectOpts) & {
+    allowH2?: boolean;
+    maxCachedSessions?: number | null;
+    socketPath?: string | null;
+    timeout?: number | null;
+    port?: number;
+    keepAlive?: boolean | null;
+    keepAliveInitialDelay?: number | null;
+  }
+
+  export interface Options {
+    hostname: string
+    host?: string
+    protocol: string
+    port: string
+    servername?: string
+    localAddress?: string | null
+    httpSocket?: Socket
+  }
+
+  export type Callback = (...args: CallbackArgs) => void
+  type CallbackArgs = [null, Socket | TLSSocket] | [Error, null]
+
+  export interface connector {
+    (options: buildConnector.Options, callback: buildConnector.Callback): void
+  }
+}

package/node_modules/undici-types/content-type.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+
+interface MIMEType {
+  type: string
+  subtype: string
+  parameters: Map<string, string>
+  essence: string
+}
+
+/**
+ * Parse a string to a {@link MIMEType} object. Returns `failure` if the string
+ * couldn't be parsed.
+ * @see https://mimesniff.spec.whatwg.org/#parse-a-mime-type
+ */
+export function parseMIMEType (input: string): 'failure' | MIMEType
+
+/**
+ * Convert a MIMEType object to a string.
+ * @see https://mimesniff.spec.whatwg.org/#serialize-a-mime-type
+ */
+export function serializeAMimeType (mimeType: MIMEType): string

package/node_modules/undici-types/cookies.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="node" />
+
+import type { Headers } from './fetch'
+
+export interface Cookie {
+  name: string
+  value: string
+  expires?: Date | number
+  maxAge?: number
+  domain?: string
+  path?: string
+  secure?: boolean
+  httpOnly?: boolean
+  sameSite?: 'Strict' | 'Lax' | 'None'
+  unparsed?: string[]
+}
+
+export function deleteCookie (
+  headers: Headers,
+  name: string,
+  attributes?: { name?: string, domain?: string }
+): void
+
+export function getCookies (headers: Headers): Record<string, string>
+
+export function getSetCookies (headers: Headers): Cookie[]
+
+export function setCookie (headers: Headers, cookie: Cookie): void