diff --git a/dist/account.d.ts b/dist/account.d.ts
new file mode 100644
index 0000000..be072af
--- /dev/null
+++ b/dist/account.d.ts
@@ -0,0 +1,28 @@
+import 'cross-fetch/polyfill';
+import { DAVAccount } from './types/models';
+export declare const serviceDiscovery: (params: {
+    account: DAVAccount;
+    headers?: Record<string, string>;
+    headersToExclude?: string[];
+    fetchOptions?: RequestInit;
+}) => Promise<string>;
+export declare const fetchPrincipalUrl: (params: {
+    account: DAVAccount;
+    headers?: Record<string, string>;
+    headersToExclude?: string[];
+    fetchOptions?: RequestInit;
+}) => Promise<string>;
+export declare const fetchHomeUrl: (params: {
+    account: DAVAccount;
+    headers?: Record<string, string>;
+    headersToExclude?: string[];
+    fetchOptions?: RequestInit;
+}) => Promise<string>;
+export declare const createAccount: (params: {
+    account: DAVAccount;
+    headers?: Record<string, string>;
+    headersToExclude?: string[];
+    loadCollections?: boolean;
+    loadObjects?: boolean;
+    fetchOptions?: RequestInit;
+}) => Promise<DAVAccount>;
diff --git a/dist/addressBook.d.ts b/dist/addressBook.d.ts
new file mode 100644
index 0000000..b99fcb1
--- /dev/null
+++ b/dist/addressBook.d.ts
@@ -0,0 +1,57 @@
+import { ElementCompact } from 'xml-js';
+import { DAVDepth, DAVResponse } from './types/DAVTypes';
+import { DAVAccount, DAVAddressBook, DAVVCard } from './types/models';
+export declare const addressBookQuery: (params: {
+    url: string;
+    props: ElementCompact;
+    filters?: ElementCompact;
+    depth?: DAVDepth;
+    headers?: Record<string, string>;
+    headersToExclude?: string[];
+    fetchOptions?: RequestInit;
+}) => Promise<DAVResponse[]>;
+export declare const addressBookMultiGet: (params: {
+    url: string;
+    props: ElementCompact;
+    objectUrls: string[];
+    depth: DAVDepth;
+    headers?: Record<string, string>;
+    headersToExclude?: string[];
+    fetchOptions?: RequestInit;
+}) => Promise<DAVResponse[]>;
+export declare const fetchAddressBooks: (params?: {
+    account?: DAVAccount;
+    props?: ElementCompact;
+    headers?: Record<string, string>;
+    headersToExclude?: string[];
+    fetchOptions?: RequestInit;
+}) => Promise<DAVAddressBook[]>;
+export declare const fetchVCards: (params: {
+    addressBook: DAVAddressBook;
+    headers?: Record<string, string>;
+    objectUrls?: string[];
+    urlFilter?: (url: string) => boolean;
+    useMultiGet?: boolean;
+    headersToExclude?: string[];
+    fetchOptions?: RequestInit;
+}) => Promise<DAVVCard[]>;
+export declare const createVCard: (params: {
+    addressBook: DAVAddressBook;
+    vCardString: string;
+    filename: string;
+    headers?: Record<string, string>;
+    headersToExclude?: string[];
+    fetchOptions?: RequestInit;
+}) => Promise<Response>;
+export declare const updateVCard: (params: {
+    vCard: DAVVCard;
+    headers?: Record<string, string>;
+    headersToExclude?: string[];
+    fetchOptions?: RequestInit;
+}) => Promise<Response>;
+export declare const deleteVCard: (params: {
+    vCard: DAVVCard;
+    headers?: Record<string, string>;
+    headersToExclude?: string[];
+    fetchOptions?: RequestInit;
+}) => Promise<Response>;
diff --git a/dist/calendar.d.ts b/dist/calendar.d.ts
new file mode 100644
index 0000000..0a7986f
--- /dev/null
+++ b/dist/calendar.d.ts
@@ -0,0 +1,97 @@
+import { ElementCompact } from 'xml-js';
+import { DAVDepth, DAVResponse } from './types/DAVTypes';
+import { SyncCalendars } from './types/functionsOverloads';
+import { DAVAccount, DAVCalendar, DAVCalendarObject } from './types/models';
+export declare const fetchCalendarUserAddresses: (params: {
+    account: DAVAccount;
+    headers?: Record<string, string>;
+    headersToExclude?: string[];
+    fetchOptions?: RequestInit;
+}) => Promise<string[]>;
+export declare const calendarQuery: (params: {
+    url: string;
+    props: ElementCompact;
+    filters?: ElementCompact;
+    timezone?: string;
+    depth?: DAVDepth;
+    headers?: Record<string, string>;
+    headersToExclude?: string[];
+    fetchOptions?: RequestInit;
+}) => Promise<DAVResponse[]>;
+export declare const calendarMultiGet: (params: {
+    url: string;
+    props: ElementCompact;
+    objectUrls?: string[];
+    timezone?: string;
+    depth: DAVDepth;
+    filters?: ElementCompact;
+    headers?: Record<string, string>;
+    headersToExclude?: string[];
+    fetchOptions?: RequestInit;
+}) => Promise<DAVResponse[]>;
+export declare const makeCalendar: (params: {
+    url: string;
+    props: ElementCompact;
+    depth?: DAVDepth;
+    headers?: Record<string, string>;
+    headersToExclude?: string[];
+    fetchOptions?: RequestInit;
+}) => Promise<DAVResponse[]>;
+export declare const fetchCalendars: (params?: {
+    account?: DAVAccount;
+    props?: ElementCompact;
+    projectedProps?: Record<string, boolean>;
+    headers?: Record<string, string>;
+    headersToExclude?: string[];
+    fetchOptions?: RequestInit;
+}) => Promise<DAVCalendar[]>;
+export declare const fetchCalendarObjects: (params: {
+    calendar: DAVCalendar;
+    objectUrls?: string[];
+    filters?: ElementCompact;
+    timeRange?: {
+        start: string;
+        end: string;
+    };
+    expand?: boolean;
+    urlFilter?: (url: string) => boolean;
+    headers?: Record<string, string>;
+    headersToExclude?: string[];
+    useMultiGet?: boolean;
+    fetchOptions?: RequestInit;
+}) => Promise<DAVCalendarObject[]>;
+export declare const createCalendarObject: (params: {
+    calendar: DAVCalendar;
+    iCalString: string;
+    filename: string;
+    headers?: Record<string, string>;
+    headersToExclude?: string[];
+    fetchOptions?: RequestInit;
+}) => Promise<Response>;
+export declare const updateCalendarObject: (params: {
+    calendarObject: DAVCalendarObject;
+    headers?: Record<string, string>;
+    headersToExclude?: string[];
+    fetchOptions?: RequestInit;
+}) => Promise<Response>;
+export declare const deleteCalendarObject: (params: {
+    calendarObject: DAVCalendarObject;
+    headers?: Record<string, string>;
+    headersToExclude?: string[];
+    fetchOptions?: RequestInit;
+}) => Promise<Response>;
+/**
+ * Sync remote calendars to local
+ */
+export declare const syncCalendars: SyncCalendars;
+export declare const freeBusyQuery: (params: {
+    url: string;
+    timeRange: {
+        start: string;
+        end: string;
+    };
+    depth?: DAVDepth;
+    headers?: Record<string, string>;
+    headersToExclude?: string[];
+    fetchOptions?: RequestInit;
+}) => Promise<DAVResponse>;
diff --git a/dist/client.d.ts b/dist/client.d.ts
new file mode 100644
index 0000000..b8a4e3e
--- /dev/null
+++ b/dist/client.d.ts
@@ -0,0 +1,317 @@
+import { addressBookMultiGet as rawAddressBookMultiGet, addressBookQuery as rawAddressBookQuery, createVCard as rawCreateVCard, deleteVCard as rawDeleteVCard, fetchAddressBooks as rawFetchAddressBooks, fetchVCards as rawFetchVCards, updateVCard as rawUpdateVCard } from './addressBook';
+import { calendarMultiGet as rawCalendarMultiGet, calendarQuery as rawCalendarQuery, createCalendarObject as rawCreateCalendarObject, deleteCalendarObject as rawDeleteCalendarObject, fetchCalendarObjects as rawFetchCalendarObjects, fetchCalendars as rawFetchCalendars, makeCalendar as rawMakeCalendar, updateCalendarObject as rawUpdateCalendarObject, fetchCalendarUserAddresses as rawFetchCalendarUserAddresses } from './calendar';
+import { collectionQuery as rawCollectionQuery, isCollectionDirty as rawIsCollectionDirty, makeCollection as rawMakeCollection, supportedReportSet as rawSupportedReportSet, syncCollection as rawSyncCollection } from './collection';
+import { createObject as rawCreateObject, deleteObject as rawDeleteObject, propfind as rawPropfind, updateObject as rawUpdateObject } from './request';
+import { DAVRequest, DAVResponse } from './types/DAVTypes';
+import { SmartCollectionSync, SyncCalendars } from './types/functionsOverloads';
+import { DAVAccount, DAVAddressBook, DAVCalendar, DAVCalendarObject, DAVCollection, DAVCredentials, DAVObject, DAVVCard } from './types/models';
+import { Optional } from './util/typeHelpers';
+export declare const createDAVClient: (params: {
+    serverUrl: string;
+    credentials: DAVCredentials;
+    authMethod?: "Basic" | "Oauth" | "Digest" | "Custom";
+    authFunction?: (credentials: DAVCredentials) => Promise<Record<string, string>>;
+    defaultAccountType?: DAVAccount["accountType"] | undefined;
+}) => Promise<{
+    davRequest: (params0: {
+        url: string;
+        init: DAVRequest;
+        convertIncoming?: boolean;
+        parseOutgoing?: boolean;
+    }) => Promise<DAVResponse[]>;
+    propfind: (params: {
+        url: string;
+        props: import("xml-js/types").ElementCompact;
+        depth?: import("./types/DAVTypes").DAVDepth;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<DAVResponse[]>;
+    createAccount: (params0: {
+        account: Optional<DAVAccount, "serverUrl">;
+        headers?: Record<string, string>;
+        loadCollections?: boolean;
+        loadObjects?: boolean;
+    }) => Promise<DAVAccount>;
+    createObject: (params: {
+        url: string;
+        data: BodyInit;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<Response>;
+    updateObject: (params: {
+        url: string;
+        data: BodyInit;
+        etag?: string;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<Response>;
+    deleteObject: (params: {
+        url: string;
+        etag?: string;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<Response>;
+    calendarQuery: (params: {
+        url: string;
+        props: import("xml-js/types").ElementCompact;
+        filters?: import("xml-js/types").ElementCompact;
+        timezone?: string;
+        depth?: import("./types/DAVTypes").DAVDepth;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<DAVResponse[]>;
+    addressBookQuery: (params: {
+        url: string;
+        props: import("xml-js/types").ElementCompact;
+        filters?: import("xml-js/types").ElementCompact;
+        depth?: import("./types/DAVTypes").DAVDepth;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<DAVResponse[]>;
+    collectionQuery: (params: {
+        url: string;
+        body: any;
+        depth?: import("./types/DAVTypes").DAVDepth;
+        defaultNamespace?: import("./consts").DAVNamespaceShort;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<DAVResponse[]>;
+    makeCollection: (params: {
+        url: string;
+        props?: import("xml-js/types").ElementCompact;
+        depth?: import("./types/DAVTypes").DAVDepth;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<DAVResponse[]>;
+    calendarMultiGet: (params: {
+        url: string;
+        props: import("xml-js/types").ElementCompact;
+        objectUrls?: string[];
+        timezone?: string;
+        depth: import("./types/DAVTypes").DAVDepth;
+        filters?: import("xml-js/types").ElementCompact;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<DAVResponse[]>;
+    makeCalendar: (params: {
+        url: string;
+        props: import("xml-js/types").ElementCompact;
+        depth?: import("./types/DAVTypes").DAVDepth;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<DAVResponse[]>;
+    syncCollection: (params: {
+        url: string;
+        props: import("xml-js/types").ElementCompact;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        syncLevel?: number;
+        syncToken?: string;
+        fetchOptions?: RequestInit;
+    }) => Promise<DAVResponse[]>;
+    supportedReportSet: (params: {
+        collection: DAVCollection;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<string[]>;
+    isCollectionDirty: (params: {
+        collection: DAVCollection;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<{
+        isDirty: boolean;
+        newCtag: string;
+    }>;
+    smartCollectionSync: SmartCollectionSync;
+    fetchCalendars: (params?: {
+        account?: DAVAccount;
+        props?: import("xml-js/types").ElementCompact;
+        projectedProps?: Record<string, boolean>;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    } | undefined) => Promise<DAVCalendar[]>;
+    fetchCalendarUserAddresses: (params: {
+        account: DAVAccount;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<string[]>;
+    fetchCalendarObjects: (params: {
+        calendar: DAVCalendar;
+        objectUrls?: string[];
+        filters?: import("xml-js/types").ElementCompact;
+        timeRange?: {
+            start: string;
+            end: string;
+        };
+        expand?: boolean;
+        urlFilter?: (url: string) => boolean;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        useMultiGet?: boolean;
+        fetchOptions?: RequestInit;
+    }) => Promise<DAVObject[]>;
+    createCalendarObject: (params: {
+        calendar: DAVCalendar;
+        iCalString: string;
+        filename: string;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<Response>;
+    updateCalendarObject: (params: {
+        calendarObject: DAVCalendarObject;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<Response>;
+    deleteCalendarObject: (params: {
+        calendarObject: DAVCalendarObject;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<Response>;
+    syncCalendars: SyncCalendars;
+    fetchAddressBooks: (params?: {
+        account?: DAVAccount;
+        props?: import("xml-js/types").ElementCompact;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    } | undefined) => Promise<DAVCollection[]>;
+    addressBookMultiGet: (params: {
+        url: string;
+        props: import("xml-js/types").ElementCompact;
+        objectUrls: string[];
+        depth: import("./types/DAVTypes").DAVDepth;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<DAVResponse[]>;
+    fetchVCards: (params: {
+        addressBook: DAVAddressBook;
+        headers?: Record<string, string>;
+        objectUrls?: string[];
+        urlFilter?: (url: string) => boolean;
+        useMultiGet?: boolean;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<DAVObject[]>;
+    createVCard: (params: {
+        addressBook: DAVAddressBook;
+        vCardString: string;
+        filename: string;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<Response>;
+    updateVCard: (params: {
+        vCard: DAVVCard;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<Response>;
+    deleteVCard: (params: {
+        vCard: DAVVCard;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<Response>;
+}>;
+export declare class DAVClient {
+    serverUrl: string;
+    credentials: DAVCredentials;
+    authMethod: 'Basic' | 'Oauth' | 'Digest' | 'Custom';
+    accountType: DAVAccount['accountType'];
+    authHeaders?: Record<string, string>;
+    account?: DAVAccount;
+    fetchOptions?: RequestInit;
+    authFunction?: (credentials: DAVCredentials) => Promise<Record<string, string>>;
+    constructor(params: {
+        serverUrl: string;
+        credentials: DAVCredentials;
+        authMethod?: 'Basic' | 'Oauth' | 'Digest' | 'Custom';
+        authFunction?: (credentials: DAVCredentials) => Promise<Record<string, string>>;
+        defaultAccountType?: DAVAccount['accountType'] | undefined;
+        fetchOptions?: RequestInit;
+    });
+    login(): Promise<void>;
+    davRequest(params0: {
+        url: string;
+        init: DAVRequest;
+        convertIncoming?: boolean;
+        parseOutgoing?: boolean;
+        fetchOptions?: RequestInit;
+    }): Promise<DAVResponse[]>;
+    createObject(...params: Parameters<typeof rawCreateObject>): Promise<Response>;
+    updateObject(...params: Parameters<typeof rawUpdateObject>): Promise<Response>;
+    deleteObject(...params: Parameters<typeof rawDeleteObject>): Promise<Response>;
+    propfind(...params: Parameters<typeof rawPropfind>): Promise<DAVResponse[]>;
+    createAccount(params0: {
+        account: Optional<DAVAccount, 'serverUrl'>;
+        headers?: Record<string, string>;
+        loadCollections?: boolean;
+        loadObjects?: boolean;
+        fetchOptions?: RequestInit;
+    }): Promise<DAVAccount>;
+    collectionQuery(...params: Parameters<typeof rawCollectionQuery>): Promise<DAVResponse[]>;
+    makeCollection(...params: Parameters<typeof rawMakeCollection>): Promise<DAVResponse[]>;
+    syncCollection(...params: Parameters<typeof rawSyncCollection>): Promise<DAVResponse[]>;
+    supportedReportSet(...params: Parameters<typeof rawSupportedReportSet>): Promise<string[]>;
+    isCollectionDirty(...params: Parameters<typeof rawIsCollectionDirty>): Promise<{
+        isDirty: boolean;
+        newCtag: string;
+    }>;
+    smartCollectionSync<T extends DAVCollection>(param: {
+        collection: T;
+        method?: 'basic' | 'webdav';
+        headers?: Record<string, string>;
+        fetchOptions?: RequestInit;
+        account?: DAVAccount;
+        detailedResult?: false;
+    }): Promise<T>;
+    smartCollectionSync<T extends DAVCollection>(param: {
+        collection: T;
+        method?: 'basic' | 'webdav';
+        headers?: Record<string, string>;
+        fetchOptions?: RequestInit;
+        account?: DAVAccount;
+        detailedResult: true;
+    }): Promise<Omit<T, 'objects'> & {
+        objects: {
+            created: DAVObject[];
+            updated: DAVObject[];
+            deleted: DAVObject[];
+        };
+    }>;
+    calendarQuery(...params: Parameters<typeof rawCalendarQuery>): Promise<DAVResponse[]>;
+    makeCalendar(...params: Parameters<typeof rawMakeCalendar>): Promise<DAVResponse[]>;
+    calendarMultiGet(...params: Parameters<typeof rawCalendarMultiGet>): Promise<DAVResponse[]>;
+    fetchCalendars(...params: Parameters<typeof rawFetchCalendars>): Promise<DAVCalendar[]>;
+    fetchCalendarUserAddresses(...params: Parameters<typeof rawFetchCalendarUserAddresses>): Promise<string[]>;
+    fetchCalendarObjects(...params: Parameters<typeof rawFetchCalendarObjects>): Promise<DAVCalendarObject[]>;
+    createCalendarObject(...params: Parameters<typeof rawCreateCalendarObject>): Promise<Response>;
+    updateCalendarObject(...params: Parameters<typeof rawUpdateCalendarObject>): Promise<Response>;
+    deleteCalendarObject(...params: Parameters<typeof rawDeleteCalendarObject>): Promise<Response>;
+    syncCalendars(...params: Parameters<SyncCalendars>): Promise<ReturnType<SyncCalendars>>;
+    addressBookQuery(...params: Parameters<typeof rawAddressBookQuery>): Promise<DAVResponse[]>;
+    addressBookMultiGet(...params: Parameters<typeof rawAddressBookMultiGet>): Promise<DAVResponse[]>;
+    fetchAddressBooks(...params: Parameters<typeof rawFetchAddressBooks>): Promise<DAVAddressBook[]>;
+    fetchVCards(...params: Parameters<typeof rawFetchVCards>): Promise<DAVVCard[]>;
+    createVCard(...params: Parameters<typeof rawCreateVCard>): Promise<Response>;
+    updateVCard(...params: Parameters<typeof rawUpdateVCard>): Promise<Response>;
+    deleteVCard(...params: Parameters<typeof rawDeleteVCard>): Promise<Response>;
+}
diff --git a/dist/collection.d.ts b/dist/collection.d.ts
new file mode 100644
index 0000000..5a126b2
--- /dev/null
+++ b/dist/collection.d.ts
@@ -0,0 +1,51 @@
+import { ElementCompact } from 'xml-js';
+import { DAVNamespaceShort } from './consts';
+import { DAVDepth, DAVResponse } from './types/DAVTypes';
+import { SmartCollectionSync } from './types/functionsOverloads';
+import { DAVCollection } from './types/models';
+export declare const collectionQuery: (params: {
+    url: string;
+    body: any;
+    depth?: DAVDepth;
+    defaultNamespace?: DAVNamespaceShort;
+    headers?: Record<string, string>;
+    headersToExclude?: string[];
+    fetchOptions?: RequestInit;
+}) => Promise<DAVResponse[]>;
+export declare const makeCollection: (params: {
+    url: string;
+    props?: ElementCompact;
+    depth?: DAVDepth;
+    headers?: Record<string, string>;
+    headersToExclude?: string[];
+    fetchOptions?: RequestInit;
+}) => Promise<DAVResponse[]>;
+export declare const supportedReportSet: (params: {
+    collection: DAVCollection;
+    headers?: Record<string, string>;
+    headersToExclude?: string[];
+    fetchOptions?: RequestInit;
+}) => Promise<string[]>;
+export declare const isCollectionDirty: (params: {
+    collection: DAVCollection;
+    headers?: Record<string, string>;
+    headersToExclude?: string[];
+    fetchOptions?: RequestInit;
+}) => Promise<{
+    isDirty: boolean;
+    newCtag: string;
+}>;
+/**
+ * This is for webdav sync-collection only
+ */
+export declare const syncCollection: (params: {
+    url: string;
+    props: ElementCompact;
+    headers?: Record<string, string>;
+    headersToExclude?: string[];
+    syncLevel?: number;
+    syncToken?: string;
+    fetchOptions?: RequestInit;
+}) => Promise<DAVResponse[]>;
+/** remote collection to local */
+export declare const smartCollectionSync: SmartCollectionSync;
diff --git a/dist/consts.d.ts b/dist/consts.d.ts
new file mode 100644
index 0000000..0205b03
--- /dev/null
+++ b/dist/consts.d.ts
@@ -0,0 +1,29 @@
+export declare enum DAVNamespace {
+    CALENDAR_SERVER = "http://calendarserver.org/ns/",
+    CALDAV_APPLE = "http://apple.com/ns/ical/",
+    CALDAV = "urn:ietf:params:xml:ns:caldav",
+    CARDDAV = "urn:ietf:params:xml:ns:carddav",
+    DAV = "DAV:"
+}
+export declare const DAVAttributeMap: {
+    "urn:ietf:params:xml:ns:caldav": string;
+    "urn:ietf:params:xml:ns:carddav": string;
+    "http://calendarserver.org/ns/": string;
+    "http://apple.com/ns/ical/": string;
+    "DAV:": string;
+};
+export declare enum DAVNamespaceShort {
+    CALDAV = "c",
+    CARDDAV = "card",
+    CALENDAR_SERVER = "cs",
+    CALDAV_APPLE = "ca",
+    DAV = "d"
+}
+export declare enum ICALObjects {
+    VEVENT = "VEVENT",
+    VTODO = "VTODO",
+    VJOURNAL = "VJOURNAL",
+    VFREEBUSY = "VFREEBUSY",
+    VTIMEZONE = "VTIMEZONE",
+    VALARM = "VALARM"
+}
diff --git a/dist/index.d.ts b/dist/index.d.ts
new file mode 100644
index 0000000..8f7b0aa
--- /dev/null
+++ b/dist/index.d.ts
@@ -0,0 +1,526 @@
+import * as client from './client';
+import { DAVNamespace, DAVNamespaceShort } from './consts';
+export type { DAVDepth, DAVMethods, DAVRequest, DAVResponse, DAVTokens } from './types/DAVTypes';
+export type { DAVAccount, DAVAddressBook, DAVCalendar, DAVCalendarObject, DAVCollection, DAVCredentials, DAVObject, DAVVCard, } from './types/models';
+export { DAVClient } from './client';
+export { createDAVClient } from './client';
+export { createAccount } from './account';
+export { davRequest, propfind, createObject, updateObject, deleteObject } from './request';
+export { collectionQuery, supportedReportSet, isCollectionDirty, syncCollection, smartCollectionSync, } from './collection';
+export { calendarQuery, calendarMultiGet, makeCalendar, fetchCalendars, fetchCalendarUserAddresses, fetchCalendarObjects, createCalendarObject, updateCalendarObject, deleteCalendarObject, syncCalendars, freeBusyQuery, } from './calendar';
+export { addressBookQuery, fetchAddressBooks, fetchVCards, createVCard, updateVCard, deleteVCard, } from './addressBook';
+export { getBasicAuthHeaders, getOauthHeaders, fetchOauthTokens, refreshAccessToken, } from './util/authHelpers';
+export { urlContains, urlEquals, getDAVAttribute, cleanupFalsy } from './util/requestHelpers';
+export { DAVNamespace, DAVAttributeMap, DAVNamespaceShort } from './consts';
+declare const _default: {
+    urlEquals: (urlA?: string, urlB?: string) => boolean;
+    urlContains: (urlA?: string, urlB?: string) => boolean;
+    getDAVAttribute: (nsArr: DAVNamespace[]) => {
+        [key: string]: DAVNamespace;
+    };
+    cleanupFalsy: <T extends object = object>(obj: T) => import("./util/typeHelpers").NoUndefinedField<T>;
+    conditionalParam: <T>(key: string, param: T) => {
+        [key: string]: T;
+    };
+    excludeHeaders: (headers: Record<string, string> | undefined, headersToExclude: string[] | undefined) => Record<string, string>;
+    defaultParam: <F extends (...args: any[]) => any>(fn: F, params: Partial<Parameters<F>[0]>) => (...args: Parameters<F>) => ReturnType<F>;
+    getBasicAuthHeaders: (credentials: import("./types/models").DAVCredentials) => {
+        authorization?: string;
+    };
+    fetchOauthTokens: (credentials: import("./types/models").DAVCredentials, fetchOptions?: RequestInit) => Promise<import("./types/DAVTypes").DAVTokens>;
+    refreshAccessToken: (credentials: import("./types/models").DAVCredentials, fetchOptions?: RequestInit) => Promise<{
+        access_token?: string;
+        expires_in?: number;
+    }>;
+    getOauthHeaders: (credentials: import("./types/models").DAVCredentials, fetchOptions?: RequestInit) => Promise<{
+        tokens: import("./types/DAVTypes").DAVTokens;
+        headers: {
+            authorization?: string;
+        };
+    }>;
+    fetchCalendarUserAddresses: (params: {
+        account: import("./types/models").DAVAccount;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<string[]>;
+    calendarQuery: (params: {
+        url: string;
+        props: import("xml-js/types").ElementCompact;
+        filters?: import("xml-js/types").ElementCompact;
+        timezone?: string;
+        depth?: import("./types/DAVTypes").DAVDepth;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<import("./types/DAVTypes").DAVResponse[]>;
+    calendarMultiGet: (params: {
+        url: string;
+        props: import("xml-js/types").ElementCompact;
+        objectUrls?: string[];
+        timezone?: string;
+        depth: import("./types/DAVTypes").DAVDepth;
+        filters?: import("xml-js/types").ElementCompact;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<import("./types/DAVTypes").DAVResponse[]>;
+    makeCalendar: (params: {
+        url: string;
+        props: import("xml-js/types").ElementCompact;
+        depth?: import("./types/DAVTypes").DAVDepth;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<import("./types/DAVTypes").DAVResponse[]>;
+    fetchCalendars: (params?: {
+        account?: import("./types/models").DAVAccount;
+        props?: import("xml-js/types").ElementCompact;
+        projectedProps?: Record<string, boolean>;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<import("./types/models").DAVCalendar[]>;
+    fetchCalendarObjects: (params: {
+        calendar: import("./types/models").DAVCalendar;
+        objectUrls?: string[];
+        filters?: import("xml-js/types").ElementCompact;
+        timeRange?: {
+            start: string;
+            end: string;
+        };
+        expand?: boolean;
+        urlFilter?: (url: string) => boolean;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        useMultiGet?: boolean;
+        fetchOptions?: RequestInit;
+    }) => Promise<import("./types/models").DAVCalendarObject[]>;
+    createCalendarObject: (params: {
+        calendar: import("./types/models").DAVCalendar;
+        iCalString: string;
+        filename: string;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<Response>;
+    updateCalendarObject: (params: {
+        calendarObject: import("./types/models").DAVCalendarObject;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<Response>;
+    deleteCalendarObject: (params: {
+        calendarObject: import("./types/models").DAVCalendarObject;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<Response>;
+    syncCalendars: import("./types/functionsOverloads").SyncCalendars;
+    freeBusyQuery: (params: {
+        url: string;
+        timeRange: {
+            start: string;
+            end: string;
+        };
+        depth?: import("./types/DAVTypes").DAVDepth;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<import("./types/DAVTypes").DAVResponse>;
+    addressBookQuery: (params: {
+        url: string;
+        props: import("xml-js/types").ElementCompact;
+        filters?: import("xml-js/types").ElementCompact;
+        depth?: import("./types/DAVTypes").DAVDepth;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<import("./types/DAVTypes").DAVResponse[]>;
+    addressBookMultiGet: (params: {
+        url: string;
+        props: import("xml-js/types").ElementCompact;
+        objectUrls: string[];
+        depth: import("./types/DAVTypes").DAVDepth;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<import("./types/DAVTypes").DAVResponse[]>;
+    fetchAddressBooks: (params?: {
+        account?: import("./types/models").DAVAccount;
+        props?: import("xml-js/types").ElementCompact;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<import("./types/models").DAVAddressBook[]>;
+    fetchVCards: (params: {
+        addressBook: import("./types/models").DAVAddressBook;
+        headers?: Record<string, string>;
+        objectUrls?: string[];
+        urlFilter?: (url: string) => boolean;
+        useMultiGet?: boolean;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<import("./types/models").DAVVCard[]>;
+    createVCard: (params: {
+        addressBook: import("./types/models").DAVAddressBook;
+        vCardString: string;
+        filename: string;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<Response>;
+    updateVCard: (params: {
+        vCard: import("./types/models").DAVVCard;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<Response>;
+    deleteVCard: (params: {
+        vCard: import("./types/models").DAVVCard;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<Response>;
+    serviceDiscovery: (params: {
+        account: import("./types/models").DAVAccount;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<string>;
+    fetchPrincipalUrl: (params: {
+        account: import("./types/models").DAVAccount;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<string>;
+    fetchHomeUrl: (params: {
+        account: import("./types/models").DAVAccount;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<string>;
+    createAccount: (params: {
+        account: import("./types/models").DAVAccount;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        loadCollections?: boolean;
+        loadObjects?: boolean;
+        fetchOptions?: RequestInit;
+    }) => Promise<import("./types/models").DAVAccount>;
+    collectionQuery: (params: {
+        url: string;
+        body: any;
+        depth?: import("./types/DAVTypes").DAVDepth;
+        defaultNamespace?: DAVNamespaceShort;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<import("./types/DAVTypes").DAVResponse[]>;
+    makeCollection: (params: {
+        url: string;
+        props?: import("xml-js/types").ElementCompact;
+        depth?: import("./types/DAVTypes").DAVDepth;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<import("./types/DAVTypes").DAVResponse[]>;
+    supportedReportSet: (params: {
+        collection: import("./types/models").DAVCollection;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<string[]>;
+    isCollectionDirty: (params: {
+        collection: import("./types/models").DAVCollection;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<{
+        isDirty: boolean;
+        newCtag: string;
+    }>;
+    syncCollection: (params: {
+        url: string;
+        props: import("xml-js/types").ElementCompact;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        syncLevel?: number;
+        syncToken?: string;
+        fetchOptions?: RequestInit;
+    }) => Promise<import("./types/DAVTypes").DAVResponse[]>;
+    smartCollectionSync: import("./types/functionsOverloads").SmartCollectionSync;
+    davRequest: (params: {
+        url: string;
+        init: import("./types/DAVTypes").DAVRequest;
+        convertIncoming?: boolean;
+        parseOutgoing?: boolean;
+        fetchOptions?: RequestInit;
+    }) => Promise<import("./types/DAVTypes").DAVResponse[]>;
+    propfind: (params: {
+        url: string;
+        props: import("xml-js/types").ElementCompact;
+        depth?: import("./types/DAVTypes").DAVDepth;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<import("./types/DAVTypes").DAVResponse[]>;
+    createObject: (params: {
+        url: string;
+        data: BodyInit;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<Response>;
+    updateObject: (params: {
+        url: string;
+        data: BodyInit;
+        etag?: string;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<Response>;
+    deleteObject: (params: {
+        url: string;
+        etag?: string;
+        headers?: Record<string, string>;
+        headersToExclude?: string[];
+        fetchOptions?: RequestInit;
+    }) => Promise<Response>;
+    createDAVClient: (params: {
+        serverUrl: string;
+        credentials: import("./types/models").DAVCredentials;
+        authMethod?: "Basic" | "Oauth" | "Digest" | "Custom";
+        authFunction?: (credentials: import("./types/models").DAVCredentials) => Promise<Record<string, string>>;
+        defaultAccountType?: import("./types/models").DAVAccount["accountType"] | undefined;
+    }) => Promise<{
+        davRequest: (params0: {
+            url: string;
+            init: import("./types/DAVTypes").DAVRequest;
+            convertIncoming?: boolean;
+            parseOutgoing?: boolean;
+        }) => Promise<import("./types/DAVTypes").DAVResponse[]>;
+        propfind: (params: {
+            url: string;
+            props: import("xml-js/types").ElementCompact;
+            depth?: import("./types/DAVTypes").DAVDepth;
+            headers?: Record<string, string>;
+            headersToExclude?: string[];
+            fetchOptions?: RequestInit;
+        }) => Promise<import("./types/DAVTypes").DAVResponse[]>;
+        createAccount: (params0: {
+            account: import("./util/typeHelpers").Optional<import("./types/models").DAVAccount, "serverUrl">;
+            headers?: Record<string, string>;
+            loadCollections?: boolean;
+            loadObjects?: boolean;
+        }) => Promise<import("./types/models").DAVAccount>;
+        createObject: (params: {
+            url: string;
+            data: BodyInit;
+            headers?: Record<string, string>;
+            headersToExclude?: string[];
+            fetchOptions?: RequestInit;
+        }) => Promise<Response>;
+        updateObject: (params: {
+            url: string;
+            data: BodyInit;
+            etag?: string;
+            headers?: Record<string, string>;
+            headersToExclude?: string[];
+            fetchOptions?: RequestInit;
+        }) => Promise<Response>;
+        deleteObject: (params: {
+            url: string;
+            etag?: string;
+            headers?: Record<string, string>;
+            headersToExclude?: string[];
+            fetchOptions?: RequestInit;
+        }) => Promise<Response>;
+        calendarQuery: (params: {
+            url: string;
+            props: import("xml-js/types").ElementCompact;
+            filters?: import("xml-js/types").ElementCompact;
+            timezone?: string;
+            depth?: import("./types/DAVTypes").DAVDepth;
+            headers?: Record<string, string>;
+            headersToExclude?: string[];
+            fetchOptions?: RequestInit;
+        }) => Promise<import("./types/DAVTypes").DAVResponse[]>;
+        addressBookQuery: (params: {
+            url: string;
+            props: import("xml-js/types").ElementCompact;
+            filters?: import("xml-js/types").ElementCompact;
+            depth?: import("./types/DAVTypes").DAVDepth;
+            headers?: Record<string, string>;
+            headersToExclude?: string[];
+            fetchOptions?: RequestInit;
+        }) => Promise<import("./types/DAVTypes").DAVResponse[]>;
+        collectionQuery: (params: {
+            url: string;
+            body: any;
+            depth?: import("./types/DAVTypes").DAVDepth;
+            defaultNamespace?: DAVNamespaceShort;
+            headers?: Record<string, string>;
+            headersToExclude?: string[];
+            fetchOptions?: RequestInit;
+        }) => Promise<import("./types/DAVTypes").DAVResponse[]>;
+        makeCollection: (params: {
+            url: string;
+            props?: import("xml-js/types").ElementCompact;
+            depth?: import("./types/DAVTypes").DAVDepth;
+            headers?: Record<string, string>;
+            headersToExclude?: string[];
+            fetchOptions?: RequestInit;
+        }) => Promise<import("./types/DAVTypes").DAVResponse[]>;
+        calendarMultiGet: (params: {
+            url: string;
+            props: import("xml-js/types").ElementCompact;
+            objectUrls?: string[];
+            timezone?: string;
+            depth: import("./types/DAVTypes").DAVDepth;
+            filters?: import("xml-js/types").ElementCompact;
+            headers?: Record<string, string>;
+            headersToExclude?: string[];
+            fetchOptions?: RequestInit;
+        }) => Promise<import("./types/DAVTypes").DAVResponse[]>;
+        makeCalendar: (params: {
+            url: string;
+            props: import("xml-js/types").ElementCompact;
+            depth?: import("./types/DAVTypes").DAVDepth;
+            headers?: Record<string, string>;
+            headersToExclude?: string[];
+            fetchOptions?: RequestInit;
+        }) => Promise<import("./types/DAVTypes").DAVResponse[]>;
+        syncCollection: (params: {
+            url: string;
+            props: import("xml-js/types").ElementCompact;
+            headers?: Record<string, string>;
+            headersToExclude?: string[];
+            syncLevel?: number;
+            syncToken?: string;
+            fetchOptions?: RequestInit;
+        }) => Promise<import("./types/DAVTypes").DAVResponse[]>;
+        supportedReportSet: (params: {
+            collection: import("./types/models").DAVCollection;
+            headers?: Record<string, string>;
+            headersToExclude?: string[];
+            fetchOptions?: RequestInit;
+        }) => Promise<string[]>;
+        isCollectionDirty: (params: {
+            collection: import("./types/models").DAVCollection;
+            headers?: Record<string, string>;
+            headersToExclude?: string[];
+            fetchOptions?: RequestInit;
+        }) => Promise<{
+            isDirty: boolean;
+            newCtag: string;
+        }>;
+        smartCollectionSync: import("./types/functionsOverloads").SmartCollectionSync;
+        fetchCalendars: (params?: {
+            account?: import("./types/models").DAVAccount;
+            props?: import("xml-js/types").ElementCompact;
+            projectedProps?: Record<string, boolean>;
+            headers?: Record<string, string>;
+            headersToExclude?: string[];
+            fetchOptions?: RequestInit;
+        } | undefined) => Promise<import("./types/models").DAVCalendar[]>;
+        fetchCalendarUserAddresses: (params: {
+            account: import("./types/models").DAVAccount;
+            headers?: Record<string, string>;
+            headersToExclude?: string[];
+            fetchOptions?: RequestInit;
+        }) => Promise<string[]>;
+        fetchCalendarObjects: (params: {
+            calendar: import("./types/models").DAVCalendar;
+            objectUrls?: string[];
+            filters?: import("xml-js/types").ElementCompact;
+            timeRange?: {
+                start: string;
+                end: string;
+            };
+            expand?: boolean;
+            urlFilter?: (url: string) => boolean;
+            headers?: Record<string, string>;
+            headersToExclude?: string[];
+            useMultiGet?: boolean;
+            fetchOptions?: RequestInit;
+        }) => Promise<import("./types/models").DAVObject[]>;
+        createCalendarObject: (params: {
+            calendar: import("./types/models").DAVCalendar;
+            iCalString: string;
+            filename: string;
+            headers?: Record<string, string>;
+            headersToExclude?: string[];
+            fetchOptions?: RequestInit;
+        }) => Promise<Response>;
+        updateCalendarObject: (params: {
+            calendarObject: import("./types/models").DAVCalendarObject;
+            headers?: Record<string, string>;
+            headersToExclude?: string[];
+            fetchOptions?: RequestInit;
+        }) => Promise<Response>;
+        deleteCalendarObject: (params: {
+            calendarObject: import("./types/models").DAVCalendarObject;
+            headers?: Record<string, string>;
+            headersToExclude?: string[];
+            fetchOptions?: RequestInit;
+        }) => Promise<Response>;
+        syncCalendars: import("./types/functionsOverloads").SyncCalendars;
+        fetchAddressBooks: (params?: {
+            account?: import("./types/models").DAVAccount;
+            props?: import("xml-js/types").ElementCompact;
+            headers?: Record<string, string>;
+            headersToExclude?: string[];
+            fetchOptions?: RequestInit;
+        } | undefined) => Promise<import("./types/models").DAVCollection[]>;
+        addressBookMultiGet: (params: {
+            url: string;
+            props: import("xml-js/types").ElementCompact;
+            objectUrls: string[];
+            depth: import("./types/DAVTypes").DAVDepth;
+            headers?: Record<string, string>;
+            headersToExclude?: string[];
+            fetchOptions?: RequestInit;
+        }) => Promise<import("./types/DAVTypes").DAVResponse[]>;
+        fetchVCards: (params: {
+            addressBook: import("./types/models").DAVAddressBook;
+            headers?: Record<string, string>;
+            objectUrls?: string[];
+            urlFilter?: (url: string) => boolean;
+            useMultiGet?: boolean;
+            headersToExclude?: string[];
+            fetchOptions?: RequestInit;
+        }) => Promise<import("./types/models").DAVObject[]>;
+        createVCard: (params: {
+            addressBook: import("./types/models").DAVAddressBook;
+            vCardString: string;
+            filename: string;
+            headers?: Record<string, string>;
+            headersToExclude?: string[];
+            fetchOptions?: RequestInit;
+        }) => Promise<Response>;
+        updateVCard: (params: {
+            vCard: import("./types/models").DAVVCard;
+            headers?: Record<string, string>;
+            headersToExclude?: string[];
+            fetchOptions?: RequestInit;
+        }) => Promise<Response>;
+        deleteVCard: (params: {
+            vCard: import("./types/models").DAVVCard;
+            headers?: Record<string, string>;
+            headersToExclude?: string[];
+            fetchOptions?: RequestInit;
+        }) => Promise<Response>;
+    }>;
+    DAVClient: typeof client.DAVClient;
+    DAVNamespace: typeof DAVNamespace;
+    DAVNamespaceShort: typeof DAVNamespaceShort;
+    DAVAttributeMap: {
+        "urn:ietf:params:xml:ns:caldav": string;
+        "urn:ietf:params:xml:ns:carddav": string;
+        "http://calendarserver.org/ns/": string;
+        "http://apple.com/ns/ical/": string;
+        "DAV:": string;
+    };
+};
+export default _default;
diff --git a/dist/package.json b/dist/package.json
index 9699324..37adbc0 100644
--- a/dist/package.json
+++ b/dist/package.json
@@ -48,14 +48,14 @@
   "dependencies": {
     "base-64": "1.0.0",
     "cross-fetch": "4.0.0",
-    "debug": "4.3.7",
+    "debug": "4.4.0",
     "xml-js": "1.6.11"
   },
   "devDependencies": {
-    "@rollup/plugin-commonjs": "26.0.1",
-    "@rollup/plugin-node-resolve": "15.2.3",
+    "@rollup/plugin-commonjs": "28.0.1",
+    "@rollup/plugin-node-resolve": "15.3.0",
     "@rollup/plugin-terser": "0.4.4",
-    "@rollup/plugin-typescript": "11.1.6",
+    "@rollup/plugin-typescript": "12.1.1",
     "@types/base-64": "1.0.2",
     "@types/debug": "4.1.12",
     "@types/jest": "29.5.12",
@@ -64,25 +64,25 @@
     "@typescript-eslint/parser": "8.5.0",
     "copyfiles": "2.4.1",
     "cross-env": "7.0.3",
-    "dotenv": "16.4.5",
-    "eslint": "9.10.0",
+    "dotenv": "16.4.7",
+    "eslint": "9.16.0",
     "eslint-config-airbnb": "19.0.4",
     "eslint-config-airbnb-typescript": "18.0.0",
     "eslint-config-prettier": "9.1.0",
-    "eslint-module-utils": "2.11.0",
-    "eslint-plugin-import": "2.30.0",
-    "eslint-plugin-prettier": "5.1.3",
+    "eslint-module-utils": "2.12.0",
+    "eslint-plugin-import": "2.31.0",
+    "eslint-plugin-prettier": "5.2.1",
     "jest": "29.7.0",
-    "prettier": "3.3.3",
+    "prettier": "3.4.2",
     "rimraf": "6.0.1",
     "rollup": "4.21.2",
     "rollup-plugin-dts": "6.1.1",
     "rollup-plugin-node-builtins": "2.1.2",
     "rollup-plugin-polyfill-node": "0.13.0",
-    "sort-package-json": "2.10.1",
+    "sort-package-json": "2.12.0",
     "ts-jest": "29.2.5",
-    "tslib": "2.7.0",
-    "typescript": "5.6.2"
+    "tslib": "2.8.1",
+    "typescript": "5.7.2"
   },
   "engines": {
     "node": ">=10"
diff --git a/dist/request.d.ts b/dist/request.d.ts
new file mode 100644
index 0000000..fae7f8c
--- /dev/null
+++ b/dist/request.d.ts
@@ -0,0 +1,40 @@
+import 'cross-fetch/polyfill';
+import { ElementCompact } from 'xml-js';
+import { DAVDepth, DAVRequest, DAVResponse } from './types/DAVTypes';
+export declare const davRequest: (params: {
+    url: string;
+    init: DAVRequest;
+    convertIncoming?: boolean;
+    parseOutgoing?: boolean;
+    fetchOptions?: RequestInit;
+}) => Promise<DAVResponse[]>;
+export declare const propfind: (params: {
+    url: string;
+    props: ElementCompact;
+    depth?: DAVDepth;
+    headers?: Record<string, string>;
+    headersToExclude?: string[];
+    fetchOptions?: RequestInit;
+}) => Promise<DAVResponse[]>;
+export declare const createObject: (params: {
+    url: string;
+    data: BodyInit;
+    headers?: Record<string, string>;
+    headersToExclude?: string[];
+    fetchOptions?: RequestInit;
+}) => Promise<Response>;
+export declare const updateObject: (params: {
+    url: string;
+    data: BodyInit;
+    etag?: string;
+    headers?: Record<string, string>;
+    headersToExclude?: string[];
+    fetchOptions?: RequestInit;
+}) => Promise<Response>;
+export declare const deleteObject: (params: {
+    url: string;
+    etag?: string;
+    headers?: Record<string, string>;
+    headersToExclude?: string[];
+    fetchOptions?: RequestInit;
+}) => Promise<Response>;
diff --git a/dist/tsdav.d.ts b/dist/tsdav.d.ts
index 8ce428a..3dd5753 100644
--- a/dist/tsdav.d.ts
+++ b/dist/tsdav.d.ts
@@ -1,5 +1,5 @@
-import * as xml_js from 'xml-js';
 import { ElementCompact } from 'xml-js';
+import * as xml_js_types from 'xml-js/types';
 
 type DAVDepth = '0' | '1' | 'infinity';
 type DAVMethods = 'COPY' | 'LOCK' | 'MKCOL' | 'MOVE' | 'PROPFIND' | 'PROPPATCH' | 'UNLOCK' | 'REPORT' | 'SEARCH' | 'MKCALENDAR';
@@ -429,7 +429,7 @@ declare const createDAVClient: (params: {
     }) => Promise<DAVResponse[]>;
     propfind: (params: {
         url: string;
-        props: xml_js.ElementCompact;
+        props: xml_js_types.ElementCompact;
         depth?: DAVDepth;
         headers?: Record<string, string>;
         headersToExclude?: string[];
@@ -465,8 +465,8 @@ declare const createDAVClient: (params: {
     }) => Promise<Response>;
     calendarQuery: (params: {
         url: string;
-        props: xml_js.ElementCompact;
-        filters?: xml_js.ElementCompact;
+        props: xml_js_types.ElementCompact;
+        filters?: xml_js_types.ElementCompact;
         timezone?: string;
         depth?: DAVDepth;
         headers?: Record<string, string>;
@@ -475,8 +475,8 @@ declare const createDAVClient: (params: {
     }) => Promise<DAVResponse[]>;
     addressBookQuery: (params: {
         url: string;
-        props: xml_js.ElementCompact;
-        filters?: xml_js.ElementCompact;
+        props: xml_js_types.ElementCompact;
+        filters?: xml_js_types.ElementCompact;
         depth?: DAVDepth;
         headers?: Record<string, string>;
         headersToExclude?: string[];
@@ -493,7 +493,7 @@ declare const createDAVClient: (params: {
     }) => Promise<DAVResponse[]>;
     makeCollection: (params: {
         url: string;
-        props?: xml_js.ElementCompact;
+        props?: xml_js_types.ElementCompact;
         depth?: DAVDepth;
         headers?: Record<string, string>;
         headersToExclude?: string[];
@@ -501,18 +501,18 @@ declare const createDAVClient: (params: {
     }) => Promise<DAVResponse[]>;
     calendarMultiGet: (params: {
         url: string;
-        props: xml_js.ElementCompact;
+        props: xml_js_types.ElementCompact;
         objectUrls?: string[];
         timezone?: string;
         depth: DAVDepth;
-        filters?: xml_js.ElementCompact;
+        filters?: xml_js_types.ElementCompact;
         headers?: Record<string, string>;
         headersToExclude?: string[];
         fetchOptions?: RequestInit;
     }) => Promise<DAVResponse[]>;
     makeCalendar: (params: {
         url: string;
-        props: xml_js.ElementCompact;
+        props: xml_js_types.ElementCompact;
         depth?: DAVDepth;
         headers?: Record<string, string>;
         headersToExclude?: string[];
@@ -520,7 +520,7 @@ declare const createDAVClient: (params: {
     }) => Promise<DAVResponse[]>;
     syncCollection: (params: {
         url: string;
-        props: xml_js.ElementCompact;
+        props: xml_js_types.ElementCompact;
         headers?: Record<string, string>;
         headersToExclude?: string[];
         syncLevel?: number;
@@ -545,7 +545,7 @@ declare const createDAVClient: (params: {
     smartCollectionSync: SmartCollectionSync;
     fetchCalendars: (params?: {
         account?: DAVAccount;
-        props?: xml_js.ElementCompact;
+        props?: xml_js_types.ElementCompact;
         projectedProps?: Record<string, boolean>;
         headers?: Record<string, string>;
         headersToExclude?: string[];
@@ -560,7 +560,7 @@ declare const createDAVClient: (params: {
     fetchCalendarObjects: (params: {
         calendar: DAVCalendar;
         objectUrls?: string[];
-        filters?: xml_js.ElementCompact;
+        filters?: xml_js_types.ElementCompact;
         timeRange?: {
             start: string;
             end: string;
@@ -595,14 +595,14 @@ declare const createDAVClient: (params: {
     syncCalendars: SyncCalendars;
     fetchAddressBooks: (params?: {
         account?: DAVAccount;
-        props?: xml_js.ElementCompact;
+        props?: xml_js_types.ElementCompact;
         headers?: Record<string, string>;
         headersToExclude?: string[];
         fetchOptions?: RequestInit;
     } | undefined) => Promise<DAVCollection[]>;
     addressBookMultiGet: (params: {
         url: string;
-        props: xml_js.ElementCompact;
+        props: xml_js_types.ElementCompact;
         objectUrls: string[];
         depth: DAVDepth;
         headers?: Record<string, string>;
@@ -789,8 +789,8 @@ declare const _default: {
     }) => Promise<string[]>;
     calendarQuery: (params: {
         url: string;
-        props: xml_js.ElementCompact;
-        filters?: xml_js.ElementCompact;
+        props: xml_js_types.ElementCompact;
+        filters?: xml_js_types.ElementCompact;
         timezone?: string;
         depth?: DAVDepth;
         headers?: Record<string, string>;
@@ -799,18 +799,18 @@ declare const _default: {
     }) => Promise<DAVResponse[]>;
     calendarMultiGet: (params: {
         url: string;
-        props: xml_js.ElementCompact;
+        props: xml_js_types.ElementCompact;
         objectUrls?: string[];
         timezone?: string;
         depth: DAVDepth;
-        filters?: xml_js.ElementCompact;
+        filters?: xml_js_types.ElementCompact;
         headers?: Record<string, string>;
         headersToExclude?: string[];
         fetchOptions?: RequestInit;
     }) => Promise<DAVResponse[]>;
     makeCalendar: (params: {
         url: string;
-        props: xml_js.ElementCompact;
+        props: xml_js_types.ElementCompact;
         depth?: DAVDepth;
         headers?: Record<string, string>;
         headersToExclude?: string[];
@@ -818,7 +818,7 @@ declare const _default: {
     }) => Promise<DAVResponse[]>;
     fetchCalendars: (params?: {
         account?: DAVAccount;
-        props?: xml_js.ElementCompact;
+        props?: xml_js_types.ElementCompact;
         projectedProps?: Record<string, boolean>;
         headers?: Record<string, string>;
         headersToExclude?: string[];
@@ -827,7 +827,7 @@ declare const _default: {
     fetchCalendarObjects: (params: {
         calendar: DAVCalendar;
         objectUrls?: string[];
-        filters?: xml_js.ElementCompact;
+        filters?: xml_js_types.ElementCompact;
         timeRange?: {
             start: string;
             end: string;
@@ -873,8 +873,8 @@ declare const _default: {
     }) => Promise<DAVResponse>;
     addressBookQuery: (params: {
         url: string;
-        props: xml_js.ElementCompact;
-        filters?: xml_js.ElementCompact;
+        props: xml_js_types.ElementCompact;
+        filters?: xml_js_types.ElementCompact;
         depth?: DAVDepth;
         headers?: Record<string, string>;
         headersToExclude?: string[];
@@ -882,7 +882,7 @@ declare const _default: {
     }) => Promise<DAVResponse[]>;
     addressBookMultiGet: (params: {
         url: string;
-        props: xml_js.ElementCompact;
+        props: xml_js_types.ElementCompact;
         objectUrls: string[];
         depth: DAVDepth;
         headers?: Record<string, string>;
@@ -891,7 +891,7 @@ declare const _default: {
     }) => Promise<DAVResponse[]>;
     fetchAddressBooks: (params?: {
         account?: DAVAccount;
-        props?: xml_js.ElementCompact;
+        props?: xml_js_types.ElementCompact;
         headers?: Record<string, string>;
         headersToExclude?: string[];
         fetchOptions?: RequestInit;
@@ -962,7 +962,7 @@ declare const _default: {
     }) => Promise<DAVResponse[]>;
     makeCollection: (params: {
         url: string;
-        props?: xml_js.ElementCompact;
+        props?: xml_js_types.ElementCompact;
         depth?: DAVDepth;
         headers?: Record<string, string>;
         headersToExclude?: string[];
@@ -985,7 +985,7 @@ declare const _default: {
     }>;
     syncCollection: (params: {
         url: string;
-        props: xml_js.ElementCompact;
+        props: xml_js_types.ElementCompact;
         headers?: Record<string, string>;
         headersToExclude?: string[];
         syncLevel?: number;
@@ -1002,7 +1002,7 @@ declare const _default: {
     }) => Promise<DAVResponse[]>;
     propfind: (params: {
         url: string;
-        props: xml_js.ElementCompact;
+        props: xml_js_types.ElementCompact;
         depth?: DAVDepth;
         headers?: Record<string, string>;
         headersToExclude?: string[];
@@ -1045,7 +1045,7 @@ declare const _default: {
         }) => Promise<DAVResponse[]>;
         propfind: (params: {
             url: string;
-            props: xml_js.ElementCompact;
+            props: xml_js_types.ElementCompact;
             depth?: DAVDepth;
             headers?: Record<string, string>;
             headersToExclude?: string[];
@@ -1081,8 +1081,8 @@ declare const _default: {
         }) => Promise<Response>;
         calendarQuery: (params: {
             url: string;
-            props: xml_js.ElementCompact;
-            filters?: xml_js.ElementCompact;
+            props: xml_js_types.ElementCompact;
+            filters?: xml_js_types.ElementCompact;
             timezone?: string;
             depth?: DAVDepth;
             headers?: Record<string, string>;
@@ -1091,8 +1091,8 @@ declare const _default: {
         }) => Promise<DAVResponse[]>;
         addressBookQuery: (params: {
             url: string;
-            props: xml_js.ElementCompact;
-            filters?: xml_js.ElementCompact;
+            props: xml_js_types.ElementCompact;
+            filters?: xml_js_types.ElementCompact;
             depth?: DAVDepth;
             headers?: Record<string, string>;
             headersToExclude?: string[];
@@ -1109,7 +1109,7 @@ declare const _default: {
         }) => Promise<DAVResponse[]>;
         makeCollection: (params: {
             url: string;
-            props?: xml_js.ElementCompact;
+            props?: xml_js_types.ElementCompact;
             depth?: DAVDepth;
             headers?: Record<string, string>;
             headersToExclude?: string[];
@@ -1117,18 +1117,18 @@ declare const _default: {
         }) => Promise<DAVResponse[]>;
         calendarMultiGet: (params: {
             url: string;
-            props: xml_js.ElementCompact;
+            props: xml_js_types.ElementCompact;
             objectUrls?: string[];
             timezone?: string;
             depth: DAVDepth;
-            filters?: xml_js.ElementCompact;
+            filters?: xml_js_types.ElementCompact;
             headers?: Record<string, string>;
             headersToExclude?: string[];
             fetchOptions?: RequestInit;
         }) => Promise<DAVResponse[]>;
         makeCalendar: (params: {
             url: string;
-            props: xml_js.ElementCompact;
+            props: xml_js_types.ElementCompact;
             depth?: DAVDepth;
             headers?: Record<string, string>;
             headersToExclude?: string[];
@@ -1136,7 +1136,7 @@ declare const _default: {
         }) => Promise<DAVResponse[]>;
         syncCollection: (params: {
             url: string;
-            props: xml_js.ElementCompact;
+            props: xml_js_types.ElementCompact;
             headers?: Record<string, string>;
             headersToExclude?: string[];
             syncLevel?: number;
@@ -1161,7 +1161,7 @@ declare const _default: {
         smartCollectionSync: SmartCollectionSync;
         fetchCalendars: (params?: {
             account?: DAVAccount;
-            props?: xml_js.ElementCompact;
+            props?: xml_js_types.ElementCompact;
             projectedProps?: Record<string, boolean>;
             headers?: Record<string, string>;
             headersToExclude?: string[];
@@ -1176,7 +1176,7 @@ declare const _default: {
         fetchCalendarObjects: (params: {
             calendar: DAVCalendar;
             objectUrls?: string[];
-            filters?: xml_js.ElementCompact;
+            filters?: xml_js_types.ElementCompact;
             timeRange?: {
                 start: string;
                 end: string;
@@ -1211,14 +1211,14 @@ declare const _default: {
         syncCalendars: SyncCalendars;
         fetchAddressBooks: (params?: {
             account?: DAVAccount;
-            props?: xml_js.ElementCompact;
+            props?: xml_js_types.ElementCompact;
             headers?: Record<string, string>;
             headersToExclude?: string[];
             fetchOptions?: RequestInit;
         } | undefined) => Promise<DAVCollection[]>;
         addressBookMultiGet: (params: {
             url: string;
-            props: xml_js.ElementCompact;
+            props: xml_js_types.ElementCompact;
             objectUrls: string[];
             depth: DAVDepth;
             headers?: Record<string, string>;
diff --git a/dist/tsdav.js b/dist/tsdav.js
index 5baca37..b811e10 100644
--- a/dist/tsdav.js
+++ b/dist/tsdav.js
@@ -29,625 +29,636 @@ function getAugmentedNamespace(n) {
 	return a;
 }
 
-(function(self) {
-
-((function (exports) {
-
-  var global =
-    (typeof globalThis !== 'undefined' && globalThis) ||
-    (typeof self !== 'undefined' && self) ||
-    (typeof global !== 'undefined' && global);
-
-  var support = {
-    searchParams: 'URLSearchParams' in global,
-    iterable: 'Symbol' in global && 'iterator' in Symbol,
-    blob:
-      'FileReader' in global &&
-      'Blob' in global &&
-      (function() {
-        try {
-          new Blob();
-          return true
-        } catch (e) {
-          return false
-        }
-      })(),
-    formData: 'FormData' in global,
-    arrayBuffer: 'ArrayBuffer' in global
-  };
+var browserPolyfill = {};
+
+var hasRequiredBrowserPolyfill;
+
+function requireBrowserPolyfill () {
+	if (hasRequiredBrowserPolyfill) return browserPolyfill;
+	hasRequiredBrowserPolyfill = 1;
+	(function(self) {
+
+	((function (exports) {
+
+	  var global =
+	    (typeof globalThis !== 'undefined' && globalThis) ||
+	    (typeof self !== 'undefined' && self) ||
+	    (typeof global !== 'undefined' && global);
+
+	  var support = {
+	    searchParams: 'URLSearchParams' in global,
+	    iterable: 'Symbol' in global && 'iterator' in Symbol,
+	    blob:
+	      'FileReader' in global &&
+	      'Blob' in global &&
+	      (function() {
+	        try {
+	          new Blob();
+	          return true
+	        } catch (e) {
+	          return false
+	        }
+	      })(),
+	    formData: 'FormData' in global,
+	    arrayBuffer: 'ArrayBuffer' in global
+	  };
 
-  function isDataView(obj) {
-    return obj && DataView.prototype.isPrototypeOf(obj)
-  }
-
-  if (support.arrayBuffer) {
-    var viewClasses = [
-      '[object Int8Array]',
-      '[object Uint8Array]',
-      '[object Uint8ClampedArray]',
-      '[object Int16Array]',
-      '[object Uint16Array]',
-      '[object Int32Array]',
-      '[object Uint32Array]',
-      '[object Float32Array]',
-      '[object Float64Array]'
-    ];
+	  function isDataView(obj) {
+	    return obj && DataView.prototype.isPrototypeOf(obj)
+	  }
 
-    var isArrayBufferView =
-      ArrayBuffer.isView ||
-      function(obj) {
-        return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1
-      };
-  }
+	  if (support.arrayBuffer) {
+	    var viewClasses = [
+	      '[object Int8Array]',
+	      '[object Uint8Array]',
+	      '[object Uint8ClampedArray]',
+	      '[object Int16Array]',
+	      '[object Uint16Array]',
+	      '[object Int32Array]',
+	      '[object Uint32Array]',
+	      '[object Float32Array]',
+	      '[object Float64Array]'
+	    ];
+
+	    var isArrayBufferView =
+	      ArrayBuffer.isView ||
+	      function(obj) {
+	        return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1
+	      };
+	  }
 
-  function normalizeName(name) {
-    if (typeof name !== 'string') {
-      name = String(name);
-    }
-    if (/[^a-z0-9\-#$%&'*+.^_`|~!]/i.test(name) || name === '') {
-      throw new TypeError('Invalid character in header field name: "' + name + '"')
-    }
-    return name.toLowerCase()
-  }
+	  function normalizeName(name) {
+	    if (typeof name !== 'string') {
+	      name = String(name);
+	    }
+	    if (/[^a-z0-9\-#$%&'*+.^_`|~!]/i.test(name) || name === '') {
+	      throw new TypeError('Invalid character in header field name: "' + name + '"')
+	    }
+	    return name.toLowerCase()
+	  }
 
-  function normalizeValue(value) {
-    if (typeof value !== 'string') {
-      value = String(value);
-    }
-    return value
-  }
+	  function normalizeValue(value) {
+	    if (typeof value !== 'string') {
+	      value = String(value);
+	    }
+	    return value
+	  }
 
-  // Build a destructive iterator for the value list
-  function iteratorFor(items) {
-    var iterator = {
-      next: function() {
-        var value = items.shift();
-        return {done: value === undefined, value: value}
-      }
-    };
+	  // Build a destructive iterator for the value list
+	  function iteratorFor(items) {
+	    var iterator = {
+	      next: function() {
+	        var value = items.shift();
+	        return {done: value === undefined, value: value}
+	      }
+	    };
 
-    if (support.iterable) {
-      iterator[Symbol.iterator] = function() {
-        return iterator
-      };
-    }
+	    if (support.iterable) {
+	      iterator[Symbol.iterator] = function() {
+	        return iterator
+	      };
+	    }
 
-    return iterator
-  }
+	    return iterator
+	  }
 
-  function Headers(headers) {
-    this.map = {};
+	  function Headers(headers) {
+	    this.map = {};
+
+	    if (headers instanceof Headers) {
+	      headers.forEach(function(value, name) {
+	        this.append(name, value);
+	      }, this);
+	    } else if (Array.isArray(headers)) {
+	      headers.forEach(function(header) {
+	        this.append(header[0], header[1]);
+	      }, this);
+	    } else if (headers) {
+	      Object.getOwnPropertyNames(headers).forEach(function(name) {
+	        this.append(name, headers[name]);
+	      }, this);
+	    }
+	  }
 
-    if (headers instanceof Headers) {
-      headers.forEach(function(value, name) {
-        this.append(name, value);
-      }, this);
-    } else if (Array.isArray(headers)) {
-      headers.forEach(function(header) {
-        this.append(header[0], header[1]);
-      }, this);
-    } else if (headers) {
-      Object.getOwnPropertyNames(headers).forEach(function(name) {
-        this.append(name, headers[name]);
-      }, this);
-    }
-  }
+	  Headers.prototype.append = function(name, value) {
+	    name = normalizeName(name);
+	    value = normalizeValue(value);
+	    var oldValue = this.map[name];
+	    this.map[name] = oldValue ? oldValue + ', ' + value : value;
+	  };
 
-  Headers.prototype.append = function(name, value) {
-    name = normalizeName(name);
-    value = normalizeValue(value);
-    var oldValue = this.map[name];
-    this.map[name] = oldValue ? oldValue + ', ' + value : value;
-  };
+	  Headers.prototype['delete'] = function(name) {
+	    delete this.map[normalizeName(name)];
+	  };
 
-  Headers.prototype['delete'] = function(name) {
-    delete this.map[normalizeName(name)];
-  };
+	  Headers.prototype.get = function(name) {
+	    name = normalizeName(name);
+	    return this.has(name) ? this.map[name] : null
+	  };
 
-  Headers.prototype.get = function(name) {
-    name = normalizeName(name);
-    return this.has(name) ? this.map[name] : null
-  };
+	  Headers.prototype.has = function(name) {
+	    return this.map.hasOwnProperty(normalizeName(name))
+	  };
 
-  Headers.prototype.has = function(name) {
-    return this.map.hasOwnProperty(normalizeName(name))
-  };
+	  Headers.prototype.set = function(name, value) {
+	    this.map[normalizeName(name)] = normalizeValue(value);
+	  };
 
-  Headers.prototype.set = function(name, value) {
-    this.map[normalizeName(name)] = normalizeValue(value);
-  };
+	  Headers.prototype.forEach = function(callback, thisArg) {
+	    for (var name in this.map) {
+	      if (this.map.hasOwnProperty(name)) {
+	        callback.call(thisArg, this.map[name], name, this);
+	      }
+	    }
+	  };
 
-  Headers.prototype.forEach = function(callback, thisArg) {
-    for (var name in this.map) {
-      if (this.map.hasOwnProperty(name)) {
-        callback.call(thisArg, this.map[name], name, this);
-      }
-    }
-  };
+	  Headers.prototype.keys = function() {
+	    var items = [];
+	    this.forEach(function(value, name) {
+	      items.push(name);
+	    });
+	    return iteratorFor(items)
+	  };
 
-  Headers.prototype.keys = function() {
-    var items = [];
-    this.forEach(function(value, name) {
-      items.push(name);
-    });
-    return iteratorFor(items)
-  };
+	  Headers.prototype.values = function() {
+	    var items = [];
+	    this.forEach(function(value) {
+	      items.push(value);
+	    });
+	    return iteratorFor(items)
+	  };
 
-  Headers.prototype.values = function() {
-    var items = [];
-    this.forEach(function(value) {
-      items.push(value);
-    });
-    return iteratorFor(items)
-  };
+	  Headers.prototype.entries = function() {
+	    var items = [];
+	    this.forEach(function(value, name) {
+	      items.push([name, value]);
+	    });
+	    return iteratorFor(items)
+	  };
 
-  Headers.prototype.entries = function() {
-    var items = [];
-    this.forEach(function(value, name) {
-      items.push([name, value]);
-    });
-    return iteratorFor(items)
-  };
+	  if (support.iterable) {
+	    Headers.prototype[Symbol.iterator] = Headers.prototype.entries;
+	  }
 
-  if (support.iterable) {
-    Headers.prototype[Symbol.iterator] = Headers.prototype.entries;
-  }
+	  function consumed(body) {
+	    if (body.bodyUsed) {
+	      return Promise.reject(new TypeError('Already read'))
+	    }
+	    body.bodyUsed = true;
+	  }
 
-  function consumed(body) {
-    if (body.bodyUsed) {
-      return Promise.reject(new TypeError('Already read'))
-    }
-    body.bodyUsed = true;
-  }
+	  function fileReaderReady(reader) {
+	    return new Promise(function(resolve, reject) {
+	      reader.onload = function() {
+	        resolve(reader.result);
+	      };
+	      reader.onerror = function() {
+	        reject(reader.error);
+	      };
+	    })
+	  }
 
-  function fileReaderReady(reader) {
-    return new Promise(function(resolve, reject) {
-      reader.onload = function() {
-        resolve(reader.result);
-      };
-      reader.onerror = function() {
-        reject(reader.error);
-      };
-    })
-  }
+	  function readBlobAsArrayBuffer(blob) {
+	    var reader = new FileReader();
+	    var promise = fileReaderReady(reader);
+	    reader.readAsArrayBuffer(blob);
+	    return promise
+	  }
 
-  function readBlobAsArrayBuffer(blob) {
-    var reader = new FileReader();
-    var promise = fileReaderReady(reader);
-    reader.readAsArrayBuffer(blob);
-    return promise
-  }
+	  function readBlobAsText(blob) {
+	    var reader = new FileReader();
+	    var promise = fileReaderReady(reader);
+	    reader.readAsText(blob);
+	    return promise
+	  }
 
-  function readBlobAsText(blob) {
-    var reader = new FileReader();
-    var promise = fileReaderReady(reader);
-    reader.readAsText(blob);
-    return promise
-  }
+	  function readArrayBufferAsText(buf) {
+	    var view = new Uint8Array(buf);
+	    var chars = new Array(view.length);
 
-  function readArrayBufferAsText(buf) {
-    var view = new Uint8Array(buf);
-    var chars = new Array(view.length);
+	    for (var i = 0; i < view.length; i++) {
+	      chars[i] = String.fromCharCode(view[i]);
+	    }
+	    return chars.join('')
+	  }
 
-    for (var i = 0; i < view.length; i++) {
-      chars[i] = String.fromCharCode(view[i]);
-    }
-    return chars.join('')
-  }
+	  function bufferClone(buf) {
+	    if (buf.slice) {
+	      return buf.slice(0)
+	    } else {
+	      var view = new Uint8Array(buf.byteLength);
+	      view.set(new Uint8Array(buf));
+	      return view.buffer
+	    }
+	  }
 
-  function bufferClone(buf) {
-    if (buf.slice) {
-      return buf.slice(0)
-    } else {
-      var view = new Uint8Array(buf.byteLength);
-      view.set(new Uint8Array(buf));
-      return view.buffer
-    }
-  }
-
-  function Body() {
-    this.bodyUsed = false;
-
-    this._initBody = function(body) {
-      /*
-        fetch-mock wraps the Response object in an ES6 Proxy to
-        provide useful test harness features such as flush. However, on
-        ES5 browsers without fetch or Proxy support pollyfills must be used;
-        the proxy-pollyfill is unable to proxy an attribute unless it exists
-        on the object before the Proxy is created. This change ensures
-        Response.bodyUsed exists on the instance, while maintaining the
-        semantic of setting Request.bodyUsed in the constructor before
-        _initBody is called.
-      */
-      this.bodyUsed = this.bodyUsed;
-      this._bodyInit = body;
-      if (!body) {
-        this._bodyText = '';
-      } else if (typeof body === 'string') {
-        this._bodyText = body;
-      } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {
-        this._bodyBlob = body;
-      } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {
-        this._bodyFormData = body;
-      } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
-        this._bodyText = body.toString();
-      } else if (support.arrayBuffer && support.blob && isDataView(body)) {
-        this._bodyArrayBuffer = bufferClone(body.buffer);
-        // IE 10-11 can't handle a DataView body.
-        this._bodyInit = new Blob([this._bodyArrayBuffer]);
-      } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {
-        this._bodyArrayBuffer = bufferClone(body);
-      } else {
-        this._bodyText = body = Object.prototype.toString.call(body);
-      }
+	  function Body() {
+	    this.bodyUsed = false;
+
+	    this._initBody = function(body) {
+	      /*
+	        fetch-mock wraps the Response object in an ES6 Proxy to
+	        provide useful test harness features such as flush. However, on
+	        ES5 browsers without fetch or Proxy support pollyfills must be used;
+	        the proxy-pollyfill is unable to proxy an attribute unless it exists
+	        on the object before the Proxy is created. This change ensures
+	        Response.bodyUsed exists on the instance, while maintaining the
+	        semantic of setting Request.bodyUsed in the constructor before
+	        _initBody is called.
+	      */
+	      this.bodyUsed = this.bodyUsed;
+	      this._bodyInit = body;
+	      if (!body) {
+	        this._bodyText = '';
+	      } else if (typeof body === 'string') {
+	        this._bodyText = body;
+	      } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {
+	        this._bodyBlob = body;
+	      } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {
+	        this._bodyFormData = body;
+	      } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
+	        this._bodyText = body.toString();
+	      } else if (support.arrayBuffer && support.blob && isDataView(body)) {
+	        this._bodyArrayBuffer = bufferClone(body.buffer);
+	        // IE 10-11 can't handle a DataView body.
+	        this._bodyInit = new Blob([this._bodyArrayBuffer]);
+	      } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {
+	        this._bodyArrayBuffer = bufferClone(body);
+	      } else {
+	        this._bodyText = body = Object.prototype.toString.call(body);
+	      }
 
-      if (!this.headers.get('content-type')) {
-        if (typeof body === 'string') {
-          this.headers.set('content-type', 'text/plain;charset=UTF-8');
-        } else if (this._bodyBlob && this._bodyBlob.type) {
-          this.headers.set('content-type', this._bodyBlob.type);
-        } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
-          this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8');
-        }
-      }
-    };
+	      if (!this.headers.get('content-type')) {
+	        if (typeof body === 'string') {
+	          this.headers.set('content-type', 'text/plain;charset=UTF-8');
+	        } else if (this._bodyBlob && this._bodyBlob.type) {
+	          this.headers.set('content-type', this._bodyBlob.type);
+	        } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
+	          this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8');
+	        }
+	      }
+	    };
 
-    if (support.blob) {
-      this.blob = function() {
-        var rejected = consumed(this);
-        if (rejected) {
-          return rejected
-        }
+	    if (support.blob) {
+	      this.blob = function() {
+	        var rejected = consumed(this);
+	        if (rejected) {
+	          return rejected
+	        }
 
-        if (this._bodyBlob) {
-          return Promise.resolve(this._bodyBlob)
-        } else if (this._bodyArrayBuffer) {
-          return Promise.resolve(new Blob([this._bodyArrayBuffer]))
-        } else if (this._bodyFormData) {
-          throw new Error('could not read FormData body as blob')
-        } else {
-          return Promise.resolve(new Blob([this._bodyText]))
-        }
-      };
+	        if (this._bodyBlob) {
+	          return Promise.resolve(this._bodyBlob)
+	        } else if (this._bodyArrayBuffer) {
+	          return Promise.resolve(new Blob([this._bodyArrayBuffer]))
+	        } else if (this._bodyFormData) {
+	          throw new Error('could not read FormData body as blob')
+	        } else {
+	          return Promise.resolve(new Blob([this._bodyText]))
+	        }
+	      };
 
-      this.arrayBuffer = function() {
-        if (this._bodyArrayBuffer) {
-          var isConsumed = consumed(this);
-          if (isConsumed) {
-            return isConsumed
-          }
-          if (ArrayBuffer.isView(this._bodyArrayBuffer)) {
-            return Promise.resolve(
-              this._bodyArrayBuffer.buffer.slice(
-                this._bodyArrayBuffer.byteOffset,
-                this._bodyArrayBuffer.byteOffset + this._bodyArrayBuffer.byteLength
-              )
-            )
-          } else {
-            return Promise.resolve(this._bodyArrayBuffer)
-          }
-        } else {
-          return this.blob().then(readBlobAsArrayBuffer)
-        }
-      };
-    }
+	      this.arrayBuffer = function() {
+	        if (this._bodyArrayBuffer) {
+	          var isConsumed = consumed(this);
+	          if (isConsumed) {
+	            return isConsumed
+	          }
+	          if (ArrayBuffer.isView(this._bodyArrayBuffer)) {
+	            return Promise.resolve(
+	              this._bodyArrayBuffer.buffer.slice(
+	                this._bodyArrayBuffer.byteOffset,
+	                this._bodyArrayBuffer.byteOffset + this._bodyArrayBuffer.byteLength
+	              )
+	            )
+	          } else {
+	            return Promise.resolve(this._bodyArrayBuffer)
+	          }
+	        } else {
+	          return this.blob().then(readBlobAsArrayBuffer)
+	        }
+	      };
+	    }
 
-    this.text = function() {
-      var rejected = consumed(this);
-      if (rejected) {
-        return rejected
-      }
+	    this.text = function() {
+	      var rejected = consumed(this);
+	      if (rejected) {
+	        return rejected
+	      }
 
-      if (this._bodyBlob) {
-        return readBlobAsText(this._bodyBlob)
-      } else if (this._bodyArrayBuffer) {
-        return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer))
-      } else if (this._bodyFormData) {
-        throw new Error('could not read FormData body as text')
-      } else {
-        return Promise.resolve(this._bodyText)
-      }
-    };
+	      if (this._bodyBlob) {
+	        return readBlobAsText(this._bodyBlob)
+	      } else if (this._bodyArrayBuffer) {
+	        return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer))
+	      } else if (this._bodyFormData) {
+	        throw new Error('could not read FormData body as text')
+	      } else {
+	        return Promise.resolve(this._bodyText)
+	      }
+	    };
 
-    if (support.formData) {
-      this.formData = function() {
-        return this.text().then(decode)
-      };
-    }
+	    if (support.formData) {
+	      this.formData = function() {
+	        return this.text().then(decode)
+	      };
+	    }
 
-    this.json = function() {
-      return this.text().then(JSON.parse)
-    };
+	    this.json = function() {
+	      return this.text().then(JSON.parse)
+	    };
 
-    return this
-  }
+	    return this
+	  }
 
-  // HTTP methods whose capitalization should be normalized
-  var methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT'];
+	  // HTTP methods whose capitalization should be normalized
+	  var methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT'];
 
-  function normalizeMethod(method) {
-    var upcased = method.toUpperCase();
-    return methods.indexOf(upcased) > -1 ? upcased : method
-  }
+	  function normalizeMethod(method) {
+	    var upcased = method.toUpperCase();
+	    return methods.indexOf(upcased) > -1 ? upcased : method
+	  }
 
-  function Request(input, options) {
-    if (!(this instanceof Request)) {
-      throw new TypeError('Please use the "new" operator, this DOM object constructor cannot be called as a function.')
-    }
+	  function Request(input, options) {
+	    if (!(this instanceof Request)) {
+	      throw new TypeError('Please use the "new" operator, this DOM object constructor cannot be called as a function.')
+	    }
 
-    options = options || {};
-    var body = options.body;
+	    options = options || {};
+	    var body = options.body;
 
-    if (input instanceof Request) {
-      if (input.bodyUsed) {
-        throw new TypeError('Already read')
-      }
-      this.url = input.url;
-      this.credentials = input.credentials;
-      if (!options.headers) {
-        this.headers = new Headers(input.headers);
-      }
-      this.method = input.method;
-      this.mode = input.mode;
-      this.signal = input.signal;
-      if (!body && input._bodyInit != null) {
-        body = input._bodyInit;
-        input.bodyUsed = true;
-      }
-    } else {
-      this.url = String(input);
-    }
+	    if (input instanceof Request) {
+	      if (input.bodyUsed) {
+	        throw new TypeError('Already read')
+	      }
+	      this.url = input.url;
+	      this.credentials = input.credentials;
+	      if (!options.headers) {
+	        this.headers = new Headers(input.headers);
+	      }
+	      this.method = input.method;
+	      this.mode = input.mode;
+	      this.signal = input.signal;
+	      if (!body && input._bodyInit != null) {
+	        body = input._bodyInit;
+	        input.bodyUsed = true;
+	      }
+	    } else {
+	      this.url = String(input);
+	    }
 
-    this.credentials = options.credentials || this.credentials || 'same-origin';
-    if (options.headers || !this.headers) {
-      this.headers = new Headers(options.headers);
-    }
-    this.method = normalizeMethod(options.method || this.method || 'GET');
-    this.mode = options.mode || this.mode || null;
-    this.signal = options.signal || this.signal;
-    this.referrer = null;
+	    this.credentials = options.credentials || this.credentials || 'same-origin';
+	    if (options.headers || !this.headers) {
+	      this.headers = new Headers(options.headers);
+	    }
+	    this.method = normalizeMethod(options.method || this.method || 'GET');
+	    this.mode = options.mode || this.mode || null;
+	    this.signal = options.signal || this.signal;
+	    this.referrer = null;
 
-    if ((this.method === 'GET' || this.method === 'HEAD') && body) {
-      throw new TypeError('Body not allowed for GET or HEAD requests')
-    }
-    this._initBody(body);
+	    if ((this.method === 'GET' || this.method === 'HEAD') && body) {
+	      throw new TypeError('Body not allowed for GET or HEAD requests')
+	    }
+	    this._initBody(body);
+
+	    if (this.method === 'GET' || this.method === 'HEAD') {
+	      if (options.cache === 'no-store' || options.cache === 'no-cache') {
+	        // Search for a '_' parameter in the query string
+	        var reParamSearch = /([?&])_=[^&]*/;
+	        if (reParamSearch.test(this.url)) {
+	          // If it already exists then set the value with the current time
+	          this.url = this.url.replace(reParamSearch, '$1_=' + new Date().getTime());
+	        } else {
+	          // Otherwise add a new '_' parameter to the end with the current time
+	          var reQueryString = /\?/;
+	          this.url += (reQueryString.test(this.url) ? '&' : '?') + '_=' + new Date().getTime();
+	        }
+	      }
+	    }
+	  }
 
-    if (this.method === 'GET' || this.method === 'HEAD') {
-      if (options.cache === 'no-store' || options.cache === 'no-cache') {
-        // Search for a '_' parameter in the query string
-        var reParamSearch = /([?&])_=[^&]*/;
-        if (reParamSearch.test(this.url)) {
-          // If it already exists then set the value with the current time
-          this.url = this.url.replace(reParamSearch, '$1_=' + new Date().getTime());
-        } else {
-          // Otherwise add a new '_' parameter to the end with the current time
-          var reQueryString = /\?/;
-          this.url += (reQueryString.test(this.url) ? '&' : '?') + '_=' + new Date().getTime();
-        }
-      }
-    }
-  }
+	  Request.prototype.clone = function() {
+	    return new Request(this, {body: this._bodyInit})
+	  };
 
-  Request.prototype.clone = function() {
-    return new Request(this, {body: this._bodyInit})
-  };
+	  function decode(body) {
+	    var form = new FormData();
+	    body
+	      .trim()
+	      .split('&')
+	      .forEach(function(bytes) {
+	        if (bytes) {
+	          var split = bytes.split('=');
+	          var name = split.shift().replace(/\+/g, ' ');
+	          var value = split.join('=').replace(/\+/g, ' ');
+	          form.append(decodeURIComponent(name), decodeURIComponent(value));
+	        }
+	      });
+	    return form
+	  }
 
-  function decode(body) {
-    var form = new FormData();
-    body
-      .trim()
-      .split('&')
-      .forEach(function(bytes) {
-        if (bytes) {
-          var split = bytes.split('=');
-          var name = split.shift().replace(/\+/g, ' ');
-          var value = split.join('=').replace(/\+/g, ' ');
-          form.append(decodeURIComponent(name), decodeURIComponent(value));
-        }
-      });
-    return form
-  }
-
-  function parseHeaders(rawHeaders) {
-    var headers = new Headers();
-    // Replace instances of \r\n and \n followed by at least one space or horizontal tab with a space
-    // https://tools.ietf.org/html/rfc7230#section-3.2
-    var preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, ' ');
-    // Avoiding split via regex to work around a common IE11 bug with the core-js 3.6.0 regex polyfill
-    // https://github.com/github/fetch/issues/748
-    // https://github.com/zloirock/core-js/issues/751
-    preProcessedHeaders
-      .split('\r')
-      .map(function(header) {
-        return header.indexOf('\n') === 0 ? header.substr(1, header.length) : header
-      })
-      .forEach(function(line) {
-        var parts = line.split(':');
-        var key = parts.shift().trim();
-        if (key) {
-          var value = parts.join(':').trim();
-          headers.append(key, value);
-        }
-      });
-    return headers
-  }
+	  function parseHeaders(rawHeaders) {
+	    var headers = new Headers();
+	    // Replace instances of \r\n and \n followed by at least one space or horizontal tab with a space
+	    // https://tools.ietf.org/html/rfc7230#section-3.2
+	    var preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, ' ');
+	    // Avoiding split via regex to work around a common IE11 bug with the core-js 3.6.0 regex polyfill
+	    // https://github.com/github/fetch/issues/748
+	    // https://github.com/zloirock/core-js/issues/751
+	    preProcessedHeaders
+	      .split('\r')
+	      .map(function(header) {
+	        return header.indexOf('\n') === 0 ? header.substr(1, header.length) : header
+	      })
+	      .forEach(function(line) {
+	        var parts = line.split(':');
+	        var key = parts.shift().trim();
+	        if (key) {
+	          var value = parts.join(':').trim();
+	          headers.append(key, value);
+	        }
+	      });
+	    return headers
+	  }
 
-  Body.call(Request.prototype);
+	  Body.call(Request.prototype);
 
-  function Response(bodyInit, options) {
-    if (!(this instanceof Response)) {
-      throw new TypeError('Please use the "new" operator, this DOM object constructor cannot be called as a function.')
-    }
-    if (!options) {
-      options = {};
-    }
+	  function Response(bodyInit, options) {
+	    if (!(this instanceof Response)) {
+	      throw new TypeError('Please use the "new" operator, this DOM object constructor cannot be called as a function.')
+	    }
+	    if (!options) {
+	      options = {};
+	    }
 
-    this.type = 'default';
-    this.status = options.status === undefined ? 200 : options.status;
-    this.ok = this.status >= 200 && this.status < 300;
-    this.statusText = options.statusText === undefined ? '' : '' + options.statusText;
-    this.headers = new Headers(options.headers);
-    this.url = options.url || '';
-    this._initBody(bodyInit);
-  }
+	    this.type = 'default';
+	    this.status = options.status === undefined ? 200 : options.status;
+	    this.ok = this.status >= 200 && this.status < 300;
+	    this.statusText = options.statusText === undefined ? '' : '' + options.statusText;
+	    this.headers = new Headers(options.headers);
+	    this.url = options.url || '';
+	    this._initBody(bodyInit);
+	  }
 
-  Body.call(Response.prototype);
+	  Body.call(Response.prototype);
 
-  Response.prototype.clone = function() {
-    return new Response(this._bodyInit, {
-      status: this.status,
-      statusText: this.statusText,
-      headers: new Headers(this.headers),
-      url: this.url
-    })
-  };
+	  Response.prototype.clone = function() {
+	    return new Response(this._bodyInit, {
+	      status: this.status,
+	      statusText: this.statusText,
+	      headers: new Headers(this.headers),
+	      url: this.url
+	    })
+	  };
 
-  Response.error = function() {
-    var response = new Response(null, {status: 0, statusText: ''});
-    response.type = 'error';
-    return response
-  };
+	  Response.error = function() {
+	    var response = new Response(null, {status: 0, statusText: ''});
+	    response.type = 'error';
+	    return response
+	  };
 
-  var redirectStatuses = [301, 302, 303, 307, 308];
+	  var redirectStatuses = [301, 302, 303, 307, 308];
 
-  Response.redirect = function(url, status) {
-    if (redirectStatuses.indexOf(status) === -1) {
-      throw new RangeError('Invalid status code')
-    }
+	  Response.redirect = function(url, status) {
+	    if (redirectStatuses.indexOf(status) === -1) {
+	      throw new RangeError('Invalid status code')
+	    }
 
-    return new Response(null, {status: status, headers: {location: url}})
-  };
+	    return new Response(null, {status: status, headers: {location: url}})
+	  };
 
-  exports.DOMException = global.DOMException;
-  try {
-    new exports.DOMException();
-  } catch (err) {
-    exports.DOMException = function(message, name) {
-      this.message = message;
-      this.name = name;
-      var error = Error(message);
-      this.stack = error.stack;
-    };
-    exports.DOMException.prototype = Object.create(Error.prototype);
-    exports.DOMException.prototype.constructor = exports.DOMException;
-  }
+	  exports.DOMException = global.DOMException;
+	  try {
+	    new exports.DOMException();
+	  } catch (err) {
+	    exports.DOMException = function(message, name) {
+	      this.message = message;
+	      this.name = name;
+	      var error = Error(message);
+	      this.stack = error.stack;
+	    };
+	    exports.DOMException.prototype = Object.create(Error.prototype);
+	    exports.DOMException.prototype.constructor = exports.DOMException;
+	  }
 
-  function fetch(input, init) {
-    return new Promise(function(resolve, reject) {
-      var request = new Request(input, init);
+	  function fetch(input, init) {
+	    return new Promise(function(resolve, reject) {
+	      var request = new Request(input, init);
 
-      if (request.signal && request.signal.aborted) {
-        return reject(new exports.DOMException('Aborted', 'AbortError'))
-      }
+	      if (request.signal && request.signal.aborted) {
+	        return reject(new exports.DOMException('Aborted', 'AbortError'))
+	      }
 
-      var xhr = new XMLHttpRequest();
+	      var xhr = new XMLHttpRequest();
 
-      function abortXhr() {
-        xhr.abort();
-      }
+	      function abortXhr() {
+	        xhr.abort();
+	      }
 
-      xhr.onload = function() {
-        var options = {
-          status: xhr.status,
-          statusText: xhr.statusText,
-          headers: parseHeaders(xhr.getAllResponseHeaders() || '')
-        };
-        options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL');
-        var body = 'response' in xhr ? xhr.response : xhr.responseText;
-        setTimeout(function() {
-          resolve(new Response(body, options));
-        }, 0);
-      };
+	      xhr.onload = function() {
+	        var options = {
+	          status: xhr.status,
+	          statusText: xhr.statusText,
+	          headers: parseHeaders(xhr.getAllResponseHeaders() || '')
+	        };
+	        options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL');
+	        var body = 'response' in xhr ? xhr.response : xhr.responseText;
+	        setTimeout(function() {
+	          resolve(new Response(body, options));
+	        }, 0);
+	      };
 
-      xhr.onerror = function() {
-        setTimeout(function() {
-          reject(new TypeError('Network request failed'));
-        }, 0);
-      };
+	      xhr.onerror = function() {
+	        setTimeout(function() {
+	          reject(new TypeError('Network request failed'));
+	        }, 0);
+	      };
 
-      xhr.ontimeout = function() {
-        setTimeout(function() {
-          reject(new TypeError('Network request failed'));
-        }, 0);
-      };
+	      xhr.ontimeout = function() {
+	        setTimeout(function() {
+	          reject(new TypeError('Network request failed'));
+	        }, 0);
+	      };
 
-      xhr.onabort = function() {
-        setTimeout(function() {
-          reject(new exports.DOMException('Aborted', 'AbortError'));
-        }, 0);
-      };
+	      xhr.onabort = function() {
+	        setTimeout(function() {
+	          reject(new exports.DOMException('Aborted', 'AbortError'));
+	        }, 0);
+	      };
 
-      function fixUrl(url) {
-        try {
-          return url === '' && global.location.href ? global.location.href : url
-        } catch (e) {
-          return url
-        }
-      }
+	      function fixUrl(url) {
+	        try {
+	          return url === '' && global.location.href ? global.location.href : url
+	        } catch (e) {
+	          return url
+	        }
+	      }
 
-      xhr.open(request.method, fixUrl(request.url), true);
+	      xhr.open(request.method, fixUrl(request.url), true);
 
-      if (request.credentials === 'include') {
-        xhr.withCredentials = true;
-      } else if (request.credentials === 'omit') {
-        xhr.withCredentials = false;
-      }
+	      if (request.credentials === 'include') {
+	        xhr.withCredentials = true;
+	      } else if (request.credentials === 'omit') {
+	        xhr.withCredentials = false;
+	      }
 
-      if ('responseType' in xhr) {
-        if (support.blob) {
-          xhr.responseType = 'blob';
-        } else if (
-          support.arrayBuffer &&
-          request.headers.get('Content-Type') &&
-          request.headers.get('Content-Type').indexOf('application/octet-stream') !== -1
-        ) {
-          xhr.responseType = 'arraybuffer';
-        }
-      }
+	      if ('responseType' in xhr) {
+	        if (support.blob) {
+	          xhr.responseType = 'blob';
+	        } else if (
+	          support.arrayBuffer &&
+	          request.headers.get('Content-Type') &&
+	          request.headers.get('Content-Type').indexOf('application/octet-stream') !== -1
+	        ) {
+	          xhr.responseType = 'arraybuffer';
+	        }
+	      }
 
-      if (init && typeof init.headers === 'object' && !(init.headers instanceof Headers)) {
-        Object.getOwnPropertyNames(init.headers).forEach(function(name) {
-          xhr.setRequestHeader(name, normalizeValue(init.headers[name]));
-        });
-      } else {
-        request.headers.forEach(function(value, name) {
-          xhr.setRequestHeader(name, value);
-        });
-      }
+	      if (init && typeof init.headers === 'object' && !(init.headers instanceof Headers)) {
+	        Object.getOwnPropertyNames(init.headers).forEach(function(name) {
+	          xhr.setRequestHeader(name, normalizeValue(init.headers[name]));
+	        });
+	      } else {
+	        request.headers.forEach(function(value, name) {
+	          xhr.setRequestHeader(name, value);
+	        });
+	      }
 
-      if (request.signal) {
-        request.signal.addEventListener('abort', abortXhr);
+	      if (request.signal) {
+	        request.signal.addEventListener('abort', abortXhr);
 
-        xhr.onreadystatechange = function() {
-          // DONE (success or failure)
-          if (xhr.readyState === 4) {
-            request.signal.removeEventListener('abort', abortXhr);
-          }
-        };
-      }
+	        xhr.onreadystatechange = function() {
+	          // DONE (success or failure)
+	          if (xhr.readyState === 4) {
+	            request.signal.removeEventListener('abort', abortXhr);
+	          }
+	        };
+	      }
 
-      xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit);
-    })
-  }
+	      xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit);
+	    })
+	  }
 
-  fetch.polyfill = true;
+	  fetch.polyfill = true;
 
-  if (!global.fetch) {
-    global.fetch = fetch;
-    global.Headers = Headers;
-    global.Request = Request;
-    global.Response = Response;
-  }
+	  if (!global.fetch) {
+	    global.fetch = fetch;
+	    global.Headers = Headers;
+	    global.Request = Request;
+	    global.Response = Response;
+	  }
 
-  exports.Headers = Headers;
-  exports.Request = Request;
-  exports.Response = Response;
-  exports.fetch = fetch;
+	  exports.Headers = Headers;
+	  exports.Request = Request;
+	  exports.Response = Response;
+	  exports.fetch = fetch;
 
-  return exports;
+	  return exports;
 
-}))({});
-})(typeof self !== 'undefined' ? self : commonjsGlobal);
+	}))({});
+	})(typeof self !== 'undefined' ? self : browserPolyfill);
+	return browserPolyfill;
+}
+
+requireBrowserPolyfill();
 
 var global$1 = (typeof global !== "undefined" ? global :
   typeof self !== "undefined" ? self :
@@ -1048,553 +1059,587 @@ function requireMs () {
 	return ms;
 }
 
-/**
- * This is the common logic for both the Node.js and web browser
- * implementations of `debug()`.
- */
-
-function setup(env) {
-	createDebug.debug = createDebug;
-	createDebug.default = createDebug;
-	createDebug.coerce = coerce;
-	createDebug.disable = disable;
-	createDebug.enable = enable;
-	createDebug.enabled = enabled;
-	createDebug.humanize = requireMs();
-	createDebug.destroy = destroy;
-
-	Object.keys(env).forEach(key => {
-		createDebug[key] = env[key];
-	});
+var common;
+var hasRequiredCommon;
 
+function requireCommon () {
+	if (hasRequiredCommon) return common;
+	hasRequiredCommon = 1;
 	/**
-	* The currently active debug mode names, and names to skip.
-	*/
+	 * This is the common logic for both the Node.js and web browser
+	 * implementations of `debug()`.
+	 */
 
-	createDebug.names = [];
-	createDebug.skips = [];
+	function setup(env) {
+		createDebug.debug = createDebug;
+		createDebug.default = createDebug;
+		createDebug.coerce = coerce;
+		createDebug.disable = disable;
+		createDebug.enable = enable;
+		createDebug.enabled = enabled;
+		createDebug.humanize = requireMs();
+		createDebug.destroy = destroy;
+
+		Object.keys(env).forEach(key => {
+			createDebug[key] = env[key];
+		});
 
-	/**
-	* Map of special "%n" handling functions, for the debug "format" argument.
-	*
-	* Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
-	*/
-	createDebug.formatters = {};
+		/**
+		* The currently active debug mode names, and names to skip.
+		*/
 
-	/**
-	* Selects a color for a debug namespace
-	* @param {String} namespace The namespace string for the debug instance to be colored
-	* @return {Number|String} An ANSI color code for the given namespace
-	* @api private
-	*/
-	function selectColor(namespace) {
-		let hash = 0;
-
-		for (let i = 0; i < namespace.length; i++) {
-			hash = ((hash << 5) - hash) + namespace.charCodeAt(i);
-			hash |= 0; // Convert to 32bit integer
-		}
+		createDebug.names = [];
+		createDebug.skips = [];
 
-		return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
-	}
-	createDebug.selectColor = selectColor;
+		/**
+		* Map of special "%n" handling functions, for the debug "format" argument.
+		*
+		* Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
+		*/
+		createDebug.formatters = {};
+
+		/**
+		* Selects a color for a debug namespace
+		* @param {String} namespace The namespace string for the debug instance to be colored
+		* @return {Number|String} An ANSI color code for the given namespace
+		* @api private
+		*/
+		function selectColor(namespace) {
+			let hash = 0;
+
+			for (let i = 0; i < namespace.length; i++) {
+				hash = ((hash << 5) - hash) + namespace.charCodeAt(i);
+				hash |= 0; // Convert to 32bit integer
+			}
 
-	/**
-	* Create a debugger with the given `namespace`.
-	*
-	* @param {String} namespace
-	* @return {Function}
-	* @api public
-	*/
-	function createDebug(namespace) {
-		let prevTime;
-		let enableOverride = null;
-		let namespacesCache;
-		let enabledCache;
-
-		function debug(...args) {
-			// Disabled?
-			if (!debug.enabled) {
-				return;
-			}
+			return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+		}
+		createDebug.selectColor = selectColor;
+
+		/**
+		* Create a debugger with the given `namespace`.
+		*
+		* @param {String} namespace
+		* @return {Function}
+		* @api public
+		*/
+		function createDebug(namespace) {
+			let prevTime;
+			let enableOverride = null;
+			let namespacesCache;
+			let enabledCache;
+
+			function debug(...args) {
+				// Disabled?
+				if (!debug.enabled) {
+					return;
+				}
 
-			const self = debug;
+				const self = debug;
 
-			// Set `diff` timestamp
-			const curr = Number(new Date());
-			const ms = curr - (prevTime || curr);
-			self.diff = ms;
-			self.prev = prevTime;
-			self.curr = curr;
-			prevTime = curr;
+				// Set `diff` timestamp
+				const curr = Number(new Date());
+				const ms = curr - (prevTime || curr);
+				self.diff = ms;
+				self.prev = prevTime;
+				self.curr = curr;
+				prevTime = curr;
 
-			args[0] = createDebug.coerce(args[0]);
+				args[0] = createDebug.coerce(args[0]);
 
-			if (typeof args[0] !== 'string') {
-				// Anything else let's inspect with %O
-				args.unshift('%O');
+				if (typeof args[0] !== 'string') {
+					// Anything else let's inspect with %O
+					args.unshift('%O');
+				}
+
+				// Apply any `formatters` transformations
+				let index = 0;
+				args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+					// If we encounter an escaped % then don't increase the array index
+					if (match === '%%') {
+						return '%';
+					}
+					index++;
+					const formatter = createDebug.formatters[format];
+					if (typeof formatter === 'function') {
+						const val = args[index];
+						match = formatter.call(self, val);
+
+						// Now we need to remove `args[index]` since it's inlined in the `format`
+						args.splice(index, 1);
+						index--;
+					}
+					return match;
+				});
+
+				// Apply env-specific formatting (colors, etc.)
+				createDebug.formatArgs.call(self, args);
+
+				const logFn = self.log || createDebug.log;
+				logFn.apply(self, args);
 			}
 
-			// Apply any `formatters` transformations
-			let index = 0;
-			args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
-				// If we encounter an escaped % then don't increase the array index
-				if (match === '%%') {
-					return '%';
-				}
-				index++;
-				const formatter = createDebug.formatters[format];
-				if (typeof formatter === 'function') {
-					const val = args[index];
-					match = formatter.call(self, val);
-
-					// Now we need to remove `args[index]` since it's inlined in the `format`
-					args.splice(index, 1);
-					index--;
+			debug.namespace = namespace;
+			debug.useColors = createDebug.useColors();
+			debug.color = createDebug.selectColor(namespace);
+			debug.extend = extend;
+			debug.destroy = createDebug.destroy; // XXX Temporary. Will be removed in the next major release.
+
+			Object.defineProperty(debug, 'enabled', {
+				enumerable: true,
+				configurable: false,
+				get: () => {
+					if (enableOverride !== null) {
+						return enableOverride;
+					}
+					if (namespacesCache !== createDebug.namespaces) {
+						namespacesCache = createDebug.namespaces;
+						enabledCache = createDebug.enabled(namespace);
+					}
+
+					return enabledCache;
+				},
+				set: v => {
+					enableOverride = v;
 				}
-				return match;
 			});
 
-			// Apply env-specific formatting (colors, etc.)
-			createDebug.formatArgs.call(self, args);
+			// Env-specific initialization logic for debug instances
+			if (typeof createDebug.init === 'function') {
+				createDebug.init(debug);
+			}
 
-			const logFn = self.log || createDebug.log;
-			logFn.apply(self, args);
+			return debug;
 		}
 
-		debug.namespace = namespace;
-		debug.useColors = createDebug.useColors();
-		debug.color = createDebug.selectColor(namespace);
-		debug.extend = extend;
-		debug.destroy = createDebug.destroy; // XXX Temporary. Will be removed in the next major release.
+		function extend(namespace, delimiter) {
+			const newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
+			newDebug.log = this.log;
+			return newDebug;
+		}
 
-		Object.defineProperty(debug, 'enabled', {
-			enumerable: true,
-			configurable: false,
-			get: () => {
-				if (enableOverride !== null) {
-					return enableOverride;
+		/**
+		* Enables a debug mode by namespaces. This can include modes
+		* separated by a colon and wildcards.
+		*
+		* @param {String} namespaces
+		* @api public
+		*/
+		function enable(namespaces) {
+			createDebug.save(namespaces);
+			createDebug.namespaces = namespaces;
+
+			createDebug.names = [];
+			createDebug.skips = [];
+
+			const split = (typeof namespaces === 'string' ? namespaces : '')
+				.trim()
+				.replace(' ', ',')
+				.split(',')
+				.filter(Boolean);
+
+			for (const ns of split) {
+				if (ns[0] === '-') {
+					createDebug.skips.push(ns.slice(1));
+				} else {
+					createDebug.names.push(ns);
 				}
-				if (namespacesCache !== createDebug.namespaces) {
-					namespacesCache = createDebug.namespaces;
-					enabledCache = createDebug.enabled(namespace);
-				}
-
-				return enabledCache;
-			},
-			set: v => {
-				enableOverride = v;
 			}
-		});
-
-		// Env-specific initialization logic for debug instances
-		if (typeof createDebug.init === 'function') {
-			createDebug.init(debug);
 		}
 
-		return debug;
-	}
-
-	function extend(namespace, delimiter) {
-		const newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
-		newDebug.log = this.log;
-		return newDebug;
-	}
-
-	/**
-	* Enables a debug mode by namespaces. This can include modes
-	* separated by a colon and wildcards.
-	*
-	* @param {String} namespaces
-	* @api public
-	*/
-	function enable(namespaces) {
-		createDebug.save(namespaces);
-		createDebug.namespaces = namespaces;
-
-		createDebug.names = [];
-		createDebug.skips = [];
-
-		let i;
-		const split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
-		const len = split.length;
-
-		for (i = 0; i < len; i++) {
-			if (!split[i]) {
-				// ignore empty strings
-				continue;
+		/**
+		 * Checks if the given string matches a namespace template, honoring
+		 * asterisks as wildcards.
+		 *
+		 * @param {String} search
+		 * @param {String} template
+		 * @return {Boolean}
+		 */
+		function matchesTemplate(search, template) {
+			let searchIndex = 0;
+			let templateIndex = 0;
+			let starIndex = -1;
+			let matchIndex = 0;
+
+			while (searchIndex < search.length) {
+				if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === '*')) {
+					// Match character or proceed with wildcard
+					if (template[templateIndex] === '*') {
+						starIndex = templateIndex;
+						matchIndex = searchIndex;
+						templateIndex++; // Skip the '*'
+					} else {
+						searchIndex++;
+						templateIndex++;
+					}
+				} else if (starIndex !== -1) { // eslint-disable-line no-negated-condition
+					// Backtrack to the last '*' and try to match more characters
+					templateIndex = starIndex + 1;
+					matchIndex++;
+					searchIndex = matchIndex;
+				} else {
+					return false; // No match
+				}
 			}
 
-			namespaces = split[i].replace(/\*/g, '.*?');
-
-			if (namespaces[0] === '-') {
-				createDebug.skips.push(new RegExp('^' + namespaces.slice(1) + '$'));
-			} else {
-				createDebug.names.push(new RegExp('^' + namespaces + '$'));
+			// Handle trailing '*' in template
+			while (templateIndex < template.length && template[templateIndex] === '*') {
+				templateIndex++;
 			}
-		}
-	}
 
-	/**
-	* Disable debug output.
-	*
-	* @return {String} namespaces
-	* @api public
-	*/
-	function disable() {
-		const namespaces = [
-			...createDebug.names.map(toNamespace),
-			...createDebug.skips.map(toNamespace).map(namespace => '-' + namespace)
-		].join(',');
-		createDebug.enable('');
-		return namespaces;
-	}
+			return templateIndex === template.length;
+		}
 
-	/**
-	* Returns true if the given mode name is enabled, false otherwise.
-	*
-	* @param {String} name
-	* @return {Boolean}
-	* @api public
-	*/
-	function enabled(name) {
-		if (name[name.length - 1] === '*') {
-			return true;
+		/**
+		* Disable debug output.
+		*
+		* @return {String} namespaces
+		* @api public
+		*/
+		function disable() {
+			const namespaces = [
+				...createDebug.names,
+				...createDebug.skips.map(namespace => '-' + namespace)
+			].join(',');
+			createDebug.enable('');
+			return namespaces;
 		}
 
-		let i;
-		let len;
+		/**
+		* Returns true if the given mode name is enabled, false otherwise.
+		*
+		* @param {String} name
+		* @return {Boolean}
+		* @api public
+		*/
+		function enabled(name) {
+			for (const skip of createDebug.skips) {
+				if (matchesTemplate(name, skip)) {
+					return false;
+				}
+			}
 
-		for (i = 0, len = createDebug.skips.length; i < len; i++) {
-			if (createDebug.skips[i].test(name)) {
-				return false;
+			for (const ns of createDebug.names) {
+				if (matchesTemplate(name, ns)) {
+					return true;
+				}
 			}
+
+			return false;
 		}
 
-		for (i = 0, len = createDebug.names.length; i < len; i++) {
-			if (createDebug.names[i].test(name)) {
-				return true;
+		/**
+		* Coerce `val`.
+		*
+		* @param {Mixed} val
+		* @return {Mixed}
+		* @api private
+		*/
+		function coerce(val) {
+			if (val instanceof Error) {
+				return val.stack || val.message;
 			}
+			return val;
 		}
 
-		return false;
-	}
-
-	/**
-	* Convert regexp to namespace
-	*
-	* @param {RegExp} regxep
-	* @return {String} namespace
-	* @api private
-	*/
-	function toNamespace(regexp) {
-		return regexp.toString()
-			.substring(2, regexp.toString().length - 2)
-			.replace(/\.\*\?$/, '*');
-	}
-
-	/**
-	* Coerce `val`.
-	*
-	* @param {Mixed} val
-	* @return {Mixed}
-	* @api private
-	*/
-	function coerce(val) {
-		if (val instanceof Error) {
-			return val.stack || val.message;
+		/**
+		* XXX DO NOT USE. This is a temporary stub function.
+		* XXX It WILL be removed in the next major release.
+		*/
+		function destroy() {
+			console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
 		}
-		return val;
-	}
 
-	/**
-	* XXX DO NOT USE. This is a temporary stub function.
-	* XXX It WILL be removed in the next major release.
-	*/
-	function destroy() {
-		console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
-	}
+		createDebug.enable(createDebug.load());
 
-	createDebug.enable(createDebug.load());
+		return createDebug;
+	}
 
-	return createDebug;
+	common = setup;
+	return common;
 }
 
-var common = setup;
-
-(function (module, exports) {
-	/**
-	 * This is the web browser implementation of `debug()`.
-	 */
-
-	exports.formatArgs = formatArgs;
-	exports.save = save;
-	exports.load = load;
-	exports.useColors = useColors;
-	exports.storage = localstorage();
-	exports.destroy = (() => {
-		let warned = false;
-
-		return () => {
-			if (!warned) {
-				warned = true;
-				console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
-			}
-		};
-	})();
-
-	/**
-	 * Colors.
-	 */
-
-	exports.colors = [
-		'#0000CC',
-		'#0000FF',
-		'#0033CC',
-		'#0033FF',
-		'#0066CC',
-		'#0066FF',
-		'#0099CC',
-		'#0099FF',
-		'#00CC00',
-		'#00CC33',
-		'#00CC66',
-		'#00CC99',
-		'#00CCCC',
-		'#00CCFF',
-		'#3300CC',
-		'#3300FF',
-		'#3333CC',
-		'#3333FF',
-		'#3366CC',
-		'#3366FF',
-		'#3399CC',
-		'#3399FF',
-		'#33CC00',
-		'#33CC33',
-		'#33CC66',
-		'#33CC99',
-		'#33CCCC',
-		'#33CCFF',
-		'#6600CC',
-		'#6600FF',
-		'#6633CC',
-		'#6633FF',
-		'#66CC00',
-		'#66CC33',
-		'#9900CC',
-		'#9900FF',
-		'#9933CC',
-		'#9933FF',
-		'#99CC00',
-		'#99CC33',
-		'#CC0000',
-		'#CC0033',
-		'#CC0066',
-		'#CC0099',
-		'#CC00CC',
-		'#CC00FF',
-		'#CC3300',
-		'#CC3333',
-		'#CC3366',
-		'#CC3399',
-		'#CC33CC',
-		'#CC33FF',
-		'#CC6600',
-		'#CC6633',
-		'#CC9900',
-		'#CC9933',
-		'#CCCC00',
-		'#CCCC33',
-		'#FF0000',
-		'#FF0033',
-		'#FF0066',
-		'#FF0099',
-		'#FF00CC',
-		'#FF00FF',
-		'#FF3300',
-		'#FF3333',
-		'#FF3366',
-		'#FF3399',
-		'#FF33CC',
-		'#FF33FF',
-		'#FF6600',
-		'#FF6633',
-		'#FF9900',
-		'#FF9933',
-		'#FFCC00',
-		'#FFCC33'
-	];
-
-	/**
-	 * Currently only WebKit-based Web Inspectors, Firefox >= v31,
-	 * and the Firebug extension (any Firefox version) are known
-	 * to support "%c" CSS customizations.
-	 *
-	 * TODO: add a `localStorage` variable to explicitly enable/disable colors
-	 */
-
-	// eslint-disable-next-line complexity
-	function useColors() {
-		// NB: In an Electron preload script, document will be defined but not fully
-		// initialized. Since we know we're in Chrome, we'll just detect this case
-		// explicitly
-		if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
-			return true;
-		}
+var hasRequiredBrowser;
 
-		// Internet Explorer and Edge do not support colors.
-		if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
-			return false;
-		}
+function requireBrowser () {
+	if (hasRequiredBrowser) return browser.exports;
+	hasRequiredBrowser = 1;
+	(function (module, exports) {
+		/**
+		 * This is the web browser implementation of `debug()`.
+		 */
 
-		let m;
-
-		// Is webkit? http://stackoverflow.com/a/16459606/376773
-		// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
-		return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
-			// Is firebug? http://stackoverflow.com/a/398120/376773
-			(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
-			// Is firefox >= v31?
-			// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
-			(typeof navigator !== 'undefined' && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31) ||
-			// Double check webkit in userAgent just in case we are in a worker
-			(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
-	}
+		exports.formatArgs = formatArgs;
+		exports.save = save;
+		exports.load = load;
+		exports.useColors = useColors;
+		exports.storage = localstorage();
+		exports.destroy = (() => {
+			let warned = false;
 
-	/**
-	 * Colorize log arguments if enabled.
-	 *
-	 * @api public
-	 */
+			return () => {
+				if (!warned) {
+					warned = true;
+					console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
+				}
+			};
+		})();
+
+		/**
+		 * Colors.
+		 */
+
+		exports.colors = [
+			'#0000CC',
+			'#0000FF',
+			'#0033CC',
+			'#0033FF',
+			'#0066CC',
+			'#0066FF',
+			'#0099CC',
+			'#0099FF',
+			'#00CC00',
+			'#00CC33',
+			'#00CC66',
+			'#00CC99',
+			'#00CCCC',
+			'#00CCFF',
+			'#3300CC',
+			'#3300FF',
+			'#3333CC',
+			'#3333FF',
+			'#3366CC',
+			'#3366FF',
+			'#3399CC',
+			'#3399FF',
+			'#33CC00',
+			'#33CC33',
+			'#33CC66',
+			'#33CC99',
+			'#33CCCC',
+			'#33CCFF',
+			'#6600CC',
+			'#6600FF',
+			'#6633CC',
+			'#6633FF',
+			'#66CC00',
+			'#66CC33',
+			'#9900CC',
+			'#9900FF',
+			'#9933CC',
+			'#9933FF',
+			'#99CC00',
+			'#99CC33',
+			'#CC0000',
+			'#CC0033',
+			'#CC0066',
+			'#CC0099',
+			'#CC00CC',
+			'#CC00FF',
+			'#CC3300',
+			'#CC3333',
+			'#CC3366',
+			'#CC3399',
+			'#CC33CC',
+			'#CC33FF',
+			'#CC6600',
+			'#CC6633',
+			'#CC9900',
+			'#CC9933',
+			'#CCCC00',
+			'#CCCC33',
+			'#FF0000',
+			'#FF0033',
+			'#FF0066',
+			'#FF0099',
+			'#FF00CC',
+			'#FF00FF',
+			'#FF3300',
+			'#FF3333',
+			'#FF3366',
+			'#FF3399',
+			'#FF33CC',
+			'#FF33FF',
+			'#FF6600',
+			'#FF6633',
+			'#FF9900',
+			'#FF9933',
+			'#FFCC00',
+			'#FFCC33'
+		];
+
+		/**
+		 * Currently only WebKit-based Web Inspectors, Firefox >= v31,
+		 * and the Firebug extension (any Firefox version) are known
+		 * to support "%c" CSS customizations.
+		 *
+		 * TODO: add a `localStorage` variable to explicitly enable/disable colors
+		 */
+
+		// eslint-disable-next-line complexity
+		function useColors() {
+			// NB: In an Electron preload script, document will be defined but not fully
+			// initialized. Since we know we're in Chrome, we'll just detect this case
+			// explicitly
+			if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
+				return true;
+			}
 
-	function formatArgs(args) {
-		args[0] = (this.useColors ? '%c' : '') +
-			this.namespace +
-			(this.useColors ? ' %c' : ' ') +
-			args[0] +
-			(this.useColors ? '%c ' : ' ') +
-			'+' + module.exports.humanize(this.diff);
+			// Internet Explorer and Edge do not support colors.
+			if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+				return false;
+			}
 
-		if (!this.useColors) {
-			return;
+			let m;
+
+			// Is webkit? http://stackoverflow.com/a/16459606/376773
+			// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
+			// eslint-disable-next-line no-return-assign
+			return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
+				// Is firebug? http://stackoverflow.com/a/398120/376773
+				(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
+				// Is firefox >= v31?
+				// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+				(typeof navigator !== 'undefined' && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31) ||
+				// Double check webkit in userAgent just in case we are in a worker
+				(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
 		}
 
-		const c = 'color: ' + this.color;
-		args.splice(1, 0, c, 'color: inherit');
-
-		// The final "%c" is somewhat tricky, because there could be other
-		// arguments passed either before or after the %c, so we need to
-		// figure out the correct index to insert the CSS into
-		let index = 0;
-		let lastC = 0;
-		args[0].replace(/%[a-zA-Z%]/g, match => {
-			if (match === '%%') {
+		/**
+		 * Colorize log arguments if enabled.
+		 *
+		 * @api public
+		 */
+
+		function formatArgs(args) {
+			args[0] = (this.useColors ? '%c' : '') +
+				this.namespace +
+				(this.useColors ? ' %c' : ' ') +
+				args[0] +
+				(this.useColors ? '%c ' : ' ') +
+				'+' + module.exports.humanize(this.diff);
+
+			if (!this.useColors) {
 				return;
 			}
-			index++;
-			if (match === '%c') {
-				// We only are interested in the *last* %c
-				// (the user may have provided their own)
-				lastC = index;
-			}
-		});
 
-		args.splice(lastC, 0, c);
-	}
+			const c = 'color: ' + this.color;
+			args.splice(1, 0, c, 'color: inherit');
 
-	/**
-	 * Invokes `console.debug()` when available.
-	 * No-op when `console.debug` is not a "function".
-	 * If `console.debug` is not available, falls back
-	 * to `console.log`.
-	 *
-	 * @api public
-	 */
-	exports.log = console.debug || console.log || (() => {});
+			// The final "%c" is somewhat tricky, because there could be other
+			// arguments passed either before or after the %c, so we need to
+			// figure out the correct index to insert the CSS into
+			let index = 0;
+			let lastC = 0;
+			args[0].replace(/%[a-zA-Z%]/g, match => {
+				if (match === '%%') {
+					return;
+				}
+				index++;
+				if (match === '%c') {
+					// We only are interested in the *last* %c
+					// (the user may have provided their own)
+					lastC = index;
+				}
+			});
 
-	/**
-	 * Save `namespaces`.
-	 *
-	 * @param {String} namespaces
-	 * @api private
-	 */
-	function save(namespaces) {
-		try {
-			if (namespaces) {
-				exports.storage.setItem('debug', namespaces);
-			} else {
-				exports.storage.removeItem('debug');
-			}
-		} catch (error) {
-			// Swallow
-			// XXX (@Qix-) should we be logging these?
+			args.splice(lastC, 0, c);
 		}
-	}
 
-	/**
-	 * Load `namespaces`.
-	 *
-	 * @return {String} returns the previously persisted debug modes
-	 * @api private
-	 */
-	function load() {
-		let r;
-		try {
-			r = exports.storage.getItem('debug');
-		} catch (error) {
-			// Swallow
-			// XXX (@Qix-) should we be logging these?
+		/**
+		 * Invokes `console.debug()` when available.
+		 * No-op when `console.debug` is not a "function".
+		 * If `console.debug` is not available, falls back
+		 * to `console.log`.
+		 *
+		 * @api public
+		 */
+		exports.log = console.debug || console.log || (() => {});
+
+		/**
+		 * Save `namespaces`.
+		 *
+		 * @param {String} namespaces
+		 * @api private
+		 */
+		function save(namespaces) {
+			try {
+				if (namespaces) {
+					exports.storage.setItem('debug', namespaces);
+				} else {
+					exports.storage.removeItem('debug');
+				}
+			} catch (error) {
+				// Swallow
+				// XXX (@Qix-) should we be logging these?
+			}
 		}
 
-		// If debug isn't set in LS, and we're in Electron, try to load $DEBUG
-		if (!r && typeof browser$1$1 !== 'undefined' && 'env' in browser$1$1) {
-			r = browser$1$1.env.DEBUG;
-		}
+		/**
+		 * Load `namespaces`.
+		 *
+		 * @return {String} returns the previously persisted debug modes
+		 * @api private
+		 */
+		function load() {
+			let r;
+			try {
+				r = exports.storage.getItem('debug');
+			} catch (error) {
+				// Swallow
+				// XXX (@Qix-) should we be logging these?
+			}
 
-		return r;
-	}
+			// If debug isn't set in LS, and we're in Electron, try to load $DEBUG
+			if (!r && typeof browser$1$1 !== 'undefined' && 'env' in browser$1$1) {
+				r = browser$1$1.env.DEBUG;
+			}
 
-	/**
-	 * Localstorage attempts to return the localstorage.
-	 *
-	 * This is necessary because safari throws
-	 * when a user disables cookies/localstorage
-	 * and you attempt to access it.
-	 *
-	 * @return {LocalStorage}
-	 * @api private
-	 */
+			return r;
+		}
 
-	function localstorage() {
-		try {
-			// TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
-			// The Browser also has localStorage in the global context.
-			return localStorage;
-		} catch (error) {
-			// Swallow
-			// XXX (@Qix-) should we be logging these?
+		/**
+		 * Localstorage attempts to return the localstorage.
+		 *
+		 * This is necessary because safari throws
+		 * when a user disables cookies/localstorage
+		 * and you attempt to access it.
+		 *
+		 * @return {LocalStorage}
+		 * @api private
+		 */
+
+		function localstorage() {
+			try {
+				// TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
+				// The Browser also has localStorage in the global context.
+				return localStorage;
+			} catch (error) {
+				// Swallow
+				// XXX (@Qix-) should we be logging these?
+			}
 		}
-	}
 
-	module.exports = common(exports);
+		module.exports = requireCommon()(exports);
 
-	const {formatters} = module.exports;
+		const {formatters} = module.exports;
 
-	/**
-	 * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
-	 */
+		/**
+		 * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
+		 */
 
-	formatters.j = function (v) {
-		try {
-			return JSON.stringify(v);
-		} catch (error) {
-			return '[UnexpectedJSONParseError]: ' + error.message;
-		}
-	}; 
-} (browser, browser.exports));
+		formatters.j = function (v) {
+			try {
+				return JSON.stringify(v);
+			} catch (error) {
+				return '[UnexpectedJSONParseError]: ' + error.message;
+			}
+		}; 
+	} (browser, browser.exports));
+	return browser.exports;
+}
 
-var browserExports = browser.exports;
+var browserExports = requireBrowser();
 var getLogger = /*@__PURE__*/getDefaultExportFromCjs(browserExports);
 
 var DAVNamespace;
@@ -1827,7 +1872,7 @@ function write (buffer, value, offset, isLE, mLen, nBytes) {
 
 var toString = {}.toString;
 
-var isArray$4 = Array.isArray || function (arr) {
+var isArray$1 = Array.isArray || function (arr) {
   return toString.call(arr) == '[object Array]';
 };
 
@@ -2111,7 +2156,7 @@ function fromObject (that, obj) {
       return fromArrayLike(that, obj)
     }
 
-    if (obj.type === 'Buffer' && isArray$4(obj.data)) {
+    if (obj.type === 'Buffer' && isArray$1(obj.data)) {
       return fromArrayLike(that, obj.data)
     }
   }
@@ -2176,7 +2221,7 @@ Buffer.isEncoding = function isEncoding (encoding) {
 };
 
 Buffer.concat = function concat (list, length) {
-  if (!isArray$4(list)) {
+  if (!isArray$1(list)) {
     throw new TypeError('"list" argument must be an Array of Buffers')
   }
 
@@ -3607,7 +3652,7 @@ function isSlowBuffer (obj) {
   return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isFastBuffer(obj.slice(0, 0))
 }
 
-var sax$1 = {};
+var sax = {};
 
 var domain;
 
@@ -4347,7 +4392,7 @@ function formatValue(ctx, value, recurseTimes) {
   var base = '', array = false, braces = ['{', '}'];
 
   // Make Array say that they are Array
-  if (isArray$3(value)) {
+  if (isArray(value)) {
     array = true;
     braces = ['[', ']'];
   }
@@ -4526,7 +4571,7 @@ function reduceToSingleString(output, base, braces) {
 
 // NOTE: These type checking functions intentionally don't use `instanceof`
 // because it is fragile and can be easily faked with `Object.create()`.
-function isArray$3(ar) {
+function isArray(ar) {
   return Array.isArray(ar);
 }
 
@@ -6566,2386 +6611,2450 @@ var require$$0 = /*@__PURE__*/getAugmentedNamespace(_polyfillNode_stream);
 
 var require$$1 = /*@__PURE__*/getAugmentedNamespace(_polyfillNode_string_decoder);
 
-(function (exports) {
-(function (sax) { // wrapper for non-node envs
-	  sax.parser = function (strict, opt) { return new SAXParser(strict, opt) };
-	  sax.SAXParser = SAXParser;
-	  sax.SAXStream = SAXStream;
-	  sax.createStream = createStream;
-
-	  // When we pass the MAX_BUFFER_LENGTH position, start checking for buffer overruns.
-	  // When we check, schedule the next check for MAX_BUFFER_LENGTH - (max(buffer lengths)),
-	  // since that's the earliest that a buffer overrun could occur.  This way, checks are
-	  // as rare as required, but as often as necessary to ensure never crossing this bound.
-	  // Furthermore, buffers are only tested at most once per write(), so passing a very
-	  // large string into write() might have undesirable effects, but this is manageable by
-	  // the caller, so it is assumed to be safe.  Thus, a call to write() may, in the extreme
-	  // edge case, result in creating at most one complete copy of the string passed in.
-	  // Set to Infinity to have unlimited buffers.
-	  sax.MAX_BUFFER_LENGTH = 64 * 1024;
-
-	  var buffers = [
-	    'comment', 'sgmlDecl', 'textNode', 'tagName', 'doctype',
-	    'procInstName', 'procInstBody', 'entity', 'attribName',
-	    'attribValue', 'cdata', 'script'
-	  ];
-
-	  sax.EVENTS = [
-	    'text',
-	    'processinginstruction',
-	    'sgmldeclaration',
-	    'doctype',
-	    'comment',
-	    'opentagstart',
-	    'attribute',
-	    'opentag',
-	    'closetag',
-	    'opencdata',
-	    'cdata',
-	    'closecdata',
-	    'error',
-	    'end',
-	    'ready',
-	    'script',
-	    'opennamespace',
-	    'closenamespace'
-	  ];
-
-	  function SAXParser (strict, opt) {
-	    if (!(this instanceof SAXParser)) {
-	      return new SAXParser(strict, opt)
-	    }
-
-	    var parser = this;
-	    clearBuffers(parser);
-	    parser.q = parser.c = '';
-	    parser.bufferCheckPosition = sax.MAX_BUFFER_LENGTH;
-	    parser.opt = opt || {};
-	    parser.opt.lowercase = parser.opt.lowercase || parser.opt.lowercasetags;
-	    parser.looseCase = parser.opt.lowercase ? 'toLowerCase' : 'toUpperCase';
-	    parser.tags = [];
-	    parser.closed = parser.closedRoot = parser.sawRoot = false;
-	    parser.tag = parser.error = null;
-	    parser.strict = !!strict;
-	    parser.noscript = !!(strict || parser.opt.noscript);
-	    parser.state = S.BEGIN;
-	    parser.strictEntities = parser.opt.strictEntities;
-	    parser.ENTITIES = parser.strictEntities ? Object.create(sax.XML_ENTITIES) : Object.create(sax.ENTITIES);
-	    parser.attribList = [];
-
-	    // namespaces form a prototype chain.
-	    // it always points at the current tag,
-	    // which protos to its parent tag.
-	    if (parser.opt.xmlns) {
-	      parser.ns = Object.create(rootNS);
-	    }
+var hasRequiredSax;
 
-	    // disallow unquoted attribute values if not otherwise configured
-	    // and strict mode is true
-	    if (parser.opt.unquotedAttributeValues === undefined) {
-	      parser.opt.unquotedAttributeValues = !strict;
-	    }
-
-	    // mostly just for error reporting
-	    parser.trackPosition = parser.opt.position !== false;
-	    if (parser.trackPosition) {
-	      parser.position = parser.line = parser.column = 0;
-	    }
-	    emit(parser, 'onready');
-	  }
-
-	  if (!Object.create) {
-	    Object.create = function (o) {
-	      function F () {}
-	      F.prototype = o;
-	      var newf = new F();
-	      return newf
-	    };
-	  }
-
-	  if (!Object.keys) {
-	    Object.keys = function (o) {
-	      var a = [];
-	      for (var i in o) if (o.hasOwnProperty(i)) a.push(i);
-	      return a
-	    };
-	  }
-
-	  function checkBufferLength (parser) {
-	    var maxAllowed = Math.max(sax.MAX_BUFFER_LENGTH, 10);
-	    var maxActual = 0;
-	    for (var i = 0, l = buffers.length; i < l; i++) {
-	      var len = parser[buffers[i]].length;
-	      if (len > maxAllowed) {
-	        // Text/cdata nodes can get big, and since they're buffered,
-	        // we can get here under normal conditions.
-	        // Avoid issues by emitting the text node now,
-	        // so at least it won't get any bigger.
-	        switch (buffers[i]) {
-	          case 'textNode':
-	            closeText(parser);
-	            break
-
-	          case 'cdata':
-	            emitNode(parser, 'oncdata', parser.cdata);
-	            parser.cdata = '';
-	            break
-
-	          case 'script':
-	            emitNode(parser, 'onscript', parser.script);
-	            parser.script = '';
-	            break
-
-	          default:
-	            error(parser, 'Max buffer length exceeded: ' + buffers[i]);
-	        }
-	      }
-	      maxActual = Math.max(maxActual, len);
-	    }
-	    // schedule the next check for the earliest possible buffer overrun.
-	    var m = sax.MAX_BUFFER_LENGTH - maxActual;
-	    parser.bufferCheckPosition = m + parser.position;
-	  }
-
-	  function clearBuffers (parser) {
-	    for (var i = 0, l = buffers.length; i < l; i++) {
-	      parser[buffers[i]] = '';
-	    }
-	  }
-
-	  function flushBuffers (parser) {
-	    closeText(parser);
-	    if (parser.cdata !== '') {
-	      emitNode(parser, 'oncdata', parser.cdata);
-	      parser.cdata = '';
-	    }
-	    if (parser.script !== '') {
-	      emitNode(parser, 'onscript', parser.script);
-	      parser.script = '';
+function requireSax () {
+	if (hasRequiredSax) return sax;
+	hasRequiredSax = 1;
+	(function (exports) {
+(function (sax) { // wrapper for non-node envs
+		  sax.parser = function (strict, opt) { return new SAXParser(strict, opt) };
+		  sax.SAXParser = SAXParser;
+		  sax.SAXStream = SAXStream;
+		  sax.createStream = createStream;
+
+		  // When we pass the MAX_BUFFER_LENGTH position, start checking for buffer overruns.
+		  // When we check, schedule the next check for MAX_BUFFER_LENGTH - (max(buffer lengths)),
+		  // since that's the earliest that a buffer overrun could occur.  This way, checks are
+		  // as rare as required, but as often as necessary to ensure never crossing this bound.
+		  // Furthermore, buffers are only tested at most once per write(), so passing a very
+		  // large string into write() might have undesirable effects, but this is manageable by
+		  // the caller, so it is assumed to be safe.  Thus, a call to write() may, in the extreme
+		  // edge case, result in creating at most one complete copy of the string passed in.
+		  // Set to Infinity to have unlimited buffers.
+		  sax.MAX_BUFFER_LENGTH = 64 * 1024;
+
+		  var buffers = [
+		    'comment', 'sgmlDecl', 'textNode', 'tagName', 'doctype',
+		    'procInstName', 'procInstBody', 'entity', 'attribName',
+		    'attribValue', 'cdata', 'script'
+		  ];
+
+		  sax.EVENTS = [
+		    'text',
+		    'processinginstruction',
+		    'sgmldeclaration',
+		    'doctype',
+		    'comment',
+		    'opentagstart',
+		    'attribute',
+		    'opentag',
+		    'closetag',
+		    'opencdata',
+		    'cdata',
+		    'closecdata',
+		    'error',
+		    'end',
+		    'ready',
+		    'script',
+		    'opennamespace',
+		    'closenamespace'
+		  ];
+
+		  function SAXParser (strict, opt) {
+		    if (!(this instanceof SAXParser)) {
+		      return new SAXParser(strict, opt)
+		    }
+
+		    var parser = this;
+		    clearBuffers(parser);
+		    parser.q = parser.c = '';
+		    parser.bufferCheckPosition = sax.MAX_BUFFER_LENGTH;
+		    parser.opt = opt || {};
+		    parser.opt.lowercase = parser.opt.lowercase || parser.opt.lowercasetags;
+		    parser.looseCase = parser.opt.lowercase ? 'toLowerCase' : 'toUpperCase';
+		    parser.tags = [];
+		    parser.closed = parser.closedRoot = parser.sawRoot = false;
+		    parser.tag = parser.error = null;
+		    parser.strict = !!strict;
+		    parser.noscript = !!(strict || parser.opt.noscript);
+		    parser.state = S.BEGIN;
+		    parser.strictEntities = parser.opt.strictEntities;
+		    parser.ENTITIES = parser.strictEntities ? Object.create(sax.XML_ENTITIES) : Object.create(sax.ENTITIES);
+		    parser.attribList = [];
+
+		    // namespaces form a prototype chain.
+		    // it always points at the current tag,
+		    // which protos to its parent tag.
+		    if (parser.opt.xmlns) {
+		      parser.ns = Object.create(rootNS);
+		    }
+
+		    // disallow unquoted attribute values if not otherwise configured
+		    // and strict mode is true
+		    if (parser.opt.unquotedAttributeValues === undefined) {
+		      parser.opt.unquotedAttributeValues = !strict;
+		    }
+
+		    // mostly just for error reporting
+		    parser.trackPosition = parser.opt.position !== false;
+		    if (parser.trackPosition) {
+		      parser.position = parser.line = parser.column = 0;
+		    }
+		    emit(parser, 'onready');
+		  }
+
+		  if (!Object.create) {
+		    Object.create = function (o) {
+		      function F () {}
+		      F.prototype = o;
+		      var newf = new F();
+		      return newf
+		    };
+		  }
+
+		  if (!Object.keys) {
+		    Object.keys = function (o) {
+		      var a = [];
+		      for (var i in o) if (o.hasOwnProperty(i)) a.push(i);
+		      return a
+		    };
+		  }
+
+		  function checkBufferLength (parser) {
+		    var maxAllowed = Math.max(sax.MAX_BUFFER_LENGTH, 10);
+		    var maxActual = 0;
+		    for (var i = 0, l = buffers.length; i < l; i++) {
+		      var len = parser[buffers[i]].length;
+		      if (len > maxAllowed) {
+		        // Text/cdata nodes can get big, and since they're buffered,
+		        // we can get here under normal conditions.
+		        // Avoid issues by emitting the text node now,
+		        // so at least it won't get any bigger.
+		        switch (buffers[i]) {
+		          case 'textNode':
+		            closeText(parser);
+		            break
+
+		          case 'cdata':
+		            emitNode(parser, 'oncdata', parser.cdata);
+		            parser.cdata = '';
+		            break
+
+		          case 'script':
+		            emitNode(parser, 'onscript', parser.script);
+		            parser.script = '';
+		            break
+
+		          default:
+		            error(parser, 'Max buffer length exceeded: ' + buffers[i]);
+		        }
+		      }
+		      maxActual = Math.max(maxActual, len);
+		    }
+		    // schedule the next check for the earliest possible buffer overrun.
+		    var m = sax.MAX_BUFFER_LENGTH - maxActual;
+		    parser.bufferCheckPosition = m + parser.position;
+		  }
+
+		  function clearBuffers (parser) {
+		    for (var i = 0, l = buffers.length; i < l; i++) {
+		      parser[buffers[i]] = '';
+		    }
+		  }
+
+		  function flushBuffers (parser) {
+		    closeText(parser);
+		    if (parser.cdata !== '') {
+		      emitNode(parser, 'oncdata', parser.cdata);
+		      parser.cdata = '';
+		    }
+		    if (parser.script !== '') {
+		      emitNode(parser, 'onscript', parser.script);
+		      parser.script = '';
+		    }
+		  }
+
+		  SAXParser.prototype = {
+		    end: function () { end(this); },
+		    write: write,
+		    resume: function () { this.error = null; return this },
+		    close: function () { return this.write(null) },
+		    flush: function () { flushBuffers(this); }
+		  };
+
+		  var Stream;
+		  try {
+		    Stream = require$$0.Stream;
+		  } catch (ex) {
+		    Stream = function () {};
+		  }
+		  if (!Stream) Stream = function () {};
+
+		  var streamWraps = sax.EVENTS.filter(function (ev) {
+		    return ev !== 'error' && ev !== 'end'
+		  });
+
+		  function createStream (strict, opt) {
+		    return new SAXStream(strict, opt)
+		  }
+
+		  function SAXStream (strict, opt) {
+		    if (!(this instanceof SAXStream)) {
+		      return new SAXStream(strict, opt)
+		    }
+
+		    Stream.apply(this);
+
+		    this._parser = new SAXParser(strict, opt);
+		    this.writable = true;
+		    this.readable = true;
+
+		    var me = this;
+
+		    this._parser.onend = function () {
+		      me.emit('end');
+		    };
+
+		    this._parser.onerror = function (er) {
+		      me.emit('error', er);
+
+		      // if didn't throw, then means error was handled.
+		      // go ahead and clear error, so we can write again.
+		      me._parser.error = null;
+		    };
+
+		    this._decoder = null;
+
+		    streamWraps.forEach(function (ev) {
+		      Object.defineProperty(me, 'on' + ev, {
+		        get: function () {
+		          return me._parser['on' + ev]
+		        },
+		        set: function (h) {
+		          if (!h) {
+		            me.removeAllListeners(ev);
+		            me._parser['on' + ev] = h;
+		            return h
+		          }
+		          me.on(ev, h);
+		        },
+		        enumerable: true,
+		        configurable: false
+		      });
+		    });
+		  }
+
+		  SAXStream.prototype = Object.create(Stream.prototype, {
+		    constructor: {
+		      value: SAXStream
+		    }
+		  });
+
+		  SAXStream.prototype.write = function (data) {
+		    if (typeof Buffer === 'function' &&
+		      typeof Buffer.isBuffer === 'function' &&
+		      Buffer.isBuffer(data)) {
+		      if (!this._decoder) {
+		        var SD = require$$1.StringDecoder;
+		        this._decoder = new SD('utf8');
+		      }
+		      data = this._decoder.write(data);
+		    }
+
+		    this._parser.write(data.toString());
+		    this.emit('data', data);
+		    return true
+		  };
+
+		  SAXStream.prototype.end = function (chunk) {
+		    if (chunk && chunk.length) {
+		      this.write(chunk);
+		    }
+		    this._parser.end();
+		    return true
+		  };
+
+		  SAXStream.prototype.on = function (ev, handler) {
+		    var me = this;
+		    if (!me._parser['on' + ev] && streamWraps.indexOf(ev) !== -1) {
+		      me._parser['on' + ev] = function () {
+		        var args = arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments);
+		        args.splice(0, 0, ev);
+		        me.emit.apply(me, args);
+		      };
+		    }
+
+		    return Stream.prototype.on.call(me, ev, handler)
+		  };
+
+		  // this really needs to be replaced with character classes.
+		  // XML allows all manner of ridiculous numbers and digits.
+		  var CDATA = '[CDATA[';
+		  var DOCTYPE = 'DOCTYPE';
+		  var XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
+		  var XMLNS_NAMESPACE = 'http://www.w3.org/2000/xmlns/';
+		  var rootNS = { xml: XML_NAMESPACE, xmlns: XMLNS_NAMESPACE };
+
+		  // http://www.w3.org/TR/REC-xml/#NT-NameStartChar
+		  // This implementation works on strings, a single character at a time
+		  // as such, it cannot ever support astral-plane characters (10000-EFFFF)
+		  // without a significant breaking change to either this  parser, or the
+		  // JavaScript language.  Implementation of an emoji-capable xml parser
+		  // is left as an exercise for the reader.
+		  var nameStart = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/;
+
+		  var nameBody = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040.\d-]/;
+
+		  var entityStart = /[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/;
+		  var entityBody = /[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040.\d-]/;
+
+		  function isWhitespace (c) {
+		    return c === ' ' || c === '\n' || c === '\r' || c === '\t'
+		  }
+
+		  function isQuote (c) {
+		    return c === '"' || c === '\''
+		  }
+
+		  function isAttribEnd (c) {
+		    return c === '>' || isWhitespace(c)
+		  }
+
+		  function isMatch (regex, c) {
+		    return regex.test(c)
+		  }
+
+		  function notMatch (regex, c) {
+		    return !isMatch(regex, c)
+		  }
+
+		  var S = 0;
+		  sax.STATE = {
+		    BEGIN: S++, // leading byte order mark or whitespace
+		    BEGIN_WHITESPACE: S++, // leading whitespace
+		    TEXT: S++, // general stuff
+		    TEXT_ENTITY: S++, // &amp and such.
+		    OPEN_WAKA: S++, // <
+		    SGML_DECL: S++, // <!BLARG
+		    SGML_DECL_QUOTED: S++, // <!BLARG foo "bar
+		    DOCTYPE: S++, // <!DOCTYPE
+		    DOCTYPE_QUOTED: S++, // <!DOCTYPE "//blah
+		    DOCTYPE_DTD: S++, // <!DOCTYPE "//blah" [ ...
+		    DOCTYPE_DTD_QUOTED: S++, // <!DOCTYPE "//blah" [ "foo
+		    COMMENT_STARTING: S++, // <!-
+		    COMMENT: S++, // <!--
+		    COMMENT_ENDING: S++, // <!-- blah -
+		    COMMENT_ENDED: S++, // <!-- blah --
+		    CDATA: S++, // <![CDATA[ something
+		    CDATA_ENDING: S++, // ]
+		    CDATA_ENDING_2: S++, // ]]
+		    PROC_INST: S++, // <?hi
+		    PROC_INST_BODY: S++, // <?hi there
+		    PROC_INST_ENDING: S++, // <?hi "there" ?
+		    OPEN_TAG: S++, // <strong
+		    OPEN_TAG_SLASH: S++, // <strong /
+		    ATTRIB: S++, // <a
+		    ATTRIB_NAME: S++, // <a foo
+		    ATTRIB_NAME_SAW_WHITE: S++, // <a foo _
+		    ATTRIB_VALUE: S++, // <a foo=
+		    ATTRIB_VALUE_QUOTED: S++, // <a foo="bar
+		    ATTRIB_VALUE_CLOSED: S++, // <a foo="bar"
+		    ATTRIB_VALUE_UNQUOTED: S++, // <a foo=bar
+		    ATTRIB_VALUE_ENTITY_Q: S++, // <foo bar="&quot;"
+		    ATTRIB_VALUE_ENTITY_U: S++, // <foo bar=&quot
+		    CLOSE_TAG: S++, // </a
+		    CLOSE_TAG_SAW_WHITE: S++, // </a   >
+		    SCRIPT: S++, // <script> ...
+		    SCRIPT_ENDING: S++ // <script> ... <
+		  };
+
+		  sax.XML_ENTITIES = {
+		    'amp': '&',
+		    'gt': '>',
+		    'lt': '<',
+		    'quot': '"',
+		    'apos': "'"
+		  };
+
+		  sax.ENTITIES = {
+		    'amp': '&',
+		    'gt': '>',
+		    'lt': '<',
+		    'quot': '"',
+		    'apos': "'",
+		    'AElig': 198,
+		    'Aacute': 193,
+		    'Acirc': 194,
+		    'Agrave': 192,
+		    'Aring': 197,
+		    'Atilde': 195,
+		    'Auml': 196,
+		    'Ccedil': 199,
+		    'ETH': 208,
+		    'Eacute': 201,
+		    'Ecirc': 202,
+		    'Egrave': 200,
+		    'Euml': 203,
+		    'Iacute': 205,
+		    'Icirc': 206,
+		    'Igrave': 204,
+		    'Iuml': 207,
+		    'Ntilde': 209,
+		    'Oacute': 211,
+		    'Ocirc': 212,
+		    'Ograve': 210,
+		    'Oslash': 216,
+		    'Otilde': 213,
+		    'Ouml': 214,
+		    'THORN': 222,
+		    'Uacute': 218,
+		    'Ucirc': 219,
+		    'Ugrave': 217,
+		    'Uuml': 220,
+		    'Yacute': 221,
+		    'aacute': 225,
+		    'acirc': 226,
+		    'aelig': 230,
+		    'agrave': 224,
+		    'aring': 229,
+		    'atilde': 227,
+		    'auml': 228,
+		    'ccedil': 231,
+		    'eacute': 233,
+		    'ecirc': 234,
+		    'egrave': 232,
+		    'eth': 240,
+		    'euml': 235,
+		    'iacute': 237,
+		    'icirc': 238,
+		    'igrave': 236,
+		    'iuml': 239,
+		    'ntilde': 241,
+		    'oacute': 243,
+		    'ocirc': 244,
+		    'ograve': 242,
+		    'oslash': 248,
+		    'otilde': 245,
+		    'ouml': 246,
+		    'szlig': 223,
+		    'thorn': 254,
+		    'uacute': 250,
+		    'ucirc': 251,
+		    'ugrave': 249,
+		    'uuml': 252,
+		    'yacute': 253,
+		    'yuml': 255,
+		    'copy': 169,
+		    'reg': 174,
+		    'nbsp': 160,
+		    'iexcl': 161,
+		    'cent': 162,
+		    'pound': 163,
+		    'curren': 164,
+		    'yen': 165,
+		    'brvbar': 166,
+		    'sect': 167,
+		    'uml': 168,
+		    'ordf': 170,
+		    'laquo': 171,
+		    'not': 172,
+		    'shy': 173,
+		    'macr': 175,
+		    'deg': 176,
+		    'plusmn': 177,
+		    'sup1': 185,
+		    'sup2': 178,
+		    'sup3': 179,
+		    'acute': 180,
+		    'micro': 181,
+		    'para': 182,
+		    'middot': 183,
+		    'cedil': 184,
+		    'ordm': 186,
+		    'raquo': 187,
+		    'frac14': 188,
+		    'frac12': 189,
+		    'frac34': 190,
+		    'iquest': 191,
+		    'times': 215,
+		    'divide': 247,
+		    'OElig': 338,
+		    'oelig': 339,
+		    'Scaron': 352,
+		    'scaron': 353,
+		    'Yuml': 376,
+		    'fnof': 402,
+		    'circ': 710,
+		    'tilde': 732,
+		    'Alpha': 913,
+		    'Beta': 914,
+		    'Gamma': 915,
+		    'Delta': 916,
+		    'Epsilon': 917,
+		    'Zeta': 918,
+		    'Eta': 919,
+		    'Theta': 920,
+		    'Iota': 921,
+		    'Kappa': 922,
+		    'Lambda': 923,
+		    'Mu': 924,
+		    'Nu': 925,
+		    'Xi': 926,
+		    'Omicron': 927,
+		    'Pi': 928,
+		    'Rho': 929,
+		    'Sigma': 931,
+		    'Tau': 932,
+		    'Upsilon': 933,
+		    'Phi': 934,
+		    'Chi': 935,
+		    'Psi': 936,
+		    'Omega': 937,
+		    'alpha': 945,
+		    'beta': 946,
+		    'gamma': 947,
+		    'delta': 948,
+		    'epsilon': 949,
+		    'zeta': 950,
+		    'eta': 951,
+		    'theta': 952,
+		    'iota': 953,
+		    'kappa': 954,
+		    'lambda': 955,
+		    'mu': 956,
+		    'nu': 957,
+		    'xi': 958,
+		    'omicron': 959,
+		    'pi': 960,
+		    'rho': 961,
+		    'sigmaf': 962,
+		    'sigma': 963,
+		    'tau': 964,
+		    'upsilon': 965,
+		    'phi': 966,
+		    'chi': 967,
+		    'psi': 968,
+		    'omega': 969,
+		    'thetasym': 977,
+		    'upsih': 978,
+		    'piv': 982,
+		    'ensp': 8194,
+		    'emsp': 8195,
+		    'thinsp': 8201,
+		    'zwnj': 8204,
+		    'zwj': 8205,
+		    'lrm': 8206,
+		    'rlm': 8207,
+		    'ndash': 8211,
+		    'mdash': 8212,
+		    'lsquo': 8216,
+		    'rsquo': 8217,
+		    'sbquo': 8218,
+		    'ldquo': 8220,
+		    'rdquo': 8221,
+		    'bdquo': 8222,
+		    'dagger': 8224,
+		    'Dagger': 8225,
+		    'bull': 8226,
+		    'hellip': 8230,
+		    'permil': 8240,
+		    'prime': 8242,
+		    'Prime': 8243,
+		    'lsaquo': 8249,
+		    'rsaquo': 8250,
+		    'oline': 8254,
+		    'frasl': 8260,
+		    'euro': 8364,
+		    'image': 8465,
+		    'weierp': 8472,
+		    'real': 8476,
+		    'trade': 8482,
+		    'alefsym': 8501,
+		    'larr': 8592,
+		    'uarr': 8593,
+		    'rarr': 8594,
+		    'darr': 8595,
+		    'harr': 8596,
+		    'crarr': 8629,
+		    'lArr': 8656,
+		    'uArr': 8657,
+		    'rArr': 8658,
+		    'dArr': 8659,
+		    'hArr': 8660,
+		    'forall': 8704,
+		    'part': 8706,
+		    'exist': 8707,
+		    'empty': 8709,
+		    'nabla': 8711,
+		    'isin': 8712,
+		    'notin': 8713,
+		    'ni': 8715,
+		    'prod': 8719,
+		    'sum': 8721,
+		    'minus': 8722,
+		    'lowast': 8727,
+		    'radic': 8730,
+		    'prop': 8733,
+		    'infin': 8734,
+		    'ang': 8736,
+		    'and': 8743,
+		    'or': 8744,
+		    'cap': 8745,
+		    'cup': 8746,
+		    'int': 8747,
+		    'there4': 8756,
+		    'sim': 8764,
+		    'cong': 8773,
+		    'asymp': 8776,
+		    'ne': 8800,
+		    'equiv': 8801,
+		    'le': 8804,
+		    'ge': 8805,
+		    'sub': 8834,
+		    'sup': 8835,
+		    'nsub': 8836,
+		    'sube': 8838,
+		    'supe': 8839,
+		    'oplus': 8853,
+		    'otimes': 8855,
+		    'perp': 8869,
+		    'sdot': 8901,
+		    'lceil': 8968,
+		    'rceil': 8969,
+		    'lfloor': 8970,
+		    'rfloor': 8971,
+		    'lang': 9001,
+		    'rang': 9002,
+		    'loz': 9674,
+		    'spades': 9824,
+		    'clubs': 9827,
+		    'hearts': 9829,
+		    'diams': 9830
+		  };
+
+		  Object.keys(sax.ENTITIES).forEach(function (key) {
+		    var e = sax.ENTITIES[key];
+		    var s = typeof e === 'number' ? String.fromCharCode(e) : e;
+		    sax.ENTITIES[key] = s;
+		  });
+
+		  for (var s in sax.STATE) {
+		    sax.STATE[sax.STATE[s]] = s;
+		  }
+
+		  // shorthand
+		  S = sax.STATE;
+
+		  function emit (parser, event, data) {
+		    parser[event] && parser[event](data);
+		  }
+
+		  function emitNode (parser, nodeType, data) {
+		    if (parser.textNode) closeText(parser);
+		    emit(parser, nodeType, data);
+		  }
+
+		  function closeText (parser) {
+		    parser.textNode = textopts(parser.opt, parser.textNode);
+		    if (parser.textNode) emit(parser, 'ontext', parser.textNode);
+		    parser.textNode = '';
+		  }
+
+		  function textopts (opt, text) {
+		    if (opt.trim) text = text.trim();
+		    if (opt.normalize) text = text.replace(/\s+/g, ' ');
+		    return text
+		  }
+
+		  function error (parser, er) {
+		    closeText(parser);
+		    if (parser.trackPosition) {
+		      er += '\nLine: ' + parser.line +
+		        '\nColumn: ' + parser.column +
+		        '\nChar: ' + parser.c;
+		    }
+		    er = new Error(er);
+		    parser.error = er;
+		    emit(parser, 'onerror', er);
+		    return parser
+		  }
+
+		  function end (parser) {
+		    if (parser.sawRoot && !parser.closedRoot) strictFail(parser, 'Unclosed root tag');
+		    if ((parser.state !== S.BEGIN) &&
+		      (parser.state !== S.BEGIN_WHITESPACE) &&
+		      (parser.state !== S.TEXT)) {
+		      error(parser, 'Unexpected end');
+		    }
+		    closeText(parser);
+		    parser.c = '';
+		    parser.closed = true;
+		    emit(parser, 'onend');
+		    SAXParser.call(parser, parser.strict, parser.opt);
+		    return parser
+		  }
+
+		  function strictFail (parser, message) {
+		    if (typeof parser !== 'object' || !(parser instanceof SAXParser)) {
+		      throw new Error('bad call to strictFail')
+		    }
+		    if (parser.strict) {
+		      error(parser, message);
+		    }
+		  }
+
+		  function newTag (parser) {
+		    if (!parser.strict) parser.tagName = parser.tagName[parser.looseCase]();
+		    var parent = parser.tags[parser.tags.length - 1] || parser;
+		    var tag = parser.tag = { name: parser.tagName, attributes: {} };
+
+		    // will be overridden if tag contails an xmlns="foo" or xmlns:foo="bar"
+		    if (parser.opt.xmlns) {
+		      tag.ns = parent.ns;
+		    }
+		    parser.attribList.length = 0;
+		    emitNode(parser, 'onopentagstart', tag);
+		  }
+
+		  function qname (name, attribute) {
+		    var i = name.indexOf(':');
+		    var qualName = i < 0 ? [ '', name ] : name.split(':');
+		    var prefix = qualName[0];
+		    var local = qualName[1];
+
+		    // <x "xmlns"="http://foo">
+		    if (attribute && name === 'xmlns') {
+		      prefix = 'xmlns';
+		      local = '';
+		    }
+
+		    return { prefix: prefix, local: local }
+		  }
+
+		  function attrib (parser) {
+		    if (!parser.strict) {
+		      parser.attribName = parser.attribName[parser.looseCase]();
+		    }
+
+		    if (parser.attribList.indexOf(parser.attribName) !== -1 ||
+		      parser.tag.attributes.hasOwnProperty(parser.attribName)) {
+		      parser.attribName = parser.attribValue = '';
+		      return
+		    }
+
+		    if (parser.opt.xmlns) {
+		      var qn = qname(parser.attribName, true);
+		      var prefix = qn.prefix;
+		      var local = qn.local;
+
+		      if (prefix === 'xmlns') {
+		        // namespace binding attribute. push the binding into scope
+		        if (local === 'xml' && parser.attribValue !== XML_NAMESPACE) {
+		          strictFail(parser,
+		            'xml: prefix must be bound to ' + XML_NAMESPACE + '\n' +
+		            'Actual: ' + parser.attribValue);
+		        } else if (local === 'xmlns' && parser.attribValue !== XMLNS_NAMESPACE) {
+		          strictFail(parser,
+		            'xmlns: prefix must be bound to ' + XMLNS_NAMESPACE + '\n' +
+		            'Actual: ' + parser.attribValue);
+		        } else {
+		          var tag = parser.tag;
+		          var parent = parser.tags[parser.tags.length - 1] || parser;
+		          if (tag.ns === parent.ns) {
+		            tag.ns = Object.create(parent.ns);
+		          }
+		          tag.ns[local] = parser.attribValue;
+		        }
+		      }
+
+		      // defer onattribute events until all attributes have been seen
+		      // so any new bindings can take effect. preserve attribute order
+		      // so deferred events can be emitted in document order
+		      parser.attribList.push([parser.attribName, parser.attribValue]);
+		    } else {
+		      // in non-xmlns mode, we can emit the event right away
+		      parser.tag.attributes[parser.attribName] = parser.attribValue;
+		      emitNode(parser, 'onattribute', {
+		        name: parser.attribName,
+		        value: parser.attribValue
+		      });
+		    }
+
+		    parser.attribName = parser.attribValue = '';
+		  }
+
+		  function openTag (parser, selfClosing) {
+		    if (parser.opt.xmlns) {
+		      // emit namespace binding events
+		      var tag = parser.tag;
+
+		      // add namespace info to tag
+		      var qn = qname(parser.tagName);
+		      tag.prefix = qn.prefix;
+		      tag.local = qn.local;
+		      tag.uri = tag.ns[qn.prefix] || '';
+
+		      if (tag.prefix && !tag.uri) {
+		        strictFail(parser, 'Unbound namespace prefix: ' +
+		          JSON.stringify(parser.tagName));
+		        tag.uri = qn.prefix;
+		      }
+
+		      var parent = parser.tags[parser.tags.length - 1] || parser;
+		      if (tag.ns && parent.ns !== tag.ns) {
+		        Object.keys(tag.ns).forEach(function (p) {
+		          emitNode(parser, 'onopennamespace', {
+		            prefix: p,
+		            uri: tag.ns[p]
+		          });
+		        });
+		      }
+
+		      // handle deferred onattribute events
+		      // Note: do not apply default ns to attributes:
+		      //   http://www.w3.org/TR/REC-xml-names/#defaulting
+		      for (var i = 0, l = parser.attribList.length; i < l; i++) {
+		        var nv = parser.attribList[i];
+		        var name = nv[0];
+		        var value = nv[1];
+		        var qualName = qname(name, true);
+		        var prefix = qualName.prefix;
+		        var local = qualName.local;
+		        var uri = prefix === '' ? '' : (tag.ns[prefix] || '');
+		        var a = {
+		          name: name,
+		          value: value,
+		          prefix: prefix,
+		          local: local,
+		          uri: uri
+		        };
+
+		        // if there's any attributes with an undefined namespace,
+		        // then fail on them now.
+		        if (prefix && prefix !== 'xmlns' && !uri) {
+		          strictFail(parser, 'Unbound namespace prefix: ' +
+		            JSON.stringify(prefix));
+		          a.uri = prefix;
+		        }
+		        parser.tag.attributes[name] = a;
+		        emitNode(parser, 'onattribute', a);
+		      }
+		      parser.attribList.length = 0;
+		    }
+
+		    parser.tag.isSelfClosing = !!selfClosing;
+
+		    // process the tag
+		    parser.sawRoot = true;
+		    parser.tags.push(parser.tag);
+		    emitNode(parser, 'onopentag', parser.tag);
+		    if (!selfClosing) {
+		      // special case for <script> in non-strict mode.
+		      if (!parser.noscript && parser.tagName.toLowerCase() === 'script') {
+		        parser.state = S.SCRIPT;
+		      } else {
+		        parser.state = S.TEXT;
+		      }
+		      parser.tag = null;
+		      parser.tagName = '';
+		    }
+		    parser.attribName = parser.attribValue = '';
+		    parser.attribList.length = 0;
+		  }
+
+		  function closeTag (parser) {
+		    if (!parser.tagName) {
+		      strictFail(parser, 'Weird empty close tag.');
+		      parser.textNode += '</>';
+		      parser.state = S.TEXT;
+		      return
+		    }
+
+		    if (parser.script) {
+		      if (parser.tagName !== 'script') {
+		        parser.script += '</' + parser.tagName + '>';
+		        parser.tagName = '';
+		        parser.state = S.SCRIPT;
+		        return
+		      }
+		      emitNode(parser, 'onscript', parser.script);
+		      parser.script = '';
+		    }
+
+		    // first make sure that the closing tag actually exists.
+		    // <a><b></c></b></a> will close everything, otherwise.
+		    var t = parser.tags.length;
+		    var tagName = parser.tagName;
+		    if (!parser.strict) {
+		      tagName = tagName[parser.looseCase]();
+		    }
+		    var closeTo = tagName;
+		    while (t--) {
+		      var close = parser.tags[t];
+		      if (close.name !== closeTo) {
+		        // fail the first time in strict mode
+		        strictFail(parser, 'Unexpected close tag');
+		      } else {
+		        break
+		      }
+		    }
+
+		    // didn't find it.  we already failed for strict, so just abort.
+		    if (t < 0) {
+		      strictFail(parser, 'Unmatched closing tag: ' + parser.tagName);
+		      parser.textNode += '</' + parser.tagName + '>';
+		      parser.state = S.TEXT;
+		      return
+		    }
+		    parser.tagName = tagName;
+		    var s = parser.tags.length;
+		    while (s-- > t) {
+		      var tag = parser.tag = parser.tags.pop();
+		      parser.tagName = parser.tag.name;
+		      emitNode(parser, 'onclosetag', parser.tagName);
+
+		      var x = {};
+		      for (var i in tag.ns) {
+		        x[i] = tag.ns[i];
+		      }
+
+		      var parent = parser.tags[parser.tags.length - 1] || parser;
+		      if (parser.opt.xmlns && tag.ns !== parent.ns) {
+		        // remove namespace bindings introduced by tag
+		        Object.keys(tag.ns).forEach(function (p) {
+		          var n = tag.ns[p];
+		          emitNode(parser, 'onclosenamespace', { prefix: p, uri: n });
+		        });
+		      }
+		    }
+		    if (t === 0) parser.closedRoot = true;
+		    parser.tagName = parser.attribValue = parser.attribName = '';
+		    parser.attribList.length = 0;
+		    parser.state = S.TEXT;
+		  }
+
+		  function parseEntity (parser) {
+		    var entity = parser.entity;
+		    var entityLC = entity.toLowerCase();
+		    var num;
+		    var numStr = '';
+
+		    if (parser.ENTITIES[entity]) {
+		      return parser.ENTITIES[entity]
+		    }
+		    if (parser.ENTITIES[entityLC]) {
+		      return parser.ENTITIES[entityLC]
+		    }
+		    entity = entityLC;
+		    if (entity.charAt(0) === '#') {
+		      if (entity.charAt(1) === 'x') {
+		        entity = entity.slice(2);
+		        num = parseInt(entity, 16);
+		        numStr = num.toString(16);
+		      } else {
+		        entity = entity.slice(1);
+		        num = parseInt(entity, 10);
+		        numStr = num.toString(10);
+		      }
+		    }
+		    entity = entity.replace(/^0+/, '');
+		    if (isNaN(num) || numStr.toLowerCase() !== entity) {
+		      strictFail(parser, 'Invalid character entity');
+		      return '&' + parser.entity + ';'
+		    }
+
+		    return String.fromCodePoint(num)
+		  }
+
+		  function beginWhiteSpace (parser, c) {
+		    if (c === '<') {
+		      parser.state = S.OPEN_WAKA;
+		      parser.startTagPosition = parser.position;
+		    } else if (!isWhitespace(c)) {
+		      // have to process this as a text node.
+		      // weird, but happens.
+		      strictFail(parser, 'Non-whitespace before first tag.');
+		      parser.textNode = c;
+		      parser.state = S.TEXT;
+		    }
+		  }
+
+		  function charAt (chunk, i) {
+		    var result = '';
+		    if (i < chunk.length) {
+		      result = chunk.charAt(i);
+		    }
+		    return result
+		  }
+
+		  function write (chunk) {
+		    var parser = this;
+		    if (this.error) {
+		      throw this.error
+		    }
+		    if (parser.closed) {
+		      return error(parser,
+		        'Cannot write after close. Assign an onready handler.')
+		    }
+		    if (chunk === null) {
+		      return end(parser)
+		    }
+		    if (typeof chunk === 'object') {
+		      chunk = chunk.toString();
+		    }
+		    var i = 0;
+		    var c = '';
+		    while (true) {
+		      c = charAt(chunk, i++);
+		      parser.c = c;
+
+		      if (!c) {
+		        break
+		      }
+
+		      if (parser.trackPosition) {
+		        parser.position++;
+		        if (c === '\n') {
+		          parser.line++;
+		          parser.column = 0;
+		        } else {
+		          parser.column++;
+		        }
+		      }
+
+		      switch (parser.state) {
+		        case S.BEGIN:
+		          parser.state = S.BEGIN_WHITESPACE;
+		          if (c === '\uFEFF') {
+		            continue
+		          }
+		          beginWhiteSpace(parser, c);
+		          continue
+
+		        case S.BEGIN_WHITESPACE:
+		          beginWhiteSpace(parser, c);
+		          continue
+
+		        case S.TEXT:
+		          if (parser.sawRoot && !parser.closedRoot) {
+		            var starti = i - 1;
+		            while (c && c !== '<' && c !== '&') {
+		              c = charAt(chunk, i++);
+		              if (c && parser.trackPosition) {
+		                parser.position++;
+		                if (c === '\n') {
+		                  parser.line++;
+		                  parser.column = 0;
+		                } else {
+		                  parser.column++;
+		                }
+		              }
+		            }
+		            parser.textNode += chunk.substring(starti, i - 1);
+		          }
+		          if (c === '<' && !(parser.sawRoot && parser.closedRoot && !parser.strict)) {
+		            parser.state = S.OPEN_WAKA;
+		            parser.startTagPosition = parser.position;
+		          } else {
+		            if (!isWhitespace(c) && (!parser.sawRoot || parser.closedRoot)) {
+		              strictFail(parser, 'Text data outside of root node.');
+		            }
+		            if (c === '&') {
+		              parser.state = S.TEXT_ENTITY;
+		            } else {
+		              parser.textNode += c;
+		            }
+		          }
+		          continue
+
+		        case S.SCRIPT:
+		          // only non-strict
+		          if (c === '<') {
+		            parser.state = S.SCRIPT_ENDING;
+		          } else {
+		            parser.script += c;
+		          }
+		          continue
+
+		        case S.SCRIPT_ENDING:
+		          if (c === '/') {
+		            parser.state = S.CLOSE_TAG;
+		          } else {
+		            parser.script += '<' + c;
+		            parser.state = S.SCRIPT;
+		          }
+		          continue
+
+		        case S.OPEN_WAKA:
+		          // either a /, ?, !, or text is coming next.
+		          if (c === '!') {
+		            parser.state = S.SGML_DECL;
+		            parser.sgmlDecl = '';
+		          } else if (isWhitespace(c)) ; else if (isMatch(nameStart, c)) {
+		            parser.state = S.OPEN_TAG;
+		            parser.tagName = c;
+		          } else if (c === '/') {
+		            parser.state = S.CLOSE_TAG;
+		            parser.tagName = '';
+		          } else if (c === '?') {
+		            parser.state = S.PROC_INST;
+		            parser.procInstName = parser.procInstBody = '';
+		          } else {
+		            strictFail(parser, 'Unencoded <');
+		            // if there was some whitespace, then add that in.
+		            if (parser.startTagPosition + 1 < parser.position) {
+		              var pad = parser.position - parser.startTagPosition;
+		              c = new Array(pad).join(' ') + c;
+		            }
+		            parser.textNode += '<' + c;
+		            parser.state = S.TEXT;
+		          }
+		          continue
+
+		        case S.SGML_DECL:
+		          if (parser.sgmlDecl + c === '--') {
+		            parser.state = S.COMMENT;
+		            parser.comment = '';
+		            parser.sgmlDecl = '';
+		            continue;
+		          }
+
+		          if (parser.doctype && parser.doctype !== true && parser.sgmlDecl) {
+		            parser.state = S.DOCTYPE_DTD;
+		            parser.doctype += '<!' + parser.sgmlDecl + c;
+		            parser.sgmlDecl = '';
+		          } else if ((parser.sgmlDecl + c).toUpperCase() === CDATA) {
+		            emitNode(parser, 'onopencdata');
+		            parser.state = S.CDATA;
+		            parser.sgmlDecl = '';
+		            parser.cdata = '';
+		          } else if ((parser.sgmlDecl + c).toUpperCase() === DOCTYPE) {
+		            parser.state = S.DOCTYPE;
+		            if (parser.doctype || parser.sawRoot) {
+		              strictFail(parser,
+		                'Inappropriately located doctype declaration');
+		            }
+		            parser.doctype = '';
+		            parser.sgmlDecl = '';
+		          } else if (c === '>') {
+		            emitNode(parser, 'onsgmldeclaration', parser.sgmlDecl);
+		            parser.sgmlDecl = '';
+		            parser.state = S.TEXT;
+		          } else if (isQuote(c)) {
+		            parser.state = S.SGML_DECL_QUOTED;
+		            parser.sgmlDecl += c;
+		          } else {
+		            parser.sgmlDecl += c;
+		          }
+		          continue
+
+		        case S.SGML_DECL_QUOTED:
+		          if (c === parser.q) {
+		            parser.state = S.SGML_DECL;
+		            parser.q = '';
+		          }
+		          parser.sgmlDecl += c;
+		          continue
+
+		        case S.DOCTYPE:
+		          if (c === '>') {
+		            parser.state = S.TEXT;
+		            emitNode(parser, 'ondoctype', parser.doctype);
+		            parser.doctype = true; // just remember that we saw it.
+		          } else {
+		            parser.doctype += c;
+		            if (c === '[') {
+		              parser.state = S.DOCTYPE_DTD;
+		            } else if (isQuote(c)) {
+		              parser.state = S.DOCTYPE_QUOTED;
+		              parser.q = c;
+		            }
+		          }
+		          continue
+
+		        case S.DOCTYPE_QUOTED:
+		          parser.doctype += c;
+		          if (c === parser.q) {
+		            parser.q = '';
+		            parser.state = S.DOCTYPE;
+		          }
+		          continue
+
+		        case S.DOCTYPE_DTD:
+		          if (c === ']') {
+		            parser.doctype += c;
+		            parser.state = S.DOCTYPE;
+		          } else if (c === '<') {
+		            parser.state = S.OPEN_WAKA;
+		            parser.startTagPosition = parser.position;
+		          } else if (isQuote(c)) {
+		            parser.doctype += c;
+		            parser.state = S.DOCTYPE_DTD_QUOTED;
+		            parser.q = c;
+		          } else {
+		            parser.doctype += c;
+		          }
+		          continue
+
+		        case S.DOCTYPE_DTD_QUOTED:
+		          parser.doctype += c;
+		          if (c === parser.q) {
+		            parser.state = S.DOCTYPE_DTD;
+		            parser.q = '';
+		          }
+		          continue
+
+		        case S.COMMENT:
+		          if (c === '-') {
+		            parser.state = S.COMMENT_ENDING;
+		          } else {
+		            parser.comment += c;
+		          }
+		          continue
+
+		        case S.COMMENT_ENDING:
+		          if (c === '-') {
+		            parser.state = S.COMMENT_ENDED;
+		            parser.comment = textopts(parser.opt, parser.comment);
+		            if (parser.comment) {
+		              emitNode(parser, 'oncomment', parser.comment);
+		            }
+		            parser.comment = '';
+		          } else {
+		            parser.comment += '-' + c;
+		            parser.state = S.COMMENT;
+		          }
+		          continue
+
+		        case S.COMMENT_ENDED:
+		          if (c !== '>') {
+		            strictFail(parser, 'Malformed comment');
+		            // allow <!-- blah -- bloo --> in non-strict mode,
+		            // which is a comment of " blah -- bloo "
+		            parser.comment += '--' + c;
+		            parser.state = S.COMMENT;
+		          } else if (parser.doctype && parser.doctype !== true) {
+		            parser.state = S.DOCTYPE_DTD;
+		          } else {
+		            parser.state = S.TEXT;
+		          }
+		          continue
+
+		        case S.CDATA:
+		          if (c === ']') {
+		            parser.state = S.CDATA_ENDING;
+		          } else {
+		            parser.cdata += c;
+		          }
+		          continue
+
+		        case S.CDATA_ENDING:
+		          if (c === ']') {
+		            parser.state = S.CDATA_ENDING_2;
+		          } else {
+		            parser.cdata += ']' + c;
+		            parser.state = S.CDATA;
+		          }
+		          continue
+
+		        case S.CDATA_ENDING_2:
+		          if (c === '>') {
+		            if (parser.cdata) {
+		              emitNode(parser, 'oncdata', parser.cdata);
+		            }
+		            emitNode(parser, 'onclosecdata');
+		            parser.cdata = '';
+		            parser.state = S.TEXT;
+		          } else if (c === ']') {
+		            parser.cdata += ']';
+		          } else {
+		            parser.cdata += ']]' + c;
+		            parser.state = S.CDATA;
+		          }
+		          continue
+
+		        case S.PROC_INST:
+		          if (c === '?') {
+		            parser.state = S.PROC_INST_ENDING;
+		          } else if (isWhitespace(c)) {
+		            parser.state = S.PROC_INST_BODY;
+		          } else {
+		            parser.procInstName += c;
+		          }
+		          continue
+
+		        case S.PROC_INST_BODY:
+		          if (!parser.procInstBody && isWhitespace(c)) {
+		            continue
+		          } else if (c === '?') {
+		            parser.state = S.PROC_INST_ENDING;
+		          } else {
+		            parser.procInstBody += c;
+		          }
+		          continue
+
+		        case S.PROC_INST_ENDING:
+		          if (c === '>') {
+		            emitNode(parser, 'onprocessinginstruction', {
+		              name: parser.procInstName,
+		              body: parser.procInstBody
+		            });
+		            parser.procInstName = parser.procInstBody = '';
+		            parser.state = S.TEXT;
+		          } else {
+		            parser.procInstBody += '?' + c;
+		            parser.state = S.PROC_INST_BODY;
+		          }
+		          continue
+
+		        case S.OPEN_TAG:
+		          if (isMatch(nameBody, c)) {
+		            parser.tagName += c;
+		          } else {
+		            newTag(parser);
+		            if (c === '>') {
+		              openTag(parser);
+		            } else if (c === '/') {
+		              parser.state = S.OPEN_TAG_SLASH;
+		            } else {
+		              if (!isWhitespace(c)) {
+		                strictFail(parser, 'Invalid character in tag name');
+		              }
+		              parser.state = S.ATTRIB;
+		            }
+		          }
+		          continue
+
+		        case S.OPEN_TAG_SLASH:
+		          if (c === '>') {
+		            openTag(parser, true);
+		            closeTag(parser);
+		          } else {
+		            strictFail(parser, 'Forward-slash in opening tag not followed by >');
+		            parser.state = S.ATTRIB;
+		          }
+		          continue
+
+		        case S.ATTRIB:
+		          // haven't read the attribute name yet.
+		          if (isWhitespace(c)) {
+		            continue
+		          } else if (c === '>') {
+		            openTag(parser);
+		          } else if (c === '/') {
+		            parser.state = S.OPEN_TAG_SLASH;
+		          } else if (isMatch(nameStart, c)) {
+		            parser.attribName = c;
+		            parser.attribValue = '';
+		            parser.state = S.ATTRIB_NAME;
+		          } else {
+		            strictFail(parser, 'Invalid attribute name');
+		          }
+		          continue
+
+		        case S.ATTRIB_NAME:
+		          if (c === '=') {
+		            parser.state = S.ATTRIB_VALUE;
+		          } else if (c === '>') {
+		            strictFail(parser, 'Attribute without value');
+		            parser.attribValue = parser.attribName;
+		            attrib(parser);
+		            openTag(parser);
+		          } else if (isWhitespace(c)) {
+		            parser.state = S.ATTRIB_NAME_SAW_WHITE;
+		          } else if (isMatch(nameBody, c)) {
+		            parser.attribName += c;
+		          } else {
+		            strictFail(parser, 'Invalid attribute name');
+		          }
+		          continue
+
+		        case S.ATTRIB_NAME_SAW_WHITE:
+		          if (c === '=') {
+		            parser.state = S.ATTRIB_VALUE;
+		          } else if (isWhitespace(c)) {
+		            continue
+		          } else {
+		            strictFail(parser, 'Attribute without value');
+		            parser.tag.attributes[parser.attribName] = '';
+		            parser.attribValue = '';
+		            emitNode(parser, 'onattribute', {
+		              name: parser.attribName,
+		              value: ''
+		            });
+		            parser.attribName = '';
+		            if (c === '>') {
+		              openTag(parser);
+		            } else if (isMatch(nameStart, c)) {
+		              parser.attribName = c;
+		              parser.state = S.ATTRIB_NAME;
+		            } else {
+		              strictFail(parser, 'Invalid attribute name');
+		              parser.state = S.ATTRIB;
+		            }
+		          }
+		          continue
+
+		        case S.ATTRIB_VALUE:
+		          if (isWhitespace(c)) {
+		            continue
+		          } else if (isQuote(c)) {
+		            parser.q = c;
+		            parser.state = S.ATTRIB_VALUE_QUOTED;
+		          } else {
+		            if (!parser.opt.unquotedAttributeValues) {
+		              error(parser, 'Unquoted attribute value');
+		            }
+		            parser.state = S.ATTRIB_VALUE_UNQUOTED;
+		            parser.attribValue = c;
+		          }
+		          continue
+
+		        case S.ATTRIB_VALUE_QUOTED:
+		          if (c !== parser.q) {
+		            if (c === '&') {
+		              parser.state = S.ATTRIB_VALUE_ENTITY_Q;
+		            } else {
+		              parser.attribValue += c;
+		            }
+		            continue
+		          }
+		          attrib(parser);
+		          parser.q = '';
+		          parser.state = S.ATTRIB_VALUE_CLOSED;
+		          continue
+
+		        case S.ATTRIB_VALUE_CLOSED:
+		          if (isWhitespace(c)) {
+		            parser.state = S.ATTRIB;
+		          } else if (c === '>') {
+		            openTag(parser);
+		          } else if (c === '/') {
+		            parser.state = S.OPEN_TAG_SLASH;
+		          } else if (isMatch(nameStart, c)) {
+		            strictFail(parser, 'No whitespace between attributes');
+		            parser.attribName = c;
+		            parser.attribValue = '';
+		            parser.state = S.ATTRIB_NAME;
+		          } else {
+		            strictFail(parser, 'Invalid attribute name');
+		          }
+		          continue
+
+		        case S.ATTRIB_VALUE_UNQUOTED:
+		          if (!isAttribEnd(c)) {
+		            if (c === '&') {
+		              parser.state = S.ATTRIB_VALUE_ENTITY_U;
+		            } else {
+		              parser.attribValue += c;
+		            }
+		            continue
+		          }
+		          attrib(parser);
+		          if (c === '>') {
+		            openTag(parser);
+		          } else {
+		            parser.state = S.ATTRIB;
+		          }
+		          continue
+
+		        case S.CLOSE_TAG:
+		          if (!parser.tagName) {
+		            if (isWhitespace(c)) {
+		              continue
+		            } else if (notMatch(nameStart, c)) {
+		              if (parser.script) {
+		                parser.script += '</' + c;
+		                parser.state = S.SCRIPT;
+		              } else {
+		                strictFail(parser, 'Invalid tagname in closing tag.');
+		              }
+		            } else {
+		              parser.tagName = c;
+		            }
+		          } else if (c === '>') {
+		            closeTag(parser);
+		          } else if (isMatch(nameBody, c)) {
+		            parser.tagName += c;
+		          } else if (parser.script) {
+		            parser.script += '</' + parser.tagName;
+		            parser.tagName = '';
+		            parser.state = S.SCRIPT;
+		          } else {
+		            if (!isWhitespace(c)) {
+		              strictFail(parser, 'Invalid tagname in closing tag');
+		            }
+		            parser.state = S.CLOSE_TAG_SAW_WHITE;
+		          }
+		          continue
+
+		        case S.CLOSE_TAG_SAW_WHITE:
+		          if (isWhitespace(c)) {
+		            continue
+		          }
+		          if (c === '>') {
+		            closeTag(parser);
+		          } else {
+		            strictFail(parser, 'Invalid characters in closing tag');
+		          }
+		          continue
+
+		        case S.TEXT_ENTITY:
+		        case S.ATTRIB_VALUE_ENTITY_Q:
+		        case S.ATTRIB_VALUE_ENTITY_U:
+		          var returnState;
+		          var buffer;
+		          switch (parser.state) {
+		            case S.TEXT_ENTITY:
+		              returnState = S.TEXT;
+		              buffer = 'textNode';
+		              break
+
+		            case S.ATTRIB_VALUE_ENTITY_Q:
+		              returnState = S.ATTRIB_VALUE_QUOTED;
+		              buffer = 'attribValue';
+		              break
+
+		            case S.ATTRIB_VALUE_ENTITY_U:
+		              returnState = S.ATTRIB_VALUE_UNQUOTED;
+		              buffer = 'attribValue';
+		              break
+		          }
+
+		          if (c === ';') {
+		            var parsedEntity = parseEntity(parser);
+		            if (parser.opt.unparsedEntities && !Object.values(sax.XML_ENTITIES).includes(parsedEntity)) {
+		              parser.entity = '';
+		              parser.state = returnState;
+		              parser.write(parsedEntity);
+		            } else {
+		              parser[buffer] += parsedEntity;
+		              parser.entity = '';
+		              parser.state = returnState;
+		            }
+		          } else if (isMatch(parser.entity.length ? entityBody : entityStart, c)) {
+		            parser.entity += c;
+		          } else {
+		            strictFail(parser, 'Invalid character in entity name');
+		            parser[buffer] += '&' + parser.entity + c;
+		            parser.entity = '';
+		            parser.state = returnState;
+		          }
+
+		          continue
+
+		        default: /* istanbul ignore next */ {
+		          throw new Error(parser, 'Unknown state: ' + parser.state)
+		        }
+		      }
+		    } // while
+
+		    if (parser.position >= parser.bufferCheckPosition) {
+		      checkBufferLength(parser);
+		    }
+		    return parser
+		  }
+
+		  /*! http://mths.be/fromcodepoint v0.1.0 by @mathias */
+		  /* istanbul ignore next */
+		  if (!String.fromCodePoint) {
+		    (function () {
+		      var stringFromCharCode = String.fromCharCode;
+		      var floor = Math.floor;
+		      var fromCodePoint = function () {
+		        var MAX_SIZE = 0x4000;
+		        var codeUnits = [];
+		        var highSurrogate;
+		        var lowSurrogate;
+		        var index = -1;
+		        var length = arguments.length;
+		        if (!length) {
+		          return ''
+		        }
+		        var result = '';
+		        while (++index < length) {
+		          var codePoint = Number(arguments[index]);
+		          if (
+		            !isFinite(codePoint) || // `NaN`, `+Infinity`, or `-Infinity`
+		            codePoint < 0 || // not a valid Unicode code point
+		            codePoint > 0x10FFFF || // not a valid Unicode code point
+		            floor(codePoint) !== codePoint // not an integer
+		          ) {
+		            throw RangeError('Invalid code point: ' + codePoint)
+		          }
+		          if (codePoint <= 0xFFFF) { // BMP code point
+		            codeUnits.push(codePoint);
+		          } else { // Astral code point; split in surrogate halves
+		            // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+		            codePoint -= 0x10000;
+		            highSurrogate = (codePoint >> 10) + 0xD800;
+		            lowSurrogate = (codePoint % 0x400) + 0xDC00;
+		            codeUnits.push(highSurrogate, lowSurrogate);
+		          }
+		          if (index + 1 === length || codeUnits.length > MAX_SIZE) {
+		            result += stringFromCharCode.apply(null, codeUnits);
+		            codeUnits.length = 0;
+		          }
+		        }
+		        return result
+		      };
+		      /* istanbul ignore next */
+		      if (Object.defineProperty) {
+		        Object.defineProperty(String, 'fromCodePoint', {
+		          value: fromCodePoint,
+		          configurable: true,
+		          writable: true
+		        });
+		      } else {
+		        String.fromCodePoint = fromCodePoint;
+		      }
+		    }());
+		  }
+		})(exports); 
+	} (sax));
+	return sax;
+}
+
+var arrayHelper;
+var hasRequiredArrayHelper;
+
+function requireArrayHelper () {
+	if (hasRequiredArrayHelper) return arrayHelper;
+	hasRequiredArrayHelper = 1;
+	arrayHelper = {
+
+	  isArray: function(value) {
+	    if (Array.isArray) {
+	      return Array.isArray(value);
 	    }
+	    // fallback for older browsers like  IE 8
+	    return Object.prototype.toString.call( value ) === '[object Array]';
 	  }
 
-	  SAXParser.prototype = {
-	    end: function () { end(this); },
-	    write: write,
-	    resume: function () { this.error = null; return this },
-	    close: function () { return this.write(null) },
-	    flush: function () { flushBuffers(this); }
-	  };
-
-	  var Stream;
-	  try {
-	    Stream = require$$0.Stream;
-	  } catch (ex) {
-	    Stream = function () {};
-	  }
-	  if (!Stream) Stream = function () {};
-
-	  var streamWraps = sax.EVENTS.filter(function (ev) {
-	    return ev !== 'error' && ev !== 'end'
-	  });
-
-	  function createStream (strict, opt) {
-	    return new SAXStream(strict, opt)
-	  }
-
-	  function SAXStream (strict, opt) {
-	    if (!(this instanceof SAXStream)) {
-	      return new SAXStream(strict, opt)
-	    }
-
-	    Stream.apply(this);
-
-	    this._parser = new SAXParser(strict, opt);
-	    this.writable = true;
-	    this.readable = true;
-
-	    var me = this;
+	};
+	return arrayHelper;
+}
 
-	    this._parser.onend = function () {
-	      me.emit('end');
-	    };
+var optionsHelper;
+var hasRequiredOptionsHelper;
 
-	    this._parser.onerror = function (er) {
-	      me.emit('error', er);
+function requireOptionsHelper () {
+	if (hasRequiredOptionsHelper) return optionsHelper;
+	hasRequiredOptionsHelper = 1;
+	var isArray = requireArrayHelper().isArray;
 
-	      // if didn't throw, then means error was handled.
-	      // go ahead and clear error, so we can write again.
-	      me._parser.error = null;
-	    };
+	optionsHelper = {
 
-	    this._decoder = null;
-
-	    streamWraps.forEach(function (ev) {
-	      Object.defineProperty(me, 'on' + ev, {
-	        get: function () {
-	          return me._parser['on' + ev]
-	        },
-	        set: function (h) {
-	          if (!h) {
-	            me.removeAllListeners(ev);
-	            me._parser['on' + ev] = h;
-	            return h
-	          }
-	          me.on(ev, h);
-	        },
-	        enumerable: true,
-	        configurable: false
-	      });
-	    });
-	  }
-
-	  SAXStream.prototype = Object.create(Stream.prototype, {
-	    constructor: {
-	      value: SAXStream
-	    }
-	  });
-
-	  SAXStream.prototype.write = function (data) {
-	    if (typeof Buffer === 'function' &&
-	      typeof Buffer.isBuffer === 'function' &&
-	      Buffer.isBuffer(data)) {
-	      if (!this._decoder) {
-	        var SD = require$$1.StringDecoder;
-	        this._decoder = new SD('utf8');
+	  copyOptions: function (options) {
+	    var key, copy = {};
+	    for (key in options) {
+	      if (options.hasOwnProperty(key)) {
+	        copy[key] = options[key];
 	      }
-	      data = this._decoder.write(data);
 	    }
+	    return copy;
+	  },
 
-	    this._parser.write(data.toString());
-	    this.emit('data', data);
-	    return true
-	  };
-
-	  SAXStream.prototype.end = function (chunk) {
-	    if (chunk && chunk.length) {
-	      this.write(chunk);
+	  ensureFlagExists: function (item, options) {
+	    if (!(item in options) || typeof options[item] !== 'boolean') {
+	      options[item] = false;
 	    }
-	    this._parser.end();
-	    return true
-	  };
+	  },
 
-	  SAXStream.prototype.on = function (ev, handler) {
-	    var me = this;
-	    if (!me._parser['on' + ev] && streamWraps.indexOf(ev) !== -1) {
-	      me._parser['on' + ev] = function () {
-	        var args = arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments);
-	        args.splice(0, 0, ev);
-	        me.emit.apply(me, args);
-	      };
+	  ensureSpacesExists: function (options) {
+	    if (!('spaces' in options) || (typeof options.spaces !== 'number' && typeof options.spaces !== 'string')) {
+	      options.spaces = 0;
 	    }
+	  },
 
-	    return Stream.prototype.on.call(me, ev, handler)
-	  };
-
-	  // this really needs to be replaced with character classes.
-	  // XML allows all manner of ridiculous numbers and digits.
-	  var CDATA = '[CDATA[';
-	  var DOCTYPE = 'DOCTYPE';
-	  var XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
-	  var XMLNS_NAMESPACE = 'http://www.w3.org/2000/xmlns/';
-	  var rootNS = { xml: XML_NAMESPACE, xmlns: XMLNS_NAMESPACE };
-
-	  // http://www.w3.org/TR/REC-xml/#NT-NameStartChar
-	  // This implementation works on strings, a single character at a time
-	  // as such, it cannot ever support astral-plane characters (10000-EFFFF)
-	  // without a significant breaking change to either this  parser, or the
-	  // JavaScript language.  Implementation of an emoji-capable xml parser
-	  // is left as an exercise for the reader.
-	  var nameStart = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/;
-
-	  var nameBody = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040.\d-]/;
-
-	  var entityStart = /[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/;
-	  var entityBody = /[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040.\d-]/;
-
-	  function isWhitespace (c) {
-	    return c === ' ' || c === '\n' || c === '\r' || c === '\t'
-	  }
-
-	  function isQuote (c) {
-	    return c === '"' || c === '\''
-	  }
-
-	  function isAttribEnd (c) {
-	    return c === '>' || isWhitespace(c)
-	  }
-
-	  function isMatch (regex, c) {
-	    return regex.test(c)
-	  }
-
-	  function notMatch (regex, c) {
-	    return !isMatch(regex, c)
-	  }
-
-	  var S = 0;
-	  sax.STATE = {
-	    BEGIN: S++, // leading byte order mark or whitespace
-	    BEGIN_WHITESPACE: S++, // leading whitespace
-	    TEXT: S++, // general stuff
-	    TEXT_ENTITY: S++, // &amp and such.
-	    OPEN_WAKA: S++, // <
-	    SGML_DECL: S++, // <!BLARG
-	    SGML_DECL_QUOTED: S++, // <!BLARG foo "bar
-	    DOCTYPE: S++, // <!DOCTYPE
-	    DOCTYPE_QUOTED: S++, // <!DOCTYPE "//blah
-	    DOCTYPE_DTD: S++, // <!DOCTYPE "//blah" [ ...
-	    DOCTYPE_DTD_QUOTED: S++, // <!DOCTYPE "//blah" [ "foo
-	    COMMENT_STARTING: S++, // <!-
-	    COMMENT: S++, // <!--
-	    COMMENT_ENDING: S++, // <!-- blah -
-	    COMMENT_ENDED: S++, // <!-- blah --
-	    CDATA: S++, // <![CDATA[ something
-	    CDATA_ENDING: S++, // ]
-	    CDATA_ENDING_2: S++, // ]]
-	    PROC_INST: S++, // <?hi
-	    PROC_INST_BODY: S++, // <?hi there
-	    PROC_INST_ENDING: S++, // <?hi "there" ?
-	    OPEN_TAG: S++, // <strong
-	    OPEN_TAG_SLASH: S++, // <strong /
-	    ATTRIB: S++, // <a
-	    ATTRIB_NAME: S++, // <a foo
-	    ATTRIB_NAME_SAW_WHITE: S++, // <a foo _
-	    ATTRIB_VALUE: S++, // <a foo=
-	    ATTRIB_VALUE_QUOTED: S++, // <a foo="bar
-	    ATTRIB_VALUE_CLOSED: S++, // <a foo="bar"
-	    ATTRIB_VALUE_UNQUOTED: S++, // <a foo=bar
-	    ATTRIB_VALUE_ENTITY_Q: S++, // <foo bar="&quot;"
-	    ATTRIB_VALUE_ENTITY_U: S++, // <foo bar=&quot
-	    CLOSE_TAG: S++, // </a
-	    CLOSE_TAG_SAW_WHITE: S++, // </a   >
-	    SCRIPT: S++, // <script> ...
-	    SCRIPT_ENDING: S++ // <script> ... <
-	  };
-
-	  sax.XML_ENTITIES = {
-	    'amp': '&',
-	    'gt': '>',
-	    'lt': '<',
-	    'quot': '"',
-	    'apos': "'"
-	  };
-
-	  sax.ENTITIES = {
-	    'amp': '&',
-	    'gt': '>',
-	    'lt': '<',
-	    'quot': '"',
-	    'apos': "'",
-	    'AElig': 198,
-	    'Aacute': 193,
-	    'Acirc': 194,
-	    'Agrave': 192,
-	    'Aring': 197,
-	    'Atilde': 195,
-	    'Auml': 196,
-	    'Ccedil': 199,
-	    'ETH': 208,
-	    'Eacute': 201,
-	    'Ecirc': 202,
-	    'Egrave': 200,
-	    'Euml': 203,
-	    'Iacute': 205,
-	    'Icirc': 206,
-	    'Igrave': 204,
-	    'Iuml': 207,
-	    'Ntilde': 209,
-	    'Oacute': 211,
-	    'Ocirc': 212,
-	    'Ograve': 210,
-	    'Oslash': 216,
-	    'Otilde': 213,
-	    'Ouml': 214,
-	    'THORN': 222,
-	    'Uacute': 218,
-	    'Ucirc': 219,
-	    'Ugrave': 217,
-	    'Uuml': 220,
-	    'Yacute': 221,
-	    'aacute': 225,
-	    'acirc': 226,
-	    'aelig': 230,
-	    'agrave': 224,
-	    'aring': 229,
-	    'atilde': 227,
-	    'auml': 228,
-	    'ccedil': 231,
-	    'eacute': 233,
-	    'ecirc': 234,
-	    'egrave': 232,
-	    'eth': 240,
-	    'euml': 235,
-	    'iacute': 237,
-	    'icirc': 238,
-	    'igrave': 236,
-	    'iuml': 239,
-	    'ntilde': 241,
-	    'oacute': 243,
-	    'ocirc': 244,
-	    'ograve': 242,
-	    'oslash': 248,
-	    'otilde': 245,
-	    'ouml': 246,
-	    'szlig': 223,
-	    'thorn': 254,
-	    'uacute': 250,
-	    'ucirc': 251,
-	    'ugrave': 249,
-	    'uuml': 252,
-	    'yacute': 253,
-	    'yuml': 255,
-	    'copy': 169,
-	    'reg': 174,
-	    'nbsp': 160,
-	    'iexcl': 161,
-	    'cent': 162,
-	    'pound': 163,
-	    'curren': 164,
-	    'yen': 165,
-	    'brvbar': 166,
-	    'sect': 167,
-	    'uml': 168,
-	    'ordf': 170,
-	    'laquo': 171,
-	    'not': 172,
-	    'shy': 173,
-	    'macr': 175,
-	    'deg': 176,
-	    'plusmn': 177,
-	    'sup1': 185,
-	    'sup2': 178,
-	    'sup3': 179,
-	    'acute': 180,
-	    'micro': 181,
-	    'para': 182,
-	    'middot': 183,
-	    'cedil': 184,
-	    'ordm': 186,
-	    'raquo': 187,
-	    'frac14': 188,
-	    'frac12': 189,
-	    'frac34': 190,
-	    'iquest': 191,
-	    'times': 215,
-	    'divide': 247,
-	    'OElig': 338,
-	    'oelig': 339,
-	    'Scaron': 352,
-	    'scaron': 353,
-	    'Yuml': 376,
-	    'fnof': 402,
-	    'circ': 710,
-	    'tilde': 732,
-	    'Alpha': 913,
-	    'Beta': 914,
-	    'Gamma': 915,
-	    'Delta': 916,
-	    'Epsilon': 917,
-	    'Zeta': 918,
-	    'Eta': 919,
-	    'Theta': 920,
-	    'Iota': 921,
-	    'Kappa': 922,
-	    'Lambda': 923,
-	    'Mu': 924,
-	    'Nu': 925,
-	    'Xi': 926,
-	    'Omicron': 927,
-	    'Pi': 928,
-	    'Rho': 929,
-	    'Sigma': 931,
-	    'Tau': 932,
-	    'Upsilon': 933,
-	    'Phi': 934,
-	    'Chi': 935,
-	    'Psi': 936,
-	    'Omega': 937,
-	    'alpha': 945,
-	    'beta': 946,
-	    'gamma': 947,
-	    'delta': 948,
-	    'epsilon': 949,
-	    'zeta': 950,
-	    'eta': 951,
-	    'theta': 952,
-	    'iota': 953,
-	    'kappa': 954,
-	    'lambda': 955,
-	    'mu': 956,
-	    'nu': 957,
-	    'xi': 958,
-	    'omicron': 959,
-	    'pi': 960,
-	    'rho': 961,
-	    'sigmaf': 962,
-	    'sigma': 963,
-	    'tau': 964,
-	    'upsilon': 965,
-	    'phi': 966,
-	    'chi': 967,
-	    'psi': 968,
-	    'omega': 969,
-	    'thetasym': 977,
-	    'upsih': 978,
-	    'piv': 982,
-	    'ensp': 8194,
-	    'emsp': 8195,
-	    'thinsp': 8201,
-	    'zwnj': 8204,
-	    'zwj': 8205,
-	    'lrm': 8206,
-	    'rlm': 8207,
-	    'ndash': 8211,
-	    'mdash': 8212,
-	    'lsquo': 8216,
-	    'rsquo': 8217,
-	    'sbquo': 8218,
-	    'ldquo': 8220,
-	    'rdquo': 8221,
-	    'bdquo': 8222,
-	    'dagger': 8224,
-	    'Dagger': 8225,
-	    'bull': 8226,
-	    'hellip': 8230,
-	    'permil': 8240,
-	    'prime': 8242,
-	    'Prime': 8243,
-	    'lsaquo': 8249,
-	    'rsaquo': 8250,
-	    'oline': 8254,
-	    'frasl': 8260,
-	    'euro': 8364,
-	    'image': 8465,
-	    'weierp': 8472,
-	    'real': 8476,
-	    'trade': 8482,
-	    'alefsym': 8501,
-	    'larr': 8592,
-	    'uarr': 8593,
-	    'rarr': 8594,
-	    'darr': 8595,
-	    'harr': 8596,
-	    'crarr': 8629,
-	    'lArr': 8656,
-	    'uArr': 8657,
-	    'rArr': 8658,
-	    'dArr': 8659,
-	    'hArr': 8660,
-	    'forall': 8704,
-	    'part': 8706,
-	    'exist': 8707,
-	    'empty': 8709,
-	    'nabla': 8711,
-	    'isin': 8712,
-	    'notin': 8713,
-	    'ni': 8715,
-	    'prod': 8719,
-	    'sum': 8721,
-	    'minus': 8722,
-	    'lowast': 8727,
-	    'radic': 8730,
-	    'prop': 8733,
-	    'infin': 8734,
-	    'ang': 8736,
-	    'and': 8743,
-	    'or': 8744,
-	    'cap': 8745,
-	    'cup': 8746,
-	    'int': 8747,
-	    'there4': 8756,
-	    'sim': 8764,
-	    'cong': 8773,
-	    'asymp': 8776,
-	    'ne': 8800,
-	    'equiv': 8801,
-	    'le': 8804,
-	    'ge': 8805,
-	    'sub': 8834,
-	    'sup': 8835,
-	    'nsub': 8836,
-	    'sube': 8838,
-	    'supe': 8839,
-	    'oplus': 8853,
-	    'otimes': 8855,
-	    'perp': 8869,
-	    'sdot': 8901,
-	    'lceil': 8968,
-	    'rceil': 8969,
-	    'lfloor': 8970,
-	    'rfloor': 8971,
-	    'lang': 9001,
-	    'rang': 9002,
-	    'loz': 9674,
-	    'spades': 9824,
-	    'clubs': 9827,
-	    'hearts': 9829,
-	    'diams': 9830
-	  };
-
-	  Object.keys(sax.ENTITIES).forEach(function (key) {
-	    var e = sax.ENTITIES[key];
-	    var s = typeof e === 'number' ? String.fromCharCode(e) : e;
-	    sax.ENTITIES[key] = s;
-	  });
-
-	  for (var s in sax.STATE) {
-	    sax.STATE[sax.STATE[s]] = s;
-	  }
-
-	  // shorthand
-	  S = sax.STATE;
-
-	  function emit (parser, event, data) {
-	    parser[event] && parser[event](data);
-	  }
-
-	  function emitNode (parser, nodeType, data) {
-	    if (parser.textNode) closeText(parser);
-	    emit(parser, nodeType, data);
-	  }
-
-	  function closeText (parser) {
-	    parser.textNode = textopts(parser.opt, parser.textNode);
-	    if (parser.textNode) emit(parser, 'ontext', parser.textNode);
-	    parser.textNode = '';
-	  }
-
-	  function textopts (opt, text) {
-	    if (opt.trim) text = text.trim();
-	    if (opt.normalize) text = text.replace(/\s+/g, ' ');
-	    return text
-	  }
-
-	  function error (parser, er) {
-	    closeText(parser);
-	    if (parser.trackPosition) {
-	      er += '\nLine: ' + parser.line +
-	        '\nColumn: ' + parser.column +
-	        '\nChar: ' + parser.c;
+	  ensureAlwaysArrayExists: function (options) {
+	    if (!('alwaysArray' in options) || (typeof options.alwaysArray !== 'boolean' && !isArray(options.alwaysArray))) {
+	      options.alwaysArray = false;
 	    }
-	    er = new Error(er);
-	    parser.error = er;
-	    emit(parser, 'onerror', er);
-	    return parser
-	  }
+	  },
 
-	  function end (parser) {
-	    if (parser.sawRoot && !parser.closedRoot) strictFail(parser, 'Unclosed root tag');
-	    if ((parser.state !== S.BEGIN) &&
-	      (parser.state !== S.BEGIN_WHITESPACE) &&
-	      (parser.state !== S.TEXT)) {
-	      error(parser, 'Unexpected end');
+	  ensureKeyExists: function (key, options) {
+	    if (!(key + 'Key' in options) || typeof options[key + 'Key'] !== 'string') {
+	      options[key + 'Key'] = options.compact ? '_' + key : key;
 	    }
-	    closeText(parser);
-	    parser.c = '';
-	    parser.closed = true;
-	    emit(parser, 'onend');
-	    SAXParser.call(parser, parser.strict, parser.opt);
-	    return parser
-	  }
+	  },
 
-	  function strictFail (parser, message) {
-	    if (typeof parser !== 'object' || !(parser instanceof SAXParser)) {
-	      throw new Error('bad call to strictFail')
-	    }
-	    if (parser.strict) {
-	      error(parser, message);
-	    }
+	  checkFnExists: function (key, options) {
+	    return key + 'Fn' in options;
 	  }
 
-	  function newTag (parser) {
-	    if (!parser.strict) parser.tagName = parser.tagName[parser.looseCase]();
-	    var parent = parser.tags[parser.tags.length - 1] || parser;
-	    var tag = parser.tag = { name: parser.tagName, attributes: {} };
+	};
+	return optionsHelper;
+}
+
+var xml2js;
+var hasRequiredXml2js;
+
+function requireXml2js () {
+	if (hasRequiredXml2js) return xml2js;
+	hasRequiredXml2js = 1;
+	var sax = requireSax();
+	var helper = requireOptionsHelper();
+	var isArray = requireArrayHelper().isArray;
+
+	var options;
+	var currentElement;
+
+	function validateOptions(userOptions) {
+	  options = helper.copyOptions(userOptions);
+	  helper.ensureFlagExists('ignoreDeclaration', options);
+	  helper.ensureFlagExists('ignoreInstruction', options);
+	  helper.ensureFlagExists('ignoreAttributes', options);
+	  helper.ensureFlagExists('ignoreText', options);
+	  helper.ensureFlagExists('ignoreComment', options);
+	  helper.ensureFlagExists('ignoreCdata', options);
+	  helper.ensureFlagExists('ignoreDoctype', options);
+	  helper.ensureFlagExists('compact', options);
+	  helper.ensureFlagExists('alwaysChildren', options);
+	  helper.ensureFlagExists('addParent', options);
+	  helper.ensureFlagExists('trim', options);
+	  helper.ensureFlagExists('nativeType', options);
+	  helper.ensureFlagExists('nativeTypeAttributes', options);
+	  helper.ensureFlagExists('sanitize', options);
+	  helper.ensureFlagExists('instructionHasAttributes', options);
+	  helper.ensureFlagExists('captureSpacesBetweenElements', options);
+	  helper.ensureAlwaysArrayExists(options);
+	  helper.ensureKeyExists('declaration', options);
+	  helper.ensureKeyExists('instruction', options);
+	  helper.ensureKeyExists('attributes', options);
+	  helper.ensureKeyExists('text', options);
+	  helper.ensureKeyExists('comment', options);
+	  helper.ensureKeyExists('cdata', options);
+	  helper.ensureKeyExists('doctype', options);
+	  helper.ensureKeyExists('type', options);
+	  helper.ensureKeyExists('name', options);
+	  helper.ensureKeyExists('elements', options);
+	  helper.ensureKeyExists('parent', options);
+	  helper.checkFnExists('doctype', options);
+	  helper.checkFnExists('instruction', options);
+	  helper.checkFnExists('cdata', options);
+	  helper.checkFnExists('comment', options);
+	  helper.checkFnExists('text', options);
+	  helper.checkFnExists('instructionName', options);
+	  helper.checkFnExists('elementName', options);
+	  helper.checkFnExists('attributeName', options);
+	  helper.checkFnExists('attributeValue', options);
+	  helper.checkFnExists('attributes', options);
+	  return options;
+	}
 
-	    // will be overridden if tag contails an xmlns="foo" or xmlns:foo="bar"
-	    if (parser.opt.xmlns) {
-	      tag.ns = parent.ns;
-	    }
-	    parser.attribList.length = 0;
-	    emitNode(parser, 'onopentagstart', tag);
+	function nativeType(value) {
+	  var nValue = Number(value);
+	  if (!isNaN(nValue)) {
+	    return nValue;
 	  }
-
-	  function qname (name, attribute) {
-	    var i = name.indexOf(':');
-	    var qualName = i < 0 ? [ '', name ] : name.split(':');
-	    var prefix = qualName[0];
-	    var local = qualName[1];
-
-	    // <x "xmlns"="http://foo">
-	    if (attribute && name === 'xmlns') {
-	      prefix = 'xmlns';
-	      local = '';
-	    }
-
-	    return { prefix: prefix, local: local }
+	  var bValue = value.toLowerCase();
+	  if (bValue === 'true') {
+	    return true;
+	  } else if (bValue === 'false') {
+	    return false;
 	  }
+	  return value;
+	}
 
-	  function attrib (parser) {
-	    if (!parser.strict) {
-	      parser.attribName = parser.attribName[parser.looseCase]();
+	function addField(type, value) {
+	  var key;
+	  if (options.compact) {
+	    if (
+	      !currentElement[options[type + 'Key']] &&
+	      (isArray(options.alwaysArray) ? options.alwaysArray.indexOf(options[type + 'Key']) !== -1 : options.alwaysArray)
+	    ) {
+	      currentElement[options[type + 'Key']] = [];
 	    }
-
-	    if (parser.attribList.indexOf(parser.attribName) !== -1 ||
-	      parser.tag.attributes.hasOwnProperty(parser.attribName)) {
-	      parser.attribName = parser.attribValue = '';
-	      return
+	    if (currentElement[options[type + 'Key']] && !isArray(currentElement[options[type + 'Key']])) {
+	      currentElement[options[type + 'Key']] = [currentElement[options[type + 'Key']]];
 	    }
-
-	    if (parser.opt.xmlns) {
-	      var qn = qname(parser.attribName, true);
-	      var prefix = qn.prefix;
-	      var local = qn.local;
-
-	      if (prefix === 'xmlns') {
-	        // namespace binding attribute. push the binding into scope
-	        if (local === 'xml' && parser.attribValue !== XML_NAMESPACE) {
-	          strictFail(parser,
-	            'xml: prefix must be bound to ' + XML_NAMESPACE + '\n' +
-	            'Actual: ' + parser.attribValue);
-	        } else if (local === 'xmlns' && parser.attribValue !== XMLNS_NAMESPACE) {
-	          strictFail(parser,
-	            'xmlns: prefix must be bound to ' + XMLNS_NAMESPACE + '\n' +
-	            'Actual: ' + parser.attribValue);
-	        } else {
-	          var tag = parser.tag;
-	          var parent = parser.tags[parser.tags.length - 1] || parser;
-	          if (tag.ns === parent.ns) {
-	            tag.ns = Object.create(parent.ns);
+	    if (type + 'Fn' in options && typeof value === 'string') {
+	      value = options[type + 'Fn'](value, currentElement);
+	    }
+	    if (type === 'instruction' && ('instructionFn' in options || 'instructionNameFn' in options)) {
+	      for (key in value) {
+	        if (value.hasOwnProperty(key)) {
+	          if ('instructionFn' in options) {
+	            value[key] = options.instructionFn(value[key], key, currentElement);
+	          } else {
+	            var temp = value[key];
+	            delete value[key];
+	            value[options.instructionNameFn(key, temp, currentElement)] = temp;
 	          }
-	          tag.ns[local] = parser.attribValue;
 	        }
 	      }
-
-	      // defer onattribute events until all attributes have been seen
-	      // so any new bindings can take effect. preserve attribute order
-	      // so deferred events can be emitted in document order
-	      parser.attribList.push([parser.attribName, parser.attribValue]);
+	    }
+	    if (isArray(currentElement[options[type + 'Key']])) {
+	      currentElement[options[type + 'Key']].push(value);
 	    } else {
-	      // in non-xmlns mode, we can emit the event right away
-	      parser.tag.attributes[parser.attribName] = parser.attribValue;
-	      emitNode(parser, 'onattribute', {
-	        name: parser.attribName,
-	        value: parser.attribValue
-	      });
+	      currentElement[options[type + 'Key']] = value;
 	    }
-
-	    parser.attribName = parser.attribValue = '';
-	  }
-
-	  function openTag (parser, selfClosing) {
-	    if (parser.opt.xmlns) {
-	      // emit namespace binding events
-	      var tag = parser.tag;
-
-	      // add namespace info to tag
-	      var qn = qname(parser.tagName);
-	      tag.prefix = qn.prefix;
-	      tag.local = qn.local;
-	      tag.uri = tag.ns[qn.prefix] || '';
-
-	      if (tag.prefix && !tag.uri) {
-	        strictFail(parser, 'Unbound namespace prefix: ' +
-	          JSON.stringify(parser.tagName));
-	        tag.uri = qn.prefix;
-	      }
-
-	      var parent = parser.tags[parser.tags.length - 1] || parser;
-	      if (tag.ns && parent.ns !== tag.ns) {
-	        Object.keys(tag.ns).forEach(function (p) {
-	          emitNode(parser, 'onopennamespace', {
-	            prefix: p,
-	            uri: tag.ns[p]
-	          });
-	        });
-	      }
-
-	      // handle deferred onattribute events
-	      // Note: do not apply default ns to attributes:
-	      //   http://www.w3.org/TR/REC-xml-names/#defaulting
-	      for (var i = 0, l = parser.attribList.length; i < l; i++) {
-	        var nv = parser.attribList[i];
-	        var name = nv[0];
-	        var value = nv[1];
-	        var qualName = qname(name, true);
-	        var prefix = qualName.prefix;
-	        var local = qualName.local;
-	        var uri = prefix === '' ? '' : (tag.ns[prefix] || '');
-	        var a = {
-	          name: name,
-	          value: value,
-	          prefix: prefix,
-	          local: local,
-	          uri: uri
-	        };
-
-	        // if there's any attributes with an undefined namespace,
-	        // then fail on them now.
-	        if (prefix && prefix !== 'xmlns' && !uri) {
-	          strictFail(parser, 'Unbound namespace prefix: ' +
-	            JSON.stringify(prefix));
-	          a.uri = prefix;
+	  } else {
+	    if (!currentElement[options.elementsKey]) {
+	      currentElement[options.elementsKey] = [];
+	    }
+	    var element = {};
+	    element[options.typeKey] = type;
+	    if (type === 'instruction') {
+	      for (key in value) {
+	        if (value.hasOwnProperty(key)) {
+	          break;
 	        }
-	        parser.tag.attributes[name] = a;
-	        emitNode(parser, 'onattribute', a);
 	      }
-	      parser.attribList.length = 0;
-	    }
-
-	    parser.tag.isSelfClosing = !!selfClosing;
-
-	    // process the tag
-	    parser.sawRoot = true;
-	    parser.tags.push(parser.tag);
-	    emitNode(parser, 'onopentag', parser.tag);
-	    if (!selfClosing) {
-	      // special case for <script> in non-strict mode.
-	      if (!parser.noscript && parser.tagName.toLowerCase() === 'script') {
-	        parser.state = S.SCRIPT;
+	      element[options.nameKey] = 'instructionNameFn' in options ? options.instructionNameFn(key, value, currentElement) : key;
+	      if (options.instructionHasAttributes) {
+	        element[options.attributesKey] = value[key][options.attributesKey];
+	        if ('instructionFn' in options) {
+	          element[options.attributesKey] = options.instructionFn(element[options.attributesKey], key, currentElement);
+	        }
 	      } else {
-	        parser.state = S.TEXT;
+	        if ('instructionFn' in options) {
+	          value[key] = options.instructionFn(value[key], key, currentElement);
+	        }
+	        element[options.instructionKey] = value[key];
+	      }
+	    } else {
+	      if (type + 'Fn' in options) {
+	        value = options[type + 'Fn'](value, currentElement);
 	      }
-	      parser.tag = null;
-	      parser.tagName = '';
+	      element[options[type + 'Key']] = value;
 	    }
-	    parser.attribName = parser.attribValue = '';
-	    parser.attribList.length = 0;
-	  }
-
-	  function closeTag (parser) {
-	    if (!parser.tagName) {
-	      strictFail(parser, 'Weird empty close tag.');
-	      parser.textNode += '</>';
-	      parser.state = S.TEXT;
-	      return
+	    if (options.addParent) {
+	      element[options.parentKey] = currentElement;
 	    }
+	    currentElement[options.elementsKey].push(element);
+	  }
+	}
 
-	    if (parser.script) {
-	      if (parser.tagName !== 'script') {
-	        parser.script += '</' + parser.tagName + '>';
-	        parser.tagName = '';
-	        parser.state = S.SCRIPT;
-	        return
+	function manipulateAttributes(attributes) {
+	  if ('attributesFn' in options && attributes) {
+	    attributes = options.attributesFn(attributes, currentElement);
+	  }
+	  if ((options.trim || 'attributeValueFn' in options || 'attributeNameFn' in options || options.nativeTypeAttributes) && attributes) {
+	    var key;
+	    for (key in attributes) {
+	      if (attributes.hasOwnProperty(key)) {
+	        if (options.trim) attributes[key] = attributes[key].trim();
+	        if (options.nativeTypeAttributes) {
+	          attributes[key] = nativeType(attributes[key]);
+	        }
+	        if ('attributeValueFn' in options) attributes[key] = options.attributeValueFn(attributes[key], key, currentElement);
+	        if ('attributeNameFn' in options) {
+	          var temp = attributes[key];
+	          delete attributes[key];
+	          attributes[options.attributeNameFn(key, attributes[key], currentElement)] = temp;
+	        }
 	      }
-	      emitNode(parser, 'onscript', parser.script);
-	      parser.script = '';
 	    }
+	  }
+	  return attributes;
+	}
 
-	    // first make sure that the closing tag actually exists.
-	    // <a><b></c></b></a> will close everything, otherwise.
-	    var t = parser.tags.length;
-	    var tagName = parser.tagName;
-	    if (!parser.strict) {
-	      tagName = tagName[parser.looseCase]();
-	    }
-	    var closeTo = tagName;
-	    while (t--) {
-	      var close = parser.tags[t];
-	      if (close.name !== closeTo) {
-	        // fail the first time in strict mode
-	        strictFail(parser, 'Unexpected close tag');
-	      } else {
-	        break
-	      }
+	function onInstruction(instruction) {
+	  var attributes = {};
+	  if (instruction.body && (instruction.name.toLowerCase() === 'xml' || options.instructionHasAttributes)) {
+	    var attrsRegExp = /([\w:-]+)\s*=\s*(?:"([^"]*)"|'([^']*)'|(\w+))\s*/g;
+	    var match;
+	    while ((match = attrsRegExp.exec(instruction.body)) !== null) {
+	      attributes[match[1]] = match[2] || match[3] || match[4];
 	    }
-
-	    // didn't find it.  we already failed for strict, so just abort.
-	    if (t < 0) {
-	      strictFail(parser, 'Unmatched closing tag: ' + parser.tagName);
-	      parser.textNode += '</' + parser.tagName + '>';
-	      parser.state = S.TEXT;
-	      return
+	    attributes = manipulateAttributes(attributes);
+	  }
+	  if (instruction.name.toLowerCase() === 'xml') {
+	    if (options.ignoreDeclaration) {
+	      return;
 	    }
-	    parser.tagName = tagName;
-	    var s = parser.tags.length;
-	    while (s-- > t) {
-	      var tag = parser.tag = parser.tags.pop();
-	      parser.tagName = parser.tag.name;
-	      emitNode(parser, 'onclosetag', parser.tagName);
-
-	      var x = {};
-	      for (var i in tag.ns) {
-	        x[i] = tag.ns[i];
-	      }
-
-	      var parent = parser.tags[parser.tags.length - 1] || parser;
-	      if (parser.opt.xmlns && tag.ns !== parent.ns) {
-	        // remove namespace bindings introduced by tag
-	        Object.keys(tag.ns).forEach(function (p) {
-	          var n = tag.ns[p];
-	          emitNode(parser, 'onclosenamespace', { prefix: p, uri: n });
-	        });
-	      }
+	    currentElement[options.declarationKey] = {};
+	    if (Object.keys(attributes).length) {
+	      currentElement[options.declarationKey][options.attributesKey] = attributes;
 	    }
-	    if (t === 0) parser.closedRoot = true;
-	    parser.tagName = parser.attribValue = parser.attribName = '';
-	    parser.attribList.length = 0;
-	    parser.state = S.TEXT;
-	  }
-
-	  function parseEntity (parser) {
-	    var entity = parser.entity;
-	    var entityLC = entity.toLowerCase();
-	    var num;
-	    var numStr = '';
-
-	    if (parser.ENTITIES[entity]) {
-	      return parser.ENTITIES[entity]
+	    if (options.addParent) {
+	      currentElement[options.declarationKey][options.parentKey] = currentElement;
 	    }
-	    if (parser.ENTITIES[entityLC]) {
-	      return parser.ENTITIES[entityLC]
+	  } else {
+	    if (options.ignoreInstruction) {
+	      return;
 	    }
-	    entity = entityLC;
-	    if (entity.charAt(0) === '#') {
-	      if (entity.charAt(1) === 'x') {
-	        entity = entity.slice(2);
-	        num = parseInt(entity, 16);
-	        numStr = num.toString(16);
-	      } else {
-	        entity = entity.slice(1);
-	        num = parseInt(entity, 10);
-	        numStr = num.toString(10);
-	      }
+	    if (options.trim) {
+	      instruction.body = instruction.body.trim();
 	    }
-	    entity = entity.replace(/^0+/, '');
-	    if (isNaN(num) || numStr.toLowerCase() !== entity) {
-	      strictFail(parser, 'Invalid character entity');
-	      return '&' + parser.entity + ';'
+	    var value = {};
+	    if (options.instructionHasAttributes && Object.keys(attributes).length) {
+	      value[instruction.name] = {};
+	      value[instruction.name][options.attributesKey] = attributes;
+	    } else {
+	      value[instruction.name] = instruction.body;
 	    }
-
-	    return String.fromCodePoint(num)
+	    addField('instruction', value);
 	  }
+	}
 
-	  function beginWhiteSpace (parser, c) {
-	    if (c === '<') {
-	      parser.state = S.OPEN_WAKA;
-	      parser.startTagPosition = parser.position;
-	    } else if (!isWhitespace(c)) {
-	      // have to process this as a text node.
-	      // weird, but happens.
-	      strictFail(parser, 'Non-whitespace before first tag.');
-	      parser.textNode = c;
-	      parser.state = S.TEXT;
-	    }
+	function onStartElement(name, attributes) {
+	  var element;
+	  if (typeof name === 'object') {
+	    attributes = name.attributes;
+	    name = name.name;
 	  }
-
-	  function charAt (chunk, i) {
-	    var result = '';
-	    if (i < chunk.length) {
-	      result = chunk.charAt(i);
-	    }
-	    return result
+	  attributes = manipulateAttributes(attributes);
+	  if ('elementNameFn' in options) {
+	    name = options.elementNameFn(name, currentElement);
 	  }
-
-	  function write (chunk) {
-	    var parser = this;
-	    if (this.error) {
-	      throw this.error
+	  if (options.compact) {
+	    element = {};
+	    if (!options.ignoreAttributes && attributes && Object.keys(attributes).length) {
+	      element[options.attributesKey] = {};
+	      var key;
+	      for (key in attributes) {
+	        if (attributes.hasOwnProperty(key)) {
+	          element[options.attributesKey][key] = attributes[key];
+	        }
+	      }
 	    }
-	    if (parser.closed) {
-	      return error(parser,
-	        'Cannot write after close. Assign an onready handler.')
+	    if (
+	      !(name in currentElement) &&
+	      (isArray(options.alwaysArray) ? options.alwaysArray.indexOf(name) !== -1 : options.alwaysArray)
+	    ) {
+	      currentElement[name] = [];
 	    }
-	    if (chunk === null) {
-	      return end(parser)
+	    if (currentElement[name] && !isArray(currentElement[name])) {
+	      currentElement[name] = [currentElement[name]];
 	    }
-	    if (typeof chunk === 'object') {
-	      chunk = chunk.toString();
+	    if (isArray(currentElement[name])) {
+	      currentElement[name].push(element);
+	    } else {
+	      currentElement[name] = element;
 	    }
-	    var i = 0;
-	    var c = '';
-	    while (true) {
-	      c = charAt(chunk, i++);
-	      parser.c = c;
-
-	      if (!c) {
-	        break
-	      }
-
-	      if (parser.trackPosition) {
-	        parser.position++;
-	        if (c === '\n') {
-	          parser.line++;
-	          parser.column = 0;
-	        } else {
-	          parser.column++;
-	        }
-	      }
-
-	      switch (parser.state) {
-	        case S.BEGIN:
-	          parser.state = S.BEGIN_WHITESPACE;
-	          if (c === '\uFEFF') {
-	            continue
-	          }
-	          beginWhiteSpace(parser, c);
-	          continue
-
-	        case S.BEGIN_WHITESPACE:
-	          beginWhiteSpace(parser, c);
-	          continue
-
-	        case S.TEXT:
-	          if (parser.sawRoot && !parser.closedRoot) {
-	            var starti = i - 1;
-	            while (c && c !== '<' && c !== '&') {
-	              c = charAt(chunk, i++);
-	              if (c && parser.trackPosition) {
-	                parser.position++;
-	                if (c === '\n') {
-	                  parser.line++;
-	                  parser.column = 0;
-	                } else {
-	                  parser.column++;
-	                }
-	              }
-	            }
-	            parser.textNode += chunk.substring(starti, i - 1);
-	          }
-	          if (c === '<' && !(parser.sawRoot && parser.closedRoot && !parser.strict)) {
-	            parser.state = S.OPEN_WAKA;
-	            parser.startTagPosition = parser.position;
-	          } else {
-	            if (!isWhitespace(c) && (!parser.sawRoot || parser.closedRoot)) {
-	              strictFail(parser, 'Text data outside of root node.');
-	            }
-	            if (c === '&') {
-	              parser.state = S.TEXT_ENTITY;
-	            } else {
-	              parser.textNode += c;
-	            }
-	          }
-	          continue
-
-	        case S.SCRIPT:
-	          // only non-strict
-	          if (c === '<') {
-	            parser.state = S.SCRIPT_ENDING;
-	          } else {
-	            parser.script += c;
-	          }
-	          continue
-
-	        case S.SCRIPT_ENDING:
-	          if (c === '/') {
-	            parser.state = S.CLOSE_TAG;
-	          } else {
-	            parser.script += '<' + c;
-	            parser.state = S.SCRIPT;
-	          }
-	          continue
-
-	        case S.OPEN_WAKA:
-	          // either a /, ?, !, or text is coming next.
-	          if (c === '!') {
-	            parser.state = S.SGML_DECL;
-	            parser.sgmlDecl = '';
-	          } else if (isWhitespace(c)) ; else if (isMatch(nameStart, c)) {
-	            parser.state = S.OPEN_TAG;
-	            parser.tagName = c;
-	          } else if (c === '/') {
-	            parser.state = S.CLOSE_TAG;
-	            parser.tagName = '';
-	          } else if (c === '?') {
-	            parser.state = S.PROC_INST;
-	            parser.procInstName = parser.procInstBody = '';
-	          } else {
-	            strictFail(parser, 'Unencoded <');
-	            // if there was some whitespace, then add that in.
-	            if (parser.startTagPosition + 1 < parser.position) {
-	              var pad = parser.position - parser.startTagPosition;
-	              c = new Array(pad).join(' ') + c;
-	            }
-	            parser.textNode += '<' + c;
-	            parser.state = S.TEXT;
-	          }
-	          continue
-
-	        case S.SGML_DECL:
-	          if (parser.sgmlDecl + c === '--') {
-	            parser.state = S.COMMENT;
-	            parser.comment = '';
-	            parser.sgmlDecl = '';
-	            continue;
-	          }
-
-	          if (parser.doctype && parser.doctype !== true && parser.sgmlDecl) {
-	            parser.state = S.DOCTYPE_DTD;
-	            parser.doctype += '<!' + parser.sgmlDecl + c;
-	            parser.sgmlDecl = '';
-	          } else if ((parser.sgmlDecl + c).toUpperCase() === CDATA) {
-	            emitNode(parser, 'onopencdata');
-	            parser.state = S.CDATA;
-	            parser.sgmlDecl = '';
-	            parser.cdata = '';
-	          } else if ((parser.sgmlDecl + c).toUpperCase() === DOCTYPE) {
-	            parser.state = S.DOCTYPE;
-	            if (parser.doctype || parser.sawRoot) {
-	              strictFail(parser,
-	                'Inappropriately located doctype declaration');
-	            }
-	            parser.doctype = '';
-	            parser.sgmlDecl = '';
-	          } else if (c === '>') {
-	            emitNode(parser, 'onsgmldeclaration', parser.sgmlDecl);
-	            parser.sgmlDecl = '';
-	            parser.state = S.TEXT;
-	          } else if (isQuote(c)) {
-	            parser.state = S.SGML_DECL_QUOTED;
-	            parser.sgmlDecl += c;
-	          } else {
-	            parser.sgmlDecl += c;
-	          }
-	          continue
-
-	        case S.SGML_DECL_QUOTED:
-	          if (c === parser.q) {
-	            parser.state = S.SGML_DECL;
-	            parser.q = '';
-	          }
-	          parser.sgmlDecl += c;
-	          continue
-
-	        case S.DOCTYPE:
-	          if (c === '>') {
-	            parser.state = S.TEXT;
-	            emitNode(parser, 'ondoctype', parser.doctype);
-	            parser.doctype = true; // just remember that we saw it.
-	          } else {
-	            parser.doctype += c;
-	            if (c === '[') {
-	              parser.state = S.DOCTYPE_DTD;
-	            } else if (isQuote(c)) {
-	              parser.state = S.DOCTYPE_QUOTED;
-	              parser.q = c;
-	            }
-	          }
-	          continue
-
-	        case S.DOCTYPE_QUOTED:
-	          parser.doctype += c;
-	          if (c === parser.q) {
-	            parser.q = '';
-	            parser.state = S.DOCTYPE;
-	          }
-	          continue
-
-	        case S.DOCTYPE_DTD:
-	          if (c === ']') {
-	            parser.doctype += c;
-	            parser.state = S.DOCTYPE;
-	          } else if (c === '<') {
-	            parser.state = S.OPEN_WAKA;
-	            parser.startTagPosition = parser.position;
-	          } else if (isQuote(c)) {
-	            parser.doctype += c;
-	            parser.state = S.DOCTYPE_DTD_QUOTED;
-	            parser.q = c;
-	          } else {
-	            parser.doctype += c;
-	          }
-	          continue
-
-	        case S.DOCTYPE_DTD_QUOTED:
-	          parser.doctype += c;
-	          if (c === parser.q) {
-	            parser.state = S.DOCTYPE_DTD;
-	            parser.q = '';
-	          }
-	          continue
-
-	        case S.COMMENT:
-	          if (c === '-') {
-	            parser.state = S.COMMENT_ENDING;
-	          } else {
-	            parser.comment += c;
-	          }
-	          continue
-
-	        case S.COMMENT_ENDING:
-	          if (c === '-') {
-	            parser.state = S.COMMENT_ENDED;
-	            parser.comment = textopts(parser.opt, parser.comment);
-	            if (parser.comment) {
-	              emitNode(parser, 'oncomment', parser.comment);
-	            }
-	            parser.comment = '';
-	          } else {
-	            parser.comment += '-' + c;
-	            parser.state = S.COMMENT;
-	          }
-	          continue
-
-	        case S.COMMENT_ENDED:
-	          if (c !== '>') {
-	            strictFail(parser, 'Malformed comment');
-	            // allow <!-- blah -- bloo --> in non-strict mode,
-	            // which is a comment of " blah -- bloo "
-	            parser.comment += '--' + c;
-	            parser.state = S.COMMENT;
-	          } else if (parser.doctype && parser.doctype !== true) {
-	            parser.state = S.DOCTYPE_DTD;
-	          } else {
-	            parser.state = S.TEXT;
-	          }
-	          continue
-
-	        case S.CDATA:
-	          if (c === ']') {
-	            parser.state = S.CDATA_ENDING;
-	          } else {
-	            parser.cdata += c;
-	          }
-	          continue
-
-	        case S.CDATA_ENDING:
-	          if (c === ']') {
-	            parser.state = S.CDATA_ENDING_2;
-	          } else {
-	            parser.cdata += ']' + c;
-	            parser.state = S.CDATA;
-	          }
-	          continue
-
-	        case S.CDATA_ENDING_2:
-	          if (c === '>') {
-	            if (parser.cdata) {
-	              emitNode(parser, 'oncdata', parser.cdata);
-	            }
-	            emitNode(parser, 'onclosecdata');
-	            parser.cdata = '';
-	            parser.state = S.TEXT;
-	          } else if (c === ']') {
-	            parser.cdata += ']';
-	          } else {
-	            parser.cdata += ']]' + c;
-	            parser.state = S.CDATA;
-	          }
-	          continue
-
-	        case S.PROC_INST:
-	          if (c === '?') {
-	            parser.state = S.PROC_INST_ENDING;
-	          } else if (isWhitespace(c)) {
-	            parser.state = S.PROC_INST_BODY;
-	          } else {
-	            parser.procInstName += c;
-	          }
-	          continue
-
-	        case S.PROC_INST_BODY:
-	          if (!parser.procInstBody && isWhitespace(c)) {
-	            continue
-	          } else if (c === '?') {
-	            parser.state = S.PROC_INST_ENDING;
-	          } else {
-	            parser.procInstBody += c;
-	          }
-	          continue
-
-	        case S.PROC_INST_ENDING:
-	          if (c === '>') {
-	            emitNode(parser, 'onprocessinginstruction', {
-	              name: parser.procInstName,
-	              body: parser.procInstBody
-	            });
-	            parser.procInstName = parser.procInstBody = '';
-	            parser.state = S.TEXT;
-	          } else {
-	            parser.procInstBody += '?' + c;
-	            parser.state = S.PROC_INST_BODY;
-	          }
-	          continue
-
-	        case S.OPEN_TAG:
-	          if (isMatch(nameBody, c)) {
-	            parser.tagName += c;
-	          } else {
-	            newTag(parser);
-	            if (c === '>') {
-	              openTag(parser);
-	            } else if (c === '/') {
-	              parser.state = S.OPEN_TAG_SLASH;
-	            } else {
-	              if (!isWhitespace(c)) {
-	                strictFail(parser, 'Invalid character in tag name');
-	              }
-	              parser.state = S.ATTRIB;
-	            }
-	          }
-	          continue
-
-	        case S.OPEN_TAG_SLASH:
-	          if (c === '>') {
-	            openTag(parser, true);
-	            closeTag(parser);
-	          } else {
-	            strictFail(parser, 'Forward-slash in opening tag not followed by >');
-	            parser.state = S.ATTRIB;
-	          }
-	          continue
-
-	        case S.ATTRIB:
-	          // haven't read the attribute name yet.
-	          if (isWhitespace(c)) {
-	            continue
-	          } else if (c === '>') {
-	            openTag(parser);
-	          } else if (c === '/') {
-	            parser.state = S.OPEN_TAG_SLASH;
-	          } else if (isMatch(nameStart, c)) {
-	            parser.attribName = c;
-	            parser.attribValue = '';
-	            parser.state = S.ATTRIB_NAME;
-	          } else {
-	            strictFail(parser, 'Invalid attribute name');
-	          }
-	          continue
-
-	        case S.ATTRIB_NAME:
-	          if (c === '=') {
-	            parser.state = S.ATTRIB_VALUE;
-	          } else if (c === '>') {
-	            strictFail(parser, 'Attribute without value');
-	            parser.attribValue = parser.attribName;
-	            attrib(parser);
-	            openTag(parser);
-	          } else if (isWhitespace(c)) {
-	            parser.state = S.ATTRIB_NAME_SAW_WHITE;
-	          } else if (isMatch(nameBody, c)) {
-	            parser.attribName += c;
-	          } else {
-	            strictFail(parser, 'Invalid attribute name');
-	          }
-	          continue
-
-	        case S.ATTRIB_NAME_SAW_WHITE:
-	          if (c === '=') {
-	            parser.state = S.ATTRIB_VALUE;
-	          } else if (isWhitespace(c)) {
-	            continue
-	          } else {
-	            strictFail(parser, 'Attribute without value');
-	            parser.tag.attributes[parser.attribName] = '';
-	            parser.attribValue = '';
-	            emitNode(parser, 'onattribute', {
-	              name: parser.attribName,
-	              value: ''
-	            });
-	            parser.attribName = '';
-	            if (c === '>') {
-	              openTag(parser);
-	            } else if (isMatch(nameStart, c)) {
-	              parser.attribName = c;
-	              parser.state = S.ATTRIB_NAME;
-	            } else {
-	              strictFail(parser, 'Invalid attribute name');
-	              parser.state = S.ATTRIB;
-	            }
-	          }
-	          continue
-
-	        case S.ATTRIB_VALUE:
-	          if (isWhitespace(c)) {
-	            continue
-	          } else if (isQuote(c)) {
-	            parser.q = c;
-	            parser.state = S.ATTRIB_VALUE_QUOTED;
-	          } else {
-	            if (!parser.opt.unquotedAttributeValues) {
-	              error(parser, 'Unquoted attribute value');
-	            }
-	            parser.state = S.ATTRIB_VALUE_UNQUOTED;
-	            parser.attribValue = c;
-	          }
-	          continue
-
-	        case S.ATTRIB_VALUE_QUOTED:
-	          if (c !== parser.q) {
-	            if (c === '&') {
-	              parser.state = S.ATTRIB_VALUE_ENTITY_Q;
-	            } else {
-	              parser.attribValue += c;
-	            }
-	            continue
-	          }
-	          attrib(parser);
-	          parser.q = '';
-	          parser.state = S.ATTRIB_VALUE_CLOSED;
-	          continue
-
-	        case S.ATTRIB_VALUE_CLOSED:
-	          if (isWhitespace(c)) {
-	            parser.state = S.ATTRIB;
-	          } else if (c === '>') {
-	            openTag(parser);
-	          } else if (c === '/') {
-	            parser.state = S.OPEN_TAG_SLASH;
-	          } else if (isMatch(nameStart, c)) {
-	            strictFail(parser, 'No whitespace between attributes');
-	            parser.attribName = c;
-	            parser.attribValue = '';
-	            parser.state = S.ATTRIB_NAME;
-	          } else {
-	            strictFail(parser, 'Invalid attribute name');
-	          }
-	          continue
-
-	        case S.ATTRIB_VALUE_UNQUOTED:
-	          if (!isAttribEnd(c)) {
-	            if (c === '&') {
-	              parser.state = S.ATTRIB_VALUE_ENTITY_U;
-	            } else {
-	              parser.attribValue += c;
-	            }
-	            continue
-	          }
-	          attrib(parser);
-	          if (c === '>') {
-	            openTag(parser);
-	          } else {
-	            parser.state = S.ATTRIB;
-	          }
-	          continue
-
-	        case S.CLOSE_TAG:
-	          if (!parser.tagName) {
-	            if (isWhitespace(c)) {
-	              continue
-	            } else if (notMatch(nameStart, c)) {
-	              if (parser.script) {
-	                parser.script += '</' + c;
-	                parser.state = S.SCRIPT;
-	              } else {
-	                strictFail(parser, 'Invalid tagname in closing tag.');
-	              }
-	            } else {
-	              parser.tagName = c;
-	            }
-	          } else if (c === '>') {
-	            closeTag(parser);
-	          } else if (isMatch(nameBody, c)) {
-	            parser.tagName += c;
-	          } else if (parser.script) {
-	            parser.script += '</' + parser.tagName;
-	            parser.tagName = '';
-	            parser.state = S.SCRIPT;
-	          } else {
-	            if (!isWhitespace(c)) {
-	              strictFail(parser, 'Invalid tagname in closing tag');
-	            }
-	            parser.state = S.CLOSE_TAG_SAW_WHITE;
-	          }
-	          continue
-
-	        case S.CLOSE_TAG_SAW_WHITE:
-	          if (isWhitespace(c)) {
-	            continue
-	          }
-	          if (c === '>') {
-	            closeTag(parser);
-	          } else {
-	            strictFail(parser, 'Invalid characters in closing tag');
-	          }
-	          continue
-
-	        case S.TEXT_ENTITY:
-	        case S.ATTRIB_VALUE_ENTITY_Q:
-	        case S.ATTRIB_VALUE_ENTITY_U:
-	          var returnState;
-	          var buffer;
-	          switch (parser.state) {
-	            case S.TEXT_ENTITY:
-	              returnState = S.TEXT;
-	              buffer = 'textNode';
-	              break
-
-	            case S.ATTRIB_VALUE_ENTITY_Q:
-	              returnState = S.ATTRIB_VALUE_QUOTED;
-	              buffer = 'attribValue';
-	              break
-
-	            case S.ATTRIB_VALUE_ENTITY_U:
-	              returnState = S.ATTRIB_VALUE_UNQUOTED;
-	              buffer = 'attribValue';
-	              break
-	          }
-
-	          if (c === ';') {
-	            var parsedEntity = parseEntity(parser);
-	            if (parser.opt.unparsedEntities && !Object.values(sax.XML_ENTITIES).includes(parsedEntity)) {
-	              parser.entity = '';
-	              parser.state = returnState;
-	              parser.write(parsedEntity);
-	            } else {
-	              parser[buffer] += parsedEntity;
-	              parser.entity = '';
-	              parser.state = returnState;
-	            }
-	          } else if (isMatch(parser.entity.length ? entityBody : entityStart, c)) {
-	            parser.entity += c;
-	          } else {
-	            strictFail(parser, 'Invalid character in entity name');
-	            parser[buffer] += '&' + parser.entity + c;
-	            parser.entity = '';
-	            parser.state = returnState;
-	          }
-
-	          continue
-
-	        default: /* istanbul ignore next */ {
-	          throw new Error(parser, 'Unknown state: ' + parser.state)
-	        }
-	      }
-	    } // while
-
-	    if (parser.position >= parser.bufferCheckPosition) {
-	      checkBufferLength(parser);
+	  } else {
+	    if (!currentElement[options.elementsKey]) {
+	      currentElement[options.elementsKey] = [];
 	    }
-	    return parser
+	    element = {};
+	    element[options.typeKey] = 'element';
+	    element[options.nameKey] = name;
+	    if (!options.ignoreAttributes && attributes && Object.keys(attributes).length) {
+	      element[options.attributesKey] = attributes;
+	    }
+	    if (options.alwaysChildren) {
+	      element[options.elementsKey] = [];
+	    }
+	    currentElement[options.elementsKey].push(element);
 	  }
+	  element[options.parentKey] = currentElement; // will be deleted in onEndElement() if !options.addParent
+	  currentElement = element;
+	}
 
-	  /*! http://mths.be/fromcodepoint v0.1.0 by @mathias */
-	  /* istanbul ignore next */
-	  if (!String.fromCodePoint) {
-	    (function () {
-	      var stringFromCharCode = String.fromCharCode;
-	      var floor = Math.floor;
-	      var fromCodePoint = function () {
-	        var MAX_SIZE = 0x4000;
-	        var codeUnits = [];
-	        var highSurrogate;
-	        var lowSurrogate;
-	        var index = -1;
-	        var length = arguments.length;
-	        if (!length) {
-	          return ''
-	        }
-	        var result = '';
-	        while (++index < length) {
-	          var codePoint = Number(arguments[index]);
-	          if (
-	            !isFinite(codePoint) || // `NaN`, `+Infinity`, or `-Infinity`
-	            codePoint < 0 || // not a valid Unicode code point
-	            codePoint > 0x10FFFF || // not a valid Unicode code point
-	            floor(codePoint) !== codePoint // not an integer
-	          ) {
-	            throw RangeError('Invalid code point: ' + codePoint)
-	          }
-	          if (codePoint <= 0xFFFF) { // BMP code point
-	            codeUnits.push(codePoint);
-	          } else { // Astral code point; split in surrogate halves
-	            // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
-	            codePoint -= 0x10000;
-	            highSurrogate = (codePoint >> 10) + 0xD800;
-	            lowSurrogate = (codePoint % 0x400) + 0xDC00;
-	            codeUnits.push(highSurrogate, lowSurrogate);
-	          }
-	          if (index + 1 === length || codeUnits.length > MAX_SIZE) {
-	            result += stringFromCharCode.apply(null, codeUnits);
-	            codeUnits.length = 0;
-	          }
-	        }
-	        return result
-	      };
-	      /* istanbul ignore next */
-	      if (Object.defineProperty) {
-	        Object.defineProperty(String, 'fromCodePoint', {
-	          value: fromCodePoint,
-	          configurable: true,
-	          writable: true
-	        });
-	      } else {
-	        String.fromCodePoint = fromCodePoint;
-	      }
-	    }());
+	function onText(text) {
+	  if (options.ignoreText) {
+	    return;
 	  }
-	})(exports); 
-} (sax$1));
-
-var arrayHelper = {
-
-  isArray: function(value) {
-    if (Array.isArray) {
-      return Array.isArray(value);
-    }
-    // fallback for older browsers like  IE 8
-    return Object.prototype.toString.call( value ) === '[object Array]';
-  }
-
-};
+	  if (!text.trim() && !options.captureSpacesBetweenElements) {
+	    return;
+	  }
+	  if (options.trim) {
+	    text = text.trim();
+	  }
+	  if (options.nativeType) {
+	    text = nativeType(text);
+	  }
+	  if (options.sanitize) {
+	    text = text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+	  }
+	  addField('text', text);
+	}
 
-var isArray$2 = arrayHelper.isArray;
+	function onComment(comment) {
+	  if (options.ignoreComment) {
+	    return;
+	  }
+	  if (options.trim) {
+	    comment = comment.trim();
+	  }
+	  addField('comment', comment);
+	}
 
-var optionsHelper = {
+	function onEndElement(name) {
+	  var parentElement = currentElement[options.parentKey];
+	  if (!options.addParent) {
+	    delete currentElement[options.parentKey];
+	  }
+	  currentElement = parentElement;
+	}
 
-  copyOptions: function (options) {
-    var key, copy = {};
-    for (key in options) {
-      if (options.hasOwnProperty(key)) {
-        copy[key] = options[key];
-      }
-    }
-    return copy;
-  },
-
-  ensureFlagExists: function (item, options) {
-    if (!(item in options) || typeof options[item] !== 'boolean') {
-      options[item] = false;
-    }
-  },
-
-  ensureSpacesExists: function (options) {
-    if (!('spaces' in options) || (typeof options.spaces !== 'number' && typeof options.spaces !== 'string')) {
-      options.spaces = 0;
-    }
-  },
-
-  ensureAlwaysArrayExists: function (options) {
-    if (!('alwaysArray' in options) || (typeof options.alwaysArray !== 'boolean' && !isArray$2(options.alwaysArray))) {
-      options.alwaysArray = false;
-    }
-  },
-
-  ensureKeyExists: function (key, options) {
-    if (!(key + 'Key' in options) || typeof options[key + 'Key'] !== 'string') {
-      options[key + 'Key'] = options.compact ? '_' + key : key;
-    }
-  },
-
-  checkFnExists: function (key, options) {
-    return key + 'Fn' in options;
-  }
-
-};
-
-var sax = sax$1;
-var helper$2 = optionsHelper;
-var isArray$1 = arrayHelper.isArray;
-
-var options;
-var currentElement$1;
-
-function validateOptions$2(userOptions) {
-  options = helper$2.copyOptions(userOptions);
-  helper$2.ensureFlagExists('ignoreDeclaration', options);
-  helper$2.ensureFlagExists('ignoreInstruction', options);
-  helper$2.ensureFlagExists('ignoreAttributes', options);
-  helper$2.ensureFlagExists('ignoreText', options);
-  helper$2.ensureFlagExists('ignoreComment', options);
-  helper$2.ensureFlagExists('ignoreCdata', options);
-  helper$2.ensureFlagExists('ignoreDoctype', options);
-  helper$2.ensureFlagExists('compact', options);
-  helper$2.ensureFlagExists('alwaysChildren', options);
-  helper$2.ensureFlagExists('addParent', options);
-  helper$2.ensureFlagExists('trim', options);
-  helper$2.ensureFlagExists('nativeType', options);
-  helper$2.ensureFlagExists('nativeTypeAttributes', options);
-  helper$2.ensureFlagExists('sanitize', options);
-  helper$2.ensureFlagExists('instructionHasAttributes', options);
-  helper$2.ensureFlagExists('captureSpacesBetweenElements', options);
-  helper$2.ensureAlwaysArrayExists(options);
-  helper$2.ensureKeyExists('declaration', options);
-  helper$2.ensureKeyExists('instruction', options);
-  helper$2.ensureKeyExists('attributes', options);
-  helper$2.ensureKeyExists('text', options);
-  helper$2.ensureKeyExists('comment', options);
-  helper$2.ensureKeyExists('cdata', options);
-  helper$2.ensureKeyExists('doctype', options);
-  helper$2.ensureKeyExists('type', options);
-  helper$2.ensureKeyExists('name', options);
-  helper$2.ensureKeyExists('elements', options);
-  helper$2.ensureKeyExists('parent', options);
-  helper$2.checkFnExists('doctype', options);
-  helper$2.checkFnExists('instruction', options);
-  helper$2.checkFnExists('cdata', options);
-  helper$2.checkFnExists('comment', options);
-  helper$2.checkFnExists('text', options);
-  helper$2.checkFnExists('instructionName', options);
-  helper$2.checkFnExists('elementName', options);
-  helper$2.checkFnExists('attributeName', options);
-  helper$2.checkFnExists('attributeValue', options);
-  helper$2.checkFnExists('attributes', options);
-  return options;
-}
-
-function nativeType$1(value) {
-  var nValue = Number(value);
-  if (!isNaN(nValue)) {
-    return nValue;
-  }
-  var bValue = value.toLowerCase();
-  if (bValue === 'true') {
-    return true;
-  } else if (bValue === 'false') {
-    return false;
-  }
-  return value;
-}
+	function onCdata(cdata) {
+	  if (options.ignoreCdata) {
+	    return;
+	  }
+	  if (options.trim) {
+	    cdata = cdata.trim();
+	  }
+	  addField('cdata', cdata);
+	}
 
-function addField(type, value) {
-  var key;
-  if (options.compact) {
-    if (
-      !currentElement$1[options[type + 'Key']] &&
-      (isArray$1(options.alwaysArray) ? options.alwaysArray.indexOf(options[type + 'Key']) !== -1 : options.alwaysArray)
-    ) {
-      currentElement$1[options[type + 'Key']] = [];
-    }
-    if (currentElement$1[options[type + 'Key']] && !isArray$1(currentElement$1[options[type + 'Key']])) {
-      currentElement$1[options[type + 'Key']] = [currentElement$1[options[type + 'Key']]];
-    }
-    if (type + 'Fn' in options && typeof value === 'string') {
-      value = options[type + 'Fn'](value, currentElement$1);
-    }
-    if (type === 'instruction' && ('instructionFn' in options || 'instructionNameFn' in options)) {
-      for (key in value) {
-        if (value.hasOwnProperty(key)) {
-          if ('instructionFn' in options) {
-            value[key] = options.instructionFn(value[key], key, currentElement$1);
-          } else {
-            var temp = value[key];
-            delete value[key];
-            value[options.instructionNameFn(key, temp, currentElement$1)] = temp;
-          }
-        }
-      }
-    }
-    if (isArray$1(currentElement$1[options[type + 'Key']])) {
-      currentElement$1[options[type + 'Key']].push(value);
-    } else {
-      currentElement$1[options[type + 'Key']] = value;
-    }
-  } else {
-    if (!currentElement$1[options.elementsKey]) {
-      currentElement$1[options.elementsKey] = [];
-    }
-    var element = {};
-    element[options.typeKey] = type;
-    if (type === 'instruction') {
-      for (key in value) {
-        if (value.hasOwnProperty(key)) {
-          break;
-        }
-      }
-      element[options.nameKey] = 'instructionNameFn' in options ? options.instructionNameFn(key, value, currentElement$1) : key;
-      if (options.instructionHasAttributes) {
-        element[options.attributesKey] = value[key][options.attributesKey];
-        if ('instructionFn' in options) {
-          element[options.attributesKey] = options.instructionFn(element[options.attributesKey], key, currentElement$1);
-        }
-      } else {
-        if ('instructionFn' in options) {
-          value[key] = options.instructionFn(value[key], key, currentElement$1);
-        }
-        element[options.instructionKey] = value[key];
-      }
-    } else {
-      if (type + 'Fn' in options) {
-        value = options[type + 'Fn'](value, currentElement$1);
-      }
-      element[options[type + 'Key']] = value;
-    }
-    if (options.addParent) {
-      element[options.parentKey] = currentElement$1;
-    }
-    currentElement$1[options.elementsKey].push(element);
-  }
-}
+	function onDoctype(doctype) {
+	  if (options.ignoreDoctype) {
+	    return;
+	  }
+	  doctype = doctype.replace(/^ /, '');
+	  if (options.trim) {
+	    doctype = doctype.trim();
+	  }
+	  addField('doctype', doctype);
+	}
 
-function manipulateAttributes(attributes) {
-  if ('attributesFn' in options && attributes) {
-    attributes = options.attributesFn(attributes, currentElement$1);
-  }
-  if ((options.trim || 'attributeValueFn' in options || 'attributeNameFn' in options || options.nativeTypeAttributes) && attributes) {
-    var key;
-    for (key in attributes) {
-      if (attributes.hasOwnProperty(key)) {
-        if (options.trim) attributes[key] = attributes[key].trim();
-        if (options.nativeTypeAttributes) {
-          attributes[key] = nativeType$1(attributes[key]);
-        }
-        if ('attributeValueFn' in options) attributes[key] = options.attributeValueFn(attributes[key], key, currentElement$1);
-        if ('attributeNameFn' in options) {
-          var temp = attributes[key];
-          delete attributes[key];
-          attributes[options.attributeNameFn(key, attributes[key], currentElement$1)] = temp;
-        }
-      }
-    }
-  }
-  return attributes;
-}
+	function onError(error) {
+	  error.note = error; //console.error(error);
+	}
 
-function onInstruction(instruction) {
-  var attributes = {};
-  if (instruction.body && (instruction.name.toLowerCase() === 'xml' || options.instructionHasAttributes)) {
-    var attrsRegExp = /([\w:-]+)\s*=\s*(?:"([^"]*)"|'([^']*)'|(\w+))\s*/g;
-    var match;
-    while ((match = attrsRegExp.exec(instruction.body)) !== null) {
-      attributes[match[1]] = match[2] || match[3] || match[4];
-    }
-    attributes = manipulateAttributes(attributes);
-  }
-  if (instruction.name.toLowerCase() === 'xml') {
-    if (options.ignoreDeclaration) {
-      return;
-    }
-    currentElement$1[options.declarationKey] = {};
-    if (Object.keys(attributes).length) {
-      currentElement$1[options.declarationKey][options.attributesKey] = attributes;
-    }
-    if (options.addParent) {
-      currentElement$1[options.declarationKey][options.parentKey] = currentElement$1;
-    }
-  } else {
-    if (options.ignoreInstruction) {
-      return;
-    }
-    if (options.trim) {
-      instruction.body = instruction.body.trim();
-    }
-    var value = {};
-    if (options.instructionHasAttributes && Object.keys(attributes).length) {
-      value[instruction.name] = {};
-      value[instruction.name][options.attributesKey] = attributes;
-    } else {
-      value[instruction.name] = instruction.body;
-    }
-    addField('instruction', value);
-  }
-}
+	xml2js = function (xml, userOptions) {
 
-function onStartElement(name, attributes) {
-  var element;
-  if (typeof name === 'object') {
-    attributes = name.attributes;
-    name = name.name;
-  }
-  attributes = manipulateAttributes(attributes);
-  if ('elementNameFn' in options) {
-    name = options.elementNameFn(name, currentElement$1);
-  }
-  if (options.compact) {
-    element = {};
-    if (!options.ignoreAttributes && attributes && Object.keys(attributes).length) {
-      element[options.attributesKey] = {};
-      var key;
-      for (key in attributes) {
-        if (attributes.hasOwnProperty(key)) {
-          element[options.attributesKey][key] = attributes[key];
-        }
-      }
-    }
-    if (
-      !(name in currentElement$1) &&
-      (isArray$1(options.alwaysArray) ? options.alwaysArray.indexOf(name) !== -1 : options.alwaysArray)
-    ) {
-      currentElement$1[name] = [];
-    }
-    if (currentElement$1[name] && !isArray$1(currentElement$1[name])) {
-      currentElement$1[name] = [currentElement$1[name]];
-    }
-    if (isArray$1(currentElement$1[name])) {
-      currentElement$1[name].push(element);
-    } else {
-      currentElement$1[name] = element;
-    }
-  } else {
-    if (!currentElement$1[options.elementsKey]) {
-      currentElement$1[options.elementsKey] = [];
-    }
-    element = {};
-    element[options.typeKey] = 'element';
-    element[options.nameKey] = name;
-    if (!options.ignoreAttributes && attributes && Object.keys(attributes).length) {
-      element[options.attributesKey] = attributes;
-    }
-    if (options.alwaysChildren) {
-      element[options.elementsKey] = [];
-    }
-    currentElement$1[options.elementsKey].push(element);
-  }
-  element[options.parentKey] = currentElement$1; // will be deleted in onEndElement() if !options.addParent
-  currentElement$1 = element;
-}
+	  var parser = sax.parser(true, {}) ;
+	  var result = {};
+	  currentElement = result;
 
-function onText(text) {
-  if (options.ignoreText) {
-    return;
-  }
-  if (!text.trim() && !options.captureSpacesBetweenElements) {
-    return;
-  }
-  if (options.trim) {
-    text = text.trim();
-  }
-  if (options.nativeType) {
-    text = nativeType$1(text);
-  }
-  if (options.sanitize) {
-    text = text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
-  }
-  addField('text', text);
-}
+	  options = validateOptions(userOptions);
 
-function onComment(comment) {
-  if (options.ignoreComment) {
-    return;
-  }
-  if (options.trim) {
-    comment = comment.trim();
-  }
-  addField('comment', comment);
-}
+	  {
+	    parser.opt = {strictEntities: true};
+	    parser.onopentag = onStartElement;
+	    parser.ontext = onText;
+	    parser.oncomment = onComment;
+	    parser.onclosetag = onEndElement;
+	    parser.onerror = onError;
+	    parser.oncdata = onCdata;
+	    parser.ondoctype = onDoctype;
+	    parser.onprocessinginstruction = onInstruction;
+	  }
 
-function onEndElement(name) {
-  var parentElement = currentElement$1[options.parentKey];
-  if (!options.addParent) {
-    delete currentElement$1[options.parentKey];
-  }
-  currentElement$1 = parentElement;
-}
+	  {
+	    parser.write(xml).close();
+	  }
 
-function onCdata(cdata) {
-  if (options.ignoreCdata) {
-    return;
-  }
-  if (options.trim) {
-    cdata = cdata.trim();
-  }
-  addField('cdata', cdata);
-}
+	  if (result[options.elementsKey]) {
+	    var temp = result[options.elementsKey];
+	    delete result[options.elementsKey];
+	    result[options.elementsKey] = temp;
+	    delete result.text;
+	  }
 
-function onDoctype(doctype) {
-  if (options.ignoreDoctype) {
-    return;
-  }
-  doctype = doctype.replace(/^ /, '');
-  if (options.trim) {
-    doctype = doctype.trim();
-  }
-  addField('doctype', doctype);
-}
+	  return result;
 
-function onError(error) {
-  error.note = error; //console.error(error);
+	};
+	return xml2js;
 }
 
-var xml2js$2 = function (xml, userOptions) {
+var xml2json;
+var hasRequiredXml2json;
 
-  var parser = sax.parser(true, {}) ;
-  var result = {};
-  currentElement$1 = result;
+function requireXml2json () {
+	if (hasRequiredXml2json) return xml2json;
+	hasRequiredXml2json = 1;
+	var helper = requireOptionsHelper();
+	var xml2js = requireXml2js();
 
-  options = validateOptions$2(userOptions);
+	function validateOptions (userOptions) {
+	  var options = helper.copyOptions(userOptions);
+	  helper.ensureSpacesExists(options);
+	  return options;
+	}
 
-  {
-    parser.opt = {strictEntities: true};
-    parser.onopentag = onStartElement;
-    parser.ontext = onText;
-    parser.oncomment = onComment;
-    parser.onclosetag = onEndElement;
-    parser.onerror = onError;
-    parser.oncdata = onCdata;
-    parser.ondoctype = onDoctype;
-    parser.onprocessinginstruction = onInstruction;
-  }
+	xml2json = function(xml, userOptions) {
+	  var options, js, json, parentKey;
+	  options = validateOptions(userOptions);
+	  js = xml2js(xml, options);
+	  parentKey = 'compact' in options && options.compact ? '_parent' : 'parent';
+	  // parentKey = ptions.compact ? '_parent' : 'parent'; // consider this
+	  if ('addParent' in options && options.addParent) {
+	    json = JSON.stringify(js, function (k, v) { return k === parentKey? '_' : v; }, options.spaces);
+	  } else {
+	    json = JSON.stringify(js, null, options.spaces);
+	  }
+	  return json.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
+	};
+	return xml2json;
+}
+
+var js2xml;
+var hasRequiredJs2xml;
+
+function requireJs2xml () {
+	if (hasRequiredJs2xml) return js2xml;
+	hasRequiredJs2xml = 1;
+	var helper = requireOptionsHelper();
+	var isArray = requireArrayHelper().isArray;
+
+	var currentElement, currentElementName;
+
+	function validateOptions(userOptions) {
+	  var options = helper.copyOptions(userOptions);
+	  helper.ensureFlagExists('ignoreDeclaration', options);
+	  helper.ensureFlagExists('ignoreInstruction', options);
+	  helper.ensureFlagExists('ignoreAttributes', options);
+	  helper.ensureFlagExists('ignoreText', options);
+	  helper.ensureFlagExists('ignoreComment', options);
+	  helper.ensureFlagExists('ignoreCdata', options);
+	  helper.ensureFlagExists('ignoreDoctype', options);
+	  helper.ensureFlagExists('compact', options);
+	  helper.ensureFlagExists('indentText', options);
+	  helper.ensureFlagExists('indentCdata', options);
+	  helper.ensureFlagExists('indentAttributes', options);
+	  helper.ensureFlagExists('indentInstruction', options);
+	  helper.ensureFlagExists('fullTagEmptyElement', options);
+	  helper.ensureFlagExists('noQuotesForNativeAttributes', options);
+	  helper.ensureSpacesExists(options);
+	  if (typeof options.spaces === 'number') {
+	    options.spaces = Array(options.spaces + 1).join(' ');
+	  }
+	  helper.ensureKeyExists('declaration', options);
+	  helper.ensureKeyExists('instruction', options);
+	  helper.ensureKeyExists('attributes', options);
+	  helper.ensureKeyExists('text', options);
+	  helper.ensureKeyExists('comment', options);
+	  helper.ensureKeyExists('cdata', options);
+	  helper.ensureKeyExists('doctype', options);
+	  helper.ensureKeyExists('type', options);
+	  helper.ensureKeyExists('name', options);
+	  helper.ensureKeyExists('elements', options);
+	  helper.checkFnExists('doctype', options);
+	  helper.checkFnExists('instruction', options);
+	  helper.checkFnExists('cdata', options);
+	  helper.checkFnExists('comment', options);
+	  helper.checkFnExists('text', options);
+	  helper.checkFnExists('instructionName', options);
+	  helper.checkFnExists('elementName', options);
+	  helper.checkFnExists('attributeName', options);
+	  helper.checkFnExists('attributeValue', options);
+	  helper.checkFnExists('attributes', options);
+	  helper.checkFnExists('fullTagEmptyElement', options);
+	  return options;
+	}
 
-  {
-    parser.write(xml).close();
-  }
+	function writeIndentation(options, depth, firstLine) {
+	  return (!firstLine && options.spaces ? '\n' : '') + Array(depth + 1).join(options.spaces);
+	}
 
-  if (result[options.elementsKey]) {
-    var temp = result[options.elementsKey];
-    delete result[options.elementsKey];
-    result[options.elementsKey] = temp;
-    delete result.text;
-  }
+	function writeAttributes(attributes, options, depth) {
+	  if (options.ignoreAttributes) {
+	    return '';
+	  }
+	  if ('attributesFn' in options) {
+	    attributes = options.attributesFn(attributes, currentElementName, currentElement);
+	  }
+	  var key, attr, attrName, quote, result = [];
+	  for (key in attributes) {
+	    if (attributes.hasOwnProperty(key) && attributes[key] !== null && attributes[key] !== undefined) {
+	      quote = options.noQuotesForNativeAttributes && typeof attributes[key] !== 'string' ? '' : '"';
+	      attr = '' + attributes[key]; // ensure number and boolean are converted to String
+	      attr = attr.replace(/"/g, '&quot;');
+	      attrName = 'attributeNameFn' in options ? options.attributeNameFn(key, attr, currentElementName, currentElement) : key;
+	      result.push((options.spaces && options.indentAttributes? writeIndentation(options, depth+1, false) : ' '));
+	      result.push(attrName + '=' + quote + ('attributeValueFn' in options ? options.attributeValueFn(attr, key, currentElementName, currentElement) : attr) + quote);
+	    }
+	  }
+	  if (attributes && Object.keys(attributes).length && options.spaces && options.indentAttributes) {
+	    result.push(writeIndentation(options, depth, false));
+	  }
+	  return result.join('');
+	}
 
-  return result;
+	function writeDeclaration(declaration, options, depth) {
+	  currentElement = declaration;
+	  currentElementName = 'xml';
+	  return options.ignoreDeclaration ? '' :  '<?' + 'xml' + writeAttributes(declaration[options.attributesKey], options, depth) + '?>';
+	}
 
-};
+	function writeInstruction(instruction, options, depth) {
+	  if (options.ignoreInstruction) {
+	    return '';
+	  }
+	  var key;
+	  for (key in instruction) {
+	    if (instruction.hasOwnProperty(key)) {
+	      break;
+	    }
+	  }
+	  var instructionName = 'instructionNameFn' in options ? options.instructionNameFn(key, instruction[key], currentElementName, currentElement) : key;
+	  if (typeof instruction[key] === 'object') {
+	    currentElement = instruction;
+	    currentElementName = instructionName;
+	    return '<?' + instructionName + writeAttributes(instruction[key][options.attributesKey], options, depth) + '?>';
+	  } else {
+	    var instructionValue = instruction[key] ? instruction[key] : '';
+	    if ('instructionFn' in options) instructionValue = options.instructionFn(instructionValue, key, currentElementName, currentElement);
+	    return '<?' + instructionName + (instructionValue ? ' ' + instructionValue : '') + '?>';
+	  }
+	}
 
-var helper$1 = optionsHelper;
-var xml2js$1 = xml2js$2;
+	function writeComment(comment, options) {
+	  return options.ignoreComment ? '' : '<!--' + ('commentFn' in options ? options.commentFn(comment, currentElementName, currentElement) : comment) + '-->';
+	}
 
-function validateOptions$1 (userOptions) {
-  var options = helper$1.copyOptions(userOptions);
-  helper$1.ensureSpacesExists(options);
-  return options;
-}
+	function writeCdata(cdata, options) {
+	  return options.ignoreCdata ? '' : '<![CDATA[' + ('cdataFn' in options ? options.cdataFn(cdata, currentElementName, currentElement) : cdata.replace(']]>', ']]]]><![CDATA[>')) + ']]>';
+	}
 
-var xml2json$1 = function(xml, userOptions) {
-  var options, js, json, parentKey;
-  options = validateOptions$1(userOptions);
-  js = xml2js$1(xml, options);
-  parentKey = 'compact' in options && options.compact ? '_parent' : 'parent';
-  // parentKey = ptions.compact ? '_parent' : 'parent'; // consider this
-  if ('addParent' in options && options.addParent) {
-    json = JSON.stringify(js, function (k, v) { return k === parentKey? '_' : v; }, options.spaces);
-  } else {
-    json = JSON.stringify(js, null, options.spaces);
-  }
-  return json.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
-};
-
-var helper = optionsHelper;
-var isArray = arrayHelper.isArray;
-
-var currentElement, currentElementName;
-
-function validateOptions(userOptions) {
-  var options = helper.copyOptions(userOptions);
-  helper.ensureFlagExists('ignoreDeclaration', options);
-  helper.ensureFlagExists('ignoreInstruction', options);
-  helper.ensureFlagExists('ignoreAttributes', options);
-  helper.ensureFlagExists('ignoreText', options);
-  helper.ensureFlagExists('ignoreComment', options);
-  helper.ensureFlagExists('ignoreCdata', options);
-  helper.ensureFlagExists('ignoreDoctype', options);
-  helper.ensureFlagExists('compact', options);
-  helper.ensureFlagExists('indentText', options);
-  helper.ensureFlagExists('indentCdata', options);
-  helper.ensureFlagExists('indentAttributes', options);
-  helper.ensureFlagExists('indentInstruction', options);
-  helper.ensureFlagExists('fullTagEmptyElement', options);
-  helper.ensureFlagExists('noQuotesForNativeAttributes', options);
-  helper.ensureSpacesExists(options);
-  if (typeof options.spaces === 'number') {
-    options.spaces = Array(options.spaces + 1).join(' ');
-  }
-  helper.ensureKeyExists('declaration', options);
-  helper.ensureKeyExists('instruction', options);
-  helper.ensureKeyExists('attributes', options);
-  helper.ensureKeyExists('text', options);
-  helper.ensureKeyExists('comment', options);
-  helper.ensureKeyExists('cdata', options);
-  helper.ensureKeyExists('doctype', options);
-  helper.ensureKeyExists('type', options);
-  helper.ensureKeyExists('name', options);
-  helper.ensureKeyExists('elements', options);
-  helper.checkFnExists('doctype', options);
-  helper.checkFnExists('instruction', options);
-  helper.checkFnExists('cdata', options);
-  helper.checkFnExists('comment', options);
-  helper.checkFnExists('text', options);
-  helper.checkFnExists('instructionName', options);
-  helper.checkFnExists('elementName', options);
-  helper.checkFnExists('attributeName', options);
-  helper.checkFnExists('attributeValue', options);
-  helper.checkFnExists('attributes', options);
-  helper.checkFnExists('fullTagEmptyElement', options);
-  return options;
-}
-
-function writeIndentation(options, depth, firstLine) {
-  return (!firstLine && options.spaces ? '\n' : '') + Array(depth + 1).join(options.spaces);
-}
-
-function writeAttributes(attributes, options, depth) {
-  if (options.ignoreAttributes) {
-    return '';
-  }
-  if ('attributesFn' in options) {
-    attributes = options.attributesFn(attributes, currentElementName, currentElement);
-  }
-  var key, attr, attrName, quote, result = [];
-  for (key in attributes) {
-    if (attributes.hasOwnProperty(key) && attributes[key] !== null && attributes[key] !== undefined) {
-      quote = options.noQuotesForNativeAttributes && typeof attributes[key] !== 'string' ? '' : '"';
-      attr = '' + attributes[key]; // ensure number and boolean are converted to String
-      attr = attr.replace(/"/g, '&quot;');
-      attrName = 'attributeNameFn' in options ? options.attributeNameFn(key, attr, currentElementName, currentElement) : key;
-      result.push((options.spaces && options.indentAttributes? writeIndentation(options, depth+1, false) : ' '));
-      result.push(attrName + '=' + quote + ('attributeValueFn' in options ? options.attributeValueFn(attr, key, currentElementName, currentElement) : attr) + quote);
-    }
-  }
-  if (attributes && Object.keys(attributes).length && options.spaces && options.indentAttributes) {
-    result.push(writeIndentation(options, depth, false));
-  }
-  return result.join('');
-}
-
-function writeDeclaration(declaration, options, depth) {
-  currentElement = declaration;
-  currentElementName = 'xml';
-  return options.ignoreDeclaration ? '' :  '<?' + 'xml' + writeAttributes(declaration[options.attributesKey], options, depth) + '?>';
-}
-
-function writeInstruction(instruction, options, depth) {
-  if (options.ignoreInstruction) {
-    return '';
-  }
-  var key;
-  for (key in instruction) {
-    if (instruction.hasOwnProperty(key)) {
-      break;
-    }
-  }
-  var instructionName = 'instructionNameFn' in options ? options.instructionNameFn(key, instruction[key], currentElementName, currentElement) : key;
-  if (typeof instruction[key] === 'object') {
-    currentElement = instruction;
-    currentElementName = instructionName;
-    return '<?' + instructionName + writeAttributes(instruction[key][options.attributesKey], options, depth) + '?>';
-  } else {
-    var instructionValue = instruction[key] ? instruction[key] : '';
-    if ('instructionFn' in options) instructionValue = options.instructionFn(instructionValue, key, currentElementName, currentElement);
-    return '<?' + instructionName + (instructionValue ? ' ' + instructionValue : '') + '?>';
-  }
-}
+	function writeDoctype(doctype, options) {
+	  return options.ignoreDoctype ? '' : '<!DOCTYPE ' + ('doctypeFn' in options ? options.doctypeFn(doctype, currentElementName, currentElement) : doctype) + '>';
+	}
 
-function writeComment(comment, options) {
-  return options.ignoreComment ? '' : '<!--' + ('commentFn' in options ? options.commentFn(comment, currentElementName, currentElement) : comment) + '-->';
-}
+	function writeText(text, options) {
+	  if (options.ignoreText) return '';
+	  text = '' + text; // ensure Number and Boolean are converted to String
+	  text = text.replace(/&amp;/g, '&'); // desanitize to avoid double sanitization
+	  text = text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+	  return 'textFn' in options ? options.textFn(text, currentElementName, currentElement) : text;
+	}
 
-function writeCdata(cdata, options) {
-  return options.ignoreCdata ? '' : '<![CDATA[' + ('cdataFn' in options ? options.cdataFn(cdata, currentElementName, currentElement) : cdata.replace(']]>', ']]]]><![CDATA[>')) + ']]>';
-}
+	function hasContent(element, options) {
+	  var i;
+	  if (element.elements && element.elements.length) {
+	    for (i = 0; i < element.elements.length; ++i) {
+	      switch (element.elements[i][options.typeKey]) {
+	      case 'text':
+	        if (options.indentText) {
+	          return true;
+	        }
+	        break; // skip to next key
+	      case 'cdata':
+	        if (options.indentCdata) {
+	          return true;
+	        }
+	        break; // skip to next key
+	      case 'instruction':
+	        if (options.indentInstruction) {
+	          return true;
+	        }
+	        break; // skip to next key
+	      case 'doctype':
+	      case 'comment':
+	      case 'element':
+	        return true;
+	      default:
+	        return true;
+	      }
+	    }
+	  }
+	  return false;
+	}
 
-function writeDoctype(doctype, options) {
-  return options.ignoreDoctype ? '' : '<!DOCTYPE ' + ('doctypeFn' in options ? options.doctypeFn(doctype, currentElementName, currentElement) : doctype) + '>';
-}
+	function writeElement(element, options, depth) {
+	  currentElement = element;
+	  currentElementName = element.name;
+	  var xml = [], elementName = 'elementNameFn' in options ? options.elementNameFn(element.name, element) : element.name;
+	  xml.push('<' + elementName);
+	  if (element[options.attributesKey]) {
+	    xml.push(writeAttributes(element[options.attributesKey], options, depth));
+	  }
+	  var withClosingTag = element[options.elementsKey] && element[options.elementsKey].length || element[options.attributesKey] && element[options.attributesKey]['xml:space'] === 'preserve';
+	  if (!withClosingTag) {
+	    if ('fullTagEmptyElementFn' in options) {
+	      withClosingTag = options.fullTagEmptyElementFn(element.name, element);
+	    } else {
+	      withClosingTag = options.fullTagEmptyElement;
+	    }
+	  }
+	  if (withClosingTag) {
+	    xml.push('>');
+	    if (element[options.elementsKey] && element[options.elementsKey].length) {
+	      xml.push(writeElements(element[options.elementsKey], options, depth + 1));
+	      currentElement = element;
+	      currentElementName = element.name;
+	    }
+	    xml.push(options.spaces && hasContent(element, options) ? '\n' + Array(depth + 1).join(options.spaces) : '');
+	    xml.push('</' + elementName + '>');
+	  } else {
+	    xml.push('/>');
+	  }
+	  return xml.join('');
+	}
 
-function writeText(text, options) {
-  if (options.ignoreText) return '';
-  text = '' + text; // ensure Number and Boolean are converted to String
-  text = text.replace(/&amp;/g, '&'); // desanitize to avoid double sanitization
-  text = text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
-  return 'textFn' in options ? options.textFn(text, currentElementName, currentElement) : text;
-}
+	function writeElements(elements, options, depth, firstLine) {
+	  return elements.reduce(function (xml, element) {
+	    var indent = writeIndentation(options, depth, firstLine && !xml);
+	    switch (element.type) {
+	    case 'element': return xml + indent + writeElement(element, options, depth);
+	    case 'comment': return xml + indent + writeComment(element[options.commentKey], options);
+	    case 'doctype': return xml + indent + writeDoctype(element[options.doctypeKey], options);
+	    case 'cdata': return xml + (options.indentCdata ? indent : '') + writeCdata(element[options.cdataKey], options);
+	    case 'text': return xml + (options.indentText ? indent : '') + writeText(element[options.textKey], options);
+	    case 'instruction':
+	      var instruction = {};
+	      instruction[element[options.nameKey]] = element[options.attributesKey] ? element : element[options.instructionKey];
+	      return xml + (options.indentInstruction ? indent : '') + writeInstruction(instruction, options, depth);
+	    }
+	  }, '');
+	}
 
-function hasContent(element, options) {
-  var i;
-  if (element.elements && element.elements.length) {
-    for (i = 0; i < element.elements.length; ++i) {
-      switch (element.elements[i][options.typeKey]) {
-      case 'text':
-        if (options.indentText) {
-          return true;
-        }
-        break; // skip to next key
-      case 'cdata':
-        if (options.indentCdata) {
-          return true;
-        }
-        break; // skip to next key
-      case 'instruction':
-        if (options.indentInstruction) {
-          return true;
-        }
-        break; // skip to next key
-      case 'doctype':
-      case 'comment':
-      case 'element':
-        return true;
-      default:
-        return true;
-      }
-    }
-  }
-  return false;
-}
+	function hasContentCompact(element, options, anyContent) {
+	  var key;
+	  for (key in element) {
+	    if (element.hasOwnProperty(key)) {
+	      switch (key) {
+	      case options.parentKey:
+	      case options.attributesKey:
+	        break; // skip to next key
+	      case options.textKey:
+	        if (options.indentText || anyContent) {
+	          return true;
+	        }
+	        break; // skip to next key
+	      case options.cdataKey:
+	        if (options.indentCdata || anyContent) {
+	          return true;
+	        }
+	        break; // skip to next key
+	      case options.instructionKey:
+	        if (options.indentInstruction || anyContent) {
+	          return true;
+	        }
+	        break; // skip to next key
+	      case options.doctypeKey:
+	      case options.commentKey:
+	        return true;
+	      default:
+	        return true;
+	      }
+	    }
+	  }
+	  return false;
+	}
 
-function writeElement(element, options, depth) {
-  currentElement = element;
-  currentElementName = element.name;
-  var xml = [], elementName = 'elementNameFn' in options ? options.elementNameFn(element.name, element) : element.name;
-  xml.push('<' + elementName);
-  if (element[options.attributesKey]) {
-    xml.push(writeAttributes(element[options.attributesKey], options, depth));
-  }
-  var withClosingTag = element[options.elementsKey] && element[options.elementsKey].length || element[options.attributesKey] && element[options.attributesKey]['xml:space'] === 'preserve';
-  if (!withClosingTag) {
-    if ('fullTagEmptyElementFn' in options) {
-      withClosingTag = options.fullTagEmptyElementFn(element.name, element);
-    } else {
-      withClosingTag = options.fullTagEmptyElement;
-    }
-  }
-  if (withClosingTag) {
-    xml.push('>');
-    if (element[options.elementsKey] && element[options.elementsKey].length) {
-      xml.push(writeElements(element[options.elementsKey], options, depth + 1));
-      currentElement = element;
-      currentElementName = element.name;
-    }
-    xml.push(options.spaces && hasContent(element, options) ? '\n' + Array(depth + 1).join(options.spaces) : '');
-    xml.push('</' + elementName + '>');
-  } else {
-    xml.push('/>');
-  }
-  return xml.join('');
-}
-
-function writeElements(elements, options, depth, firstLine) {
-  return elements.reduce(function (xml, element) {
-    var indent = writeIndentation(options, depth, firstLine && !xml);
-    switch (element.type) {
-    case 'element': return xml + indent + writeElement(element, options, depth);
-    case 'comment': return xml + indent + writeComment(element[options.commentKey], options);
-    case 'doctype': return xml + indent + writeDoctype(element[options.doctypeKey], options);
-    case 'cdata': return xml + (options.indentCdata ? indent : '') + writeCdata(element[options.cdataKey], options);
-    case 'text': return xml + (options.indentText ? indent : '') + writeText(element[options.textKey], options);
-    case 'instruction':
-      var instruction = {};
-      instruction[element[options.nameKey]] = element[options.attributesKey] ? element : element[options.instructionKey];
-      return xml + (options.indentInstruction ? indent : '') + writeInstruction(instruction, options, depth);
-    }
-  }, '');
-}
-
-function hasContentCompact(element, options, anyContent) {
-  var key;
-  for (key in element) {
-    if (element.hasOwnProperty(key)) {
-      switch (key) {
-      case options.parentKey:
-      case options.attributesKey:
-        break; // skip to next key
-      case options.textKey:
-        if (options.indentText || anyContent) {
-          return true;
-        }
-        break; // skip to next key
-      case options.cdataKey:
-        if (options.indentCdata || anyContent) {
-          return true;
-        }
-        break; // skip to next key
-      case options.instructionKey:
-        if (options.indentInstruction || anyContent) {
-          return true;
-        }
-        break; // skip to next key
-      case options.doctypeKey:
-      case options.commentKey:
-        return true;
-      default:
-        return true;
-      }
-    }
-  }
-  return false;
-}
+	function writeElementCompact(element, name, options, depth, indent) {
+	  currentElement = element;
+	  currentElementName = name;
+	  var elementName = 'elementNameFn' in options ? options.elementNameFn(name, element) : name;
+	  if (typeof element === 'undefined' || element === null || element === '') {
+	    return 'fullTagEmptyElementFn' in options && options.fullTagEmptyElementFn(name, element) || options.fullTagEmptyElement ? '<' + elementName + '></' + elementName + '>' : '<' + elementName + '/>';
+	  }
+	  var xml = [];
+	  if (name) {
+	    xml.push('<' + elementName);
+	    if (typeof element !== 'object') {
+	      xml.push('>' + writeText(element,options) + '</' + elementName + '>');
+	      return xml.join('');
+	    }
+	    if (element[options.attributesKey]) {
+	      xml.push(writeAttributes(element[options.attributesKey], options, depth));
+	    }
+	    var withClosingTag = hasContentCompact(element, options, true) || element[options.attributesKey] && element[options.attributesKey]['xml:space'] === 'preserve';
+	    if (!withClosingTag) {
+	      if ('fullTagEmptyElementFn' in options) {
+	        withClosingTag = options.fullTagEmptyElementFn(name, element);
+	      } else {
+	        withClosingTag = options.fullTagEmptyElement;
+	      }
+	    }
+	    if (withClosingTag) {
+	      xml.push('>');
+	    } else {
+	      xml.push('/>');
+	      return xml.join('');
+	    }
+	  }
+	  xml.push(writeElementsCompact(element, options, depth + 1, false));
+	  currentElement = element;
+	  currentElementName = name;
+	  if (name) {
+	    xml.push((indent ? writeIndentation(options, depth, false) : '') + '</' + elementName + '>');
+	  }
+	  return xml.join('');
+	}
 
-function writeElementCompact(element, name, options, depth, indent) {
-  currentElement = element;
-  currentElementName = name;
-  var elementName = 'elementNameFn' in options ? options.elementNameFn(name, element) : name;
-  if (typeof element === 'undefined' || element === null || element === '') {
-    return 'fullTagEmptyElementFn' in options && options.fullTagEmptyElementFn(name, element) || options.fullTagEmptyElement ? '<' + elementName + '></' + elementName + '>' : '<' + elementName + '/>';
-  }
-  var xml = [];
-  if (name) {
-    xml.push('<' + elementName);
-    if (typeof element !== 'object') {
-      xml.push('>' + writeText(element,options) + '</' + elementName + '>');
-      return xml.join('');
-    }
-    if (element[options.attributesKey]) {
-      xml.push(writeAttributes(element[options.attributesKey], options, depth));
-    }
-    var withClosingTag = hasContentCompact(element, options, true) || element[options.attributesKey] && element[options.attributesKey]['xml:space'] === 'preserve';
-    if (!withClosingTag) {
-      if ('fullTagEmptyElementFn' in options) {
-        withClosingTag = options.fullTagEmptyElementFn(name, element);
-      } else {
-        withClosingTag = options.fullTagEmptyElement;
-      }
-    }
-    if (withClosingTag) {
-      xml.push('>');
-    } else {
-      xml.push('/>');
-      return xml.join('');
-    }
-  }
-  xml.push(writeElementsCompact(element, options, depth + 1, false));
-  currentElement = element;
-  currentElementName = name;
-  if (name) {
-    xml.push((indent ? writeIndentation(options, depth, false) : '') + '</' + elementName + '>');
-  }
-  return xml.join('');
-}
-
-function writeElementsCompact(element, options, depth, firstLine) {
-  var i, key, nodes, xml = [];
-  for (key in element) {
-    if (element.hasOwnProperty(key)) {
-      nodes = isArray(element[key]) ? element[key] : [element[key]];
-      for (i = 0; i < nodes.length; ++i) {
-        switch (key) {
-        case options.declarationKey: xml.push(writeDeclaration(nodes[i], options, depth)); break;
-        case options.instructionKey: xml.push((options.indentInstruction ? writeIndentation(options, depth, firstLine) : '') + writeInstruction(nodes[i], options, depth)); break;
-        case options.attributesKey: case options.parentKey: break; // skip
-        case options.textKey: xml.push((options.indentText ? writeIndentation(options, depth, firstLine) : '') + writeText(nodes[i], options)); break;
-        case options.cdataKey: xml.push((options.indentCdata ? writeIndentation(options, depth, firstLine) : '') + writeCdata(nodes[i], options)); break;
-        case options.doctypeKey: xml.push(writeIndentation(options, depth, firstLine) + writeDoctype(nodes[i], options)); break;
-        case options.commentKey: xml.push(writeIndentation(options, depth, firstLine) + writeComment(nodes[i], options)); break;
-        default: xml.push(writeIndentation(options, depth, firstLine) + writeElementCompact(nodes[i], key, options, depth, hasContentCompact(nodes[i], options)));
-        }
-        firstLine = firstLine && !xml.length;
-      }
-    }
-  }
-  return xml.join('');
+	function writeElementsCompact(element, options, depth, firstLine) {
+	  var i, key, nodes, xml = [];
+	  for (key in element) {
+	    if (element.hasOwnProperty(key)) {
+	      nodes = isArray(element[key]) ? element[key] : [element[key]];
+	      for (i = 0; i < nodes.length; ++i) {
+	        switch (key) {
+	        case options.declarationKey: xml.push(writeDeclaration(nodes[i], options, depth)); break;
+	        case options.instructionKey: xml.push((options.indentInstruction ? writeIndentation(options, depth, firstLine) : '') + writeInstruction(nodes[i], options, depth)); break;
+	        case options.attributesKey: case options.parentKey: break; // skip
+	        case options.textKey: xml.push((options.indentText ? writeIndentation(options, depth, firstLine) : '') + writeText(nodes[i], options)); break;
+	        case options.cdataKey: xml.push((options.indentCdata ? writeIndentation(options, depth, firstLine) : '') + writeCdata(nodes[i], options)); break;
+	        case options.doctypeKey: xml.push(writeIndentation(options, depth, firstLine) + writeDoctype(nodes[i], options)); break;
+	        case options.commentKey: xml.push(writeIndentation(options, depth, firstLine) + writeComment(nodes[i], options)); break;
+	        default: xml.push(writeIndentation(options, depth, firstLine) + writeElementCompact(nodes[i], key, options, depth, hasContentCompact(nodes[i], options)));
+	        }
+	        firstLine = firstLine && !xml.length;
+	      }
+	    }
+	  }
+	  return xml.join('');
+	}
+
+	js2xml = function (js, options) {
+	  options = validateOptions(options);
+	  var xml = [];
+	  currentElement = js;
+	  currentElementName = '_root_';
+	  if (options.compact) {
+	    xml.push(writeElementsCompact(js, options, 0, true));
+	  } else {
+	    if (js[options.declarationKey]) {
+	      xml.push(writeDeclaration(js[options.declarationKey], options, 0));
+	    }
+	    if (js[options.elementsKey] && js[options.elementsKey].length) {
+	      xml.push(writeElements(js[options.elementsKey], options, 0, !xml.length));
+	    }
+	  }
+	  return xml.join('');
+	};
+	return js2xml;
 }
 
-var js2xml$2 = function (js, options) {
-  options = validateOptions(options);
-  var xml = [];
-  currentElement = js;
-  currentElementName = '_root_';
-  if (options.compact) {
-    xml.push(writeElementsCompact(js, options, 0, true));
-  } else {
-    if (js[options.declarationKey]) {
-      xml.push(writeDeclaration(js[options.declarationKey], options, 0));
-    }
-    if (js[options.elementsKey] && js[options.elementsKey].length) {
-      xml.push(writeElements(js[options.elementsKey], options, 0, !xml.length));
-    }
-  }
-  return xml.join('');
-};
+var json2xml;
+var hasRequiredJson2xml;
 
-var js2xml$1 = js2xml$2;
+function requireJson2xml () {
+	if (hasRequiredJson2xml) return json2xml;
+	hasRequiredJson2xml = 1;
+	var js2xml = requireJs2xml();
 
-var json2xml$1 = function (json, options) {
-  if (json instanceof Buffer) {
-    json = json.toString();
-  }
-  var js = null;
-  if (typeof (json) === 'string') {
-    try {
-      js = JSON.parse(json);
-    } catch (e) {
-      throw new Error('The JSON structure is invalid');
-    }
-  } else {
-    js = json;
-  }
-  return js2xml$1(js, options);
-};
+	json2xml = function (json, options) {
+	  if (json instanceof Buffer) {
+	    json = json.toString();
+	  }
+	  var js = null;
+	  if (typeof (json) === 'string') {
+	    try {
+	      js = JSON.parse(json);
+	    } catch (e) {
+	      throw new Error('The JSON structure is invalid');
+	    }
+	  } else {
+	    js = json;
+	  }
+	  return js2xml(js, options);
+	};
+	return json2xml;
+}
 
 /*jslint node:true */
 
-var xml2js = xml2js$2;
-var xml2json = xml2json$1;
-var js2xml = js2xml$2;
-var json2xml = json2xml$1;
-
-var lib = {
-  xml2js: xml2js,
-  xml2json: xml2json,
-  js2xml: js2xml,
-  json2xml: json2xml
-};
+var lib;
+var hasRequiredLib;
+
+function requireLib () {
+	if (hasRequiredLib) return lib;
+	hasRequiredLib = 1;
+	var xml2js = requireXml2js();
+	var xml2json = requireXml2json();
+	var js2xml = requireJs2xml();
+	var json2xml = requireJson2xml();
+
+	lib = {
+	  xml2js: xml2js,
+	  xml2json: xml2json,
+	  js2xml: js2xml,
+	  json2xml: json2xml
+	};
+	return lib;
+}
 
-var convert = /*@__PURE__*/getDefaultExportFromCjs(lib);
+var libExports = requireLib();
+var convert = /*@__PURE__*/getDefaultExportFromCjs(libExports);
 
 const camelCase = (str) => str.replace(/([-_]\w)/g, (g) => g[1].toUpperCase());
 
@@ -10271,170 +10380,177 @@ var account = /*#__PURE__*/Object.freeze({
 	serviceDiscovery: serviceDiscovery
 });
 
-var base64 = {exports: {}};
+var base64$1 = {exports: {}};
 
 /*! https://mths.be/base64 v1.0.0 by @mathias | MIT license */
-base64.exports;
-
-(function (module, exports) {
-(function(root) {
-
-		// Detect free variables `exports`.
-		var freeExports = exports;
+var base64 = base64$1.exports;
 
-		// Detect free variable `module`.
-		var freeModule = module &&
-			module.exports == freeExports && module;
+var hasRequiredBase64;
 
-		// Detect free variable `global`, from Node.js or Browserified code, and use
-		// it as `root`.
-		var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal;
-		if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
-			root = freeGlobal;
-		}
-
-		/*--------------------------------------------------------------------------*/
+function requireBase64 () {
+	if (hasRequiredBase64) return base64$1.exports;
+	hasRequiredBase64 = 1;
+	(function (module, exports) {
+(function(root) {
 
-		var InvalidCharacterError = function(message) {
-			this.message = message;
-		};
-		InvalidCharacterError.prototype = new Error;
-		InvalidCharacterError.prototype.name = 'InvalidCharacterError';
+			// Detect free variables `exports`.
+			var freeExports = exports;
 
-		var error = function(message) {
-			// Note: the error messages used throughout this file match those used by
-			// the native `atob`/`btoa` implementation in Chromium.
-			throw new InvalidCharacterError(message);
-		};
+			// Detect free variable `module`.
+			var freeModule = module &&
+				module.exports == freeExports && module;
 
-		var TABLE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-		// http://whatwg.org/html/common-microsyntaxes.html#space-character
-		var REGEX_SPACE_CHARACTERS = /[\t\n\f\r ]/g;
-
-		// `decode` is designed to be fully compatible with `atob` as described in the
-		// HTML Standard. http://whatwg.org/html/webappapis.html#dom-windowbase64-atob
-		// The optimized base64-decoding algorithm used is based on @atk’s excellent
-		// implementation. https://gist.github.com/atk/1020396
-		var decode = function(input) {
-			input = String(input)
-				.replace(REGEX_SPACE_CHARACTERS, '');
-			var length = input.length;
-			if (length % 4 == 0) {
-				input = input.replace(/==?$/, '');
-				length = input.length;
-			}
-			if (
-				length % 4 == 1 ||
-				// http://whatwg.org/C#alphanumeric-ascii-characters
-				/[^+a-zA-Z0-9/]/.test(input)
-			) {
-				error(
-					'Invalid character: the string to be decoded is not correctly encoded.'
-				);
+			// Detect free variable `global`, from Node.js or Browserified code, and use
+			// it as `root`.
+			var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal;
+			if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
+				root = freeGlobal;
 			}
-			var bitCounter = 0;
-			var bitStorage;
-			var buffer;
-			var output = '';
-			var position = -1;
-			while (++position < length) {
-				buffer = TABLE.indexOf(input.charAt(position));
-				bitStorage = bitCounter % 4 ? bitStorage * 64 + buffer : buffer;
-				// Unless this is the first of a group of 4 characters…
-				if (bitCounter++ % 4) {
-					// …convert the first 8 bits to a single ASCII character.
-					output += String.fromCharCode(
-						0xFF & bitStorage >> (-2 * bitCounter & 6)
+
+			/*--------------------------------------------------------------------------*/
+
+			var InvalidCharacterError = function(message) {
+				this.message = message;
+			};
+			InvalidCharacterError.prototype = new Error;
+			InvalidCharacterError.prototype.name = 'InvalidCharacterError';
+
+			var error = function(message) {
+				// Note: the error messages used throughout this file match those used by
+				// the native `atob`/`btoa` implementation in Chromium.
+				throw new InvalidCharacterError(message);
+			};
+
+			var TABLE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+			// http://whatwg.org/html/common-microsyntaxes.html#space-character
+			var REGEX_SPACE_CHARACTERS = /[\t\n\f\r ]/g;
+
+			// `decode` is designed to be fully compatible with `atob` as described in the
+			// HTML Standard. http://whatwg.org/html/webappapis.html#dom-windowbase64-atob
+			// The optimized base64-decoding algorithm used is based on @atk’s excellent
+			// implementation. https://gist.github.com/atk/1020396
+			var decode = function(input) {
+				input = String(input)
+					.replace(REGEX_SPACE_CHARACTERS, '');
+				var length = input.length;
+				if (length % 4 == 0) {
+					input = input.replace(/==?$/, '');
+					length = input.length;
+				}
+				if (
+					length % 4 == 1 ||
+					// http://whatwg.org/C#alphanumeric-ascii-characters
+					/[^+a-zA-Z0-9/]/.test(input)
+				) {
+					error(
+						'Invalid character: the string to be decoded is not correctly encoded.'
+					);
+				}
+				var bitCounter = 0;
+				var bitStorage;
+				var buffer;
+				var output = '';
+				var position = -1;
+				while (++position < length) {
+					buffer = TABLE.indexOf(input.charAt(position));
+					bitStorage = bitCounter % 4 ? bitStorage * 64 + buffer : buffer;
+					// Unless this is the first of a group of 4 characters…
+					if (bitCounter++ % 4) {
+						// …convert the first 8 bits to a single ASCII character.
+						output += String.fromCharCode(
+							0xFF & bitStorage >> (-2 * bitCounter & 6)
+						);
+					}
+				}
+				return output;
+			};
+
+			// `encode` is designed to be fully compatible with `btoa` as described in the
+			// HTML Standard: http://whatwg.org/html/webappapis.html#dom-windowbase64-btoa
+			var encode = function(input) {
+				input = String(input);
+				if (/[^\0-\xFF]/.test(input)) {
+					// Note: no need to special-case astral symbols here, as surrogates are
+					// matched, and the input is supposed to only contain ASCII anyway.
+					error(
+						'The string to be encoded contains characters outside of the ' +
+						'Latin1 range.'
+					);
+				}
+				var padding = input.length % 3;
+				var output = '';
+				var position = -1;
+				var a;
+				var b;
+				var c;
+				var buffer;
+				// Make sure any padding is handled outside of the loop.
+				var length = input.length - padding;
+
+				while (++position < length) {
+					// Read three bytes, i.e. 24 bits.
+					a = input.charCodeAt(position) << 16;
+					b = input.charCodeAt(++position) << 8;
+					c = input.charCodeAt(++position);
+					buffer = a + b + c;
+					// Turn the 24 bits into four chunks of 6 bits each, and append the
+					// matching character for each of them to the output.
+					output += (
+						TABLE.charAt(buffer >> 18 & 0x3F) +
+						TABLE.charAt(buffer >> 12 & 0x3F) +
+						TABLE.charAt(buffer >> 6 & 0x3F) +
+						TABLE.charAt(buffer & 0x3F)
 					);
 				}
-			}
-			return output;
-		};
-
-		// `encode` is designed to be fully compatible with `btoa` as described in the
-		// HTML Standard: http://whatwg.org/html/webappapis.html#dom-windowbase64-btoa
-		var encode = function(input) {
-			input = String(input);
-			if (/[^\0-\xFF]/.test(input)) {
-				// Note: no need to special-case astral symbols here, as surrogates are
-				// matched, and the input is supposed to only contain ASCII anyway.
-				error(
-					'The string to be encoded contains characters outside of the ' +
-					'Latin1 range.'
-				);
-			}
-			var padding = input.length % 3;
-			var output = '';
-			var position = -1;
-			var a;
-			var b;
-			var c;
-			var buffer;
-			// Make sure any padding is handled outside of the loop.
-			var length = input.length - padding;
-
-			while (++position < length) {
-				// Read three bytes, i.e. 24 bits.
-				a = input.charCodeAt(position) << 16;
-				b = input.charCodeAt(++position) << 8;
-				c = input.charCodeAt(++position);
-				buffer = a + b + c;
-				// Turn the 24 bits into four chunks of 6 bits each, and append the
-				// matching character for each of them to the output.
-				output += (
-					TABLE.charAt(buffer >> 18 & 0x3F) +
-					TABLE.charAt(buffer >> 12 & 0x3F) +
-					TABLE.charAt(buffer >> 6 & 0x3F) +
-					TABLE.charAt(buffer & 0x3F)
-				);
-			}
-
-			if (padding == 2) {
-				a = input.charCodeAt(position) << 8;
-				b = input.charCodeAt(++position);
-				buffer = a + b;
-				output += (
-					TABLE.charAt(buffer >> 10) +
-					TABLE.charAt((buffer >> 4) & 0x3F) +
-					TABLE.charAt((buffer << 2) & 0x3F) +
-					'='
-				);
-			} else if (padding == 1) {
-				buffer = input.charCodeAt(position);
-				output += (
-					TABLE.charAt(buffer >> 2) +
-					TABLE.charAt((buffer << 4) & 0x3F) +
-					'=='
-				);
-			}
-
-			return output;
-		};
 
-		var base64 = {
-			'encode': encode,
-			'decode': decode,
-			'version': '1.0.0'
-		};
+				if (padding == 2) {
+					a = input.charCodeAt(position) << 8;
+					b = input.charCodeAt(++position);
+					buffer = a + b;
+					output += (
+						TABLE.charAt(buffer >> 10) +
+						TABLE.charAt((buffer >> 4) & 0x3F) +
+						TABLE.charAt((buffer << 2) & 0x3F) +
+						'='
+					);
+				} else if (padding == 1) {
+					buffer = input.charCodeAt(position);
+					output += (
+						TABLE.charAt(buffer >> 2) +
+						TABLE.charAt((buffer << 4) & 0x3F) +
+						'=='
+					);
+				}
 
-		// Some AMD build optimizers, like r.js, check for specific condition patterns
-		// like the following:
-		if (freeExports && !freeExports.nodeType) {
-			if (freeModule) { // in Node.js or RingoJS v0.8.0+
-				freeModule.exports = base64;
-			} else { // in Narwhal or RingoJS v0.7.0-
-				for (var key in base64) {
-					base64.hasOwnProperty(key) && (freeExports[key] = base64[key]);
+				return output;
+			};
+
+			var base64 = {
+				'encode': encode,
+				'decode': decode,
+				'version': '1.0.0'
+			};
+
+			// Some AMD build optimizers, like r.js, check for specific condition patterns
+			// like the following:
+			if (freeExports && !freeExports.nodeType) {
+				if (freeModule) { // in Node.js or RingoJS v0.8.0+
+					freeModule.exports = base64;
+				} else { // in Narwhal or RingoJS v0.7.0-
+					for (var key in base64) {
+						base64.hasOwnProperty(key) && (freeExports[key] = base64[key]);
+					}
 				}
+			} else { // in Rhino or a web browser
+				root.base64 = base64;
 			}
-		} else { // in Rhino or a web browser
-			root.base64 = base64;
-		}
 
-	}(commonjsGlobal)); 
-} (base64, base64.exports));
+		}(base64)); 
+	} (base64$1, base64$1.exports));
+	return base64$1.exports;
+}
 
-var base64Exports = base64.exports;
+var base64Exports = requireBase64();
 
 const debug = getLogger('tsdav:authHelper');
 /**
diff --git a/dist/tsdav.min.js b/dist/tsdav.min.js
index 40cfa3a..6ed8460 100644
--- a/dist/tsdav.min.js
+++ b/dist/tsdav.min.js
@@ -1,2 +1,2 @@
-var e="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{};function t(e){return e&&e.__esModule&&Object.prototype.hasOwnProperty.call(e,"default")?e.default:e}function r(e){if(e.__esModule)return e;var t=e.default;if("function"==typeof t){var r=function e(){return this instanceof e?Reflect.construct(t,arguments,this.constructor):t.apply(this,arguments)};r.prototype=t.prototype}else r={};return Object.defineProperty(r,"__esModule",{value:!0}),Object.keys(e).forEach((function(t){var n=Object.getOwnPropertyDescriptor(e,t);Object.defineProperty(r,t,n.get?n:{enumerable:!0,get:function(){return e[t]}})})),r}!function(e){!function(t){var r="undefined"!=typeof globalThis&&globalThis||void 0!==e&&e||void 0!==r&&r,n="URLSearchParams"in r,i="Symbol"in r&&"iterator"in Symbol,a="FileReader"in r&&"Blob"in r&&function(){try{return new Blob,!0}catch(e){return!1}}(),o="FormData"in r,s="ArrayBuffer"in r;if(s)var c=["[object Int8Array]","[object Uint8Array]","[object Uint8ClampedArray]","[object Int16Array]","[object Uint16Array]","[object Int32Array]","[object Uint32Array]","[object Float32Array]","[object Float64Array]"],u=ArrayBuffer.isView||function(e){return e&&c.indexOf(Object.prototype.toString.call(e))>-1};function l(e){if("string"!=typeof e&&(e=String(e)),/[^a-z0-9\-#$%&'*+.^_`|~!]/i.test(e)||""===e)throw new TypeError('Invalid character in header field name: "'+e+'"');return e.toLowerCase()}function h(e){return"string"!=typeof e&&(e=String(e)),e}function d(e){var t={next:function(){var t=e.shift();return{done:void 0===t,value:t}}};return i&&(t[Symbol.iterator]=function(){return t}),t}function f(e){this.map={},e instanceof f?e.forEach((function(e,t){this.append(t,e)}),this):Array.isArray(e)?e.forEach((function(e){this.append(e[0],e[1])}),this):e&&Object.getOwnPropertyNames(e).forEach((function(t){this.append(t,e[t])}),this)}function p(e){if(e.bodyUsed)return Promise.reject(new TypeError("Already read"));e.bodyUsed=!0}function g(e){return new Promise((function(t,r){e.onload=function(){t(e.result)},e.onerror=function(){r(e.error)}}))}function y(e){var t=new FileReader,r=g(t);return t.readAsArrayBuffer(e),r}function m(e){if(e.slice)return e.slice(0);var t=new Uint8Array(e.byteLength);return t.set(new Uint8Array(e)),t.buffer}function v(){return this.bodyUsed=!1,this._initBody=function(e){var t;this.bodyUsed=this.bodyUsed,this._bodyInit=e,e?"string"==typeof e?this._bodyText=e:a&&Blob.prototype.isPrototypeOf(e)?this._bodyBlob=e:o&&FormData.prototype.isPrototypeOf(e)?this._bodyFormData=e:n&&URLSearchParams.prototype.isPrototypeOf(e)?this._bodyText=e.toString():s&&a&&((t=e)&&DataView.prototype.isPrototypeOf(t))?(this._bodyArrayBuffer=m(e.buffer),this._bodyInit=new Blob([this._bodyArrayBuffer])):s&&(ArrayBuffer.prototype.isPrototypeOf(e)||u(e))?this._bodyArrayBuffer=m(e):this._bodyText=e=Object.prototype.toString.call(e):this._bodyText="",this.headers.get("content-type")||("string"==typeof e?this.headers.set("content-type","text/plain;charset=UTF-8"):this._bodyBlob&&this._bodyBlob.type?this.headers.set("content-type",this._bodyBlob.type):n&&URLSearchParams.prototype.isPrototypeOf(e)&&this.headers.set("content-type","application/x-www-form-urlencoded;charset=UTF-8"))},a&&(this.blob=function(){var e=p(this);if(e)return e;if(this._bodyBlob)return Promise.resolve(this._bodyBlob);if(this._bodyArrayBuffer)return Promise.resolve(new Blob([this._bodyArrayBuffer]));if(this._bodyFormData)throw new Error("could not read FormData body as blob");return Promise.resolve(new Blob([this._bodyText]))},this.arrayBuffer=function(){if(this._bodyArrayBuffer){var e=p(this);return e||(ArrayBuffer.isView(this._bodyArrayBuffer)?Promise.resolve(this._bodyArrayBuffer.buffer.slice(this._bodyArrayBuffer.byteOffset,this._bodyArrayBuffer.byteOffset+this._bodyArrayBuffer.byteLength)):Promise.resolve(this._bodyArrayBuffer))}return this.blob().then(y)}),this.text=function(){var e,t,r,n=p(this);if(n)return n;if(this._bodyBlob)return e=this._bodyBlob,t=new FileReader,r=g(t),t.readAsText(e),r;if(this._bodyArrayBuffer)return Promise.resolve(function(e){for(var t=new Uint8Array(e),r=new Array(t.length),n=0;n<t.length;n++)r[n]=String.fromCharCode(t[n]);return r.join("")}(this._bodyArrayBuffer));if(this._bodyFormData)throw new Error("could not read FormData body as text");return Promise.resolve(this._bodyText)},o&&(this.formData=function(){return this.text().then(E)}),this.json=function(){return this.text().then(JSON.parse)},this}f.prototype.append=function(e,t){e=l(e),t=h(t);var r=this.map[e];this.map[e]=r?r+", "+t:t},f.prototype.delete=function(e){delete this.map[l(e)]},f.prototype.get=function(e){return e=l(e),this.has(e)?this.map[e]:null},f.prototype.has=function(e){return this.map.hasOwnProperty(l(e))},f.prototype.set=function(e,t){this.map[l(e)]=h(t)},f.prototype.forEach=function(e,t){for(var r in this.map)this.map.hasOwnProperty(r)&&e.call(t,this.map[r],r,this)},f.prototype.keys=function(){var e=[];return this.forEach((function(t,r){e.push(r)})),d(e)},f.prototype.values=function(){var e=[];return this.forEach((function(t){e.push(t)})),d(e)},f.prototype.entries=function(){var e=[];return this.forEach((function(t,r){e.push([r,t])})),d(e)},i&&(f.prototype[Symbol.iterator]=f.prototype.entries);var b=["DELETE","GET","HEAD","OPTIONS","POST","PUT"];function w(e,t){if(!(this instanceof w))throw new TypeError('Please use the "new" operator, this DOM object constructor cannot be called as a function.');var r=(t=t||{}).body;if(e instanceof w){if(e.bodyUsed)throw new TypeError("Already read");this.url=e.url,this.credentials=e.credentials,t.headers||(this.headers=new f(e.headers)),this.method=e.method,this.mode=e.mode,this.signal=e.signal,r||null==e._bodyInit||(r=e._bodyInit,e.bodyUsed=!0)}else this.url=String(e);if(this.credentials=t.credentials||this.credentials||"same-origin",!t.headers&&this.headers||(this.headers=new f(t.headers)),this.method=function(e){var t=e.toUpperCase();return b.indexOf(t)>-1?t:e}(t.method||this.method||"GET"),this.mode=t.mode||this.mode||null,this.signal=t.signal||this.signal,this.referrer=null,("GET"===this.method||"HEAD"===this.method)&&r)throw new TypeError("Body not allowed for GET or HEAD requests");if(this._initBody(r),!("GET"!==this.method&&"HEAD"!==this.method||"no-store"!==t.cache&&"no-cache"!==t.cache)){var n=/([?&])_=[^&]*/;if(n.test(this.url))this.url=this.url.replace(n,"$1_="+(new Date).getTime());else{this.url+=(/\?/.test(this.url)?"&":"?")+"_="+(new Date).getTime()}}}function E(e){var t=new FormData;return e.trim().split("&").forEach((function(e){if(e){var r=e.split("="),n=r.shift().replace(/\+/g," "),i=r.join("=").replace(/\+/g," ");t.append(decodeURIComponent(n),decodeURIComponent(i))}})),t}function A(e,t){if(!(this instanceof A))throw new TypeError('Please use the "new" operator, this DOM object constructor cannot be called as a function.');t||(t={}),this.type="default",this.status=void 0===t.status?200:t.status,this.ok=this.status>=200&&this.status<300,this.statusText=void 0===t.statusText?"":""+t.statusText,this.headers=new f(t.headers),this.url=t.url||"",this._initBody(e)}w.prototype.clone=function(){return new w(this,{body:this._bodyInit})},v.call(w.prototype),v.call(A.prototype),A.prototype.clone=function(){return new A(this._bodyInit,{status:this.status,statusText:this.statusText,headers:new f(this.headers),url:this.url})},A.error=function(){var e=new A(null,{status:0,statusText:""});return e.type="error",e};var T=[301,302,303,307,308];A.redirect=function(e,t){if(-1===T.indexOf(t))throw new RangeError("Invalid status code");return new A(null,{status:t,headers:{location:e}})},t.DOMException=r.DOMException;try{new t.DOMException}catch(e){t.DOMException=function(e,t){this.message=e,this.name=t;var r=Error(e);this.stack=r.stack},t.DOMException.prototype=Object.create(Error.prototype),t.DOMException.prototype.constructor=t.DOMException}function _(e,n){return new Promise((function(i,o){var c=new w(e,n);if(c.signal&&c.signal.aborted)return o(new t.DOMException("Aborted","AbortError"));var u=new XMLHttpRequest;function l(){u.abort()}u.onload=function(){var e,t,r={status:u.status,statusText:u.statusText,headers:(e=u.getAllResponseHeaders()||"",t=new f,e.replace(/\r?\n[\t ]+/g," ").split("\r").map((function(e){return 0===e.indexOf("\n")?e.substr(1,e.length):e})).forEach((function(e){var r=e.split(":"),n=r.shift().trim();if(n){var i=r.join(":").trim();t.append(n,i)}})),t)};r.url="responseURL"in u?u.responseURL:r.headers.get("X-Request-URL");var n="response"in u?u.response:u.responseText;setTimeout((function(){i(new A(n,r))}),0)},u.onerror=function(){setTimeout((function(){o(new TypeError("Network request failed"))}),0)},u.ontimeout=function(){setTimeout((function(){o(new TypeError("Network request failed"))}),0)},u.onabort=function(){setTimeout((function(){o(new t.DOMException("Aborted","AbortError"))}),0)},u.open(c.method,function(e){try{return""===e&&r.location.href?r.location.href:e}catch(t){return e}}(c.url),!0),"include"===c.credentials?u.withCredentials=!0:"omit"===c.credentials&&(u.withCredentials=!1),"responseType"in u&&(a?u.responseType="blob":s&&c.headers.get("Content-Type")&&-1!==c.headers.get("Content-Type").indexOf("application/octet-stream")&&(u.responseType="arraybuffer")),!n||"object"!=typeof n.headers||n.headers instanceof f?c.headers.forEach((function(e,t){u.setRequestHeader(t,e)})):Object.getOwnPropertyNames(n.headers).forEach((function(e){u.setRequestHeader(e,h(n.headers[e]))})),c.signal&&(c.signal.addEventListener("abort",l),u.onreadystatechange=function(){4===u.readyState&&c.signal.removeEventListener("abort",l)}),u.send(void 0===c._bodyInit?null:c._bodyInit)}))}_.polyfill=!0,r.fetch||(r.fetch=_,r.Headers=f,r.Request=w,r.Response=A),t.Headers=f,t.Request=w,t.Response=A,t.fetch=_}({})}("undefined"!=typeof self?self:e);var n="undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{};function i(){throw new Error("setTimeout has not been defined")}function a(){throw new Error("clearTimeout has not been defined")}var o=i,s=a;function c(e){if(o===setTimeout)return setTimeout(e,0);if((o===i||!o)&&setTimeout)return o=setTimeout,setTimeout(e,0);try{return o(e,0)}catch(t){try{return o.call(null,e,0)}catch(t){return o.call(this,e,0)}}}"function"==typeof n.setTimeout&&(o=setTimeout),"function"==typeof n.clearTimeout&&(s=clearTimeout);var u,l=[],h=!1,d=-1;function f(){h&&u&&(h=!1,u.length?l=u.concat(l):d=-1,l.length&&p())}function p(){if(!h){var e=c(f);h=!0;for(var t=l.length;t;){for(u=l,l=[];++d<t;)u&&u[d].run();d=-1,t=l.length}u=null,h=!1,function(e){if(s===clearTimeout)return clearTimeout(e);if((s===a||!s)&&clearTimeout)return s=clearTimeout,clearTimeout(e);try{return s(e)}catch(t){try{return s.call(null,e)}catch(t){return s.call(this,e)}}}(e)}}function g(e){var t=new Array(arguments.length-1);if(arguments.length>1)for(var r=1;r<arguments.length;r++)t[r-1]=arguments[r];l.push(new y(e,t)),1!==l.length||h||c(p)}function y(e,t){this.fun=e,this.array=t}y.prototype.run=function(){this.fun.apply(null,this.array)};function m(){}var v=m,b=m,w=m,E=m,A=m,T=m,_=m;var C=n.performance||{},O=C.now||C.mozNow||C.msNow||C.oNow||C.webkitNow||function(){return(new Date).getTime()};var D=new Date;var x,R,F={nextTick:g,title:"browser",browser:!0,env:{},argv:[],version:"",versions:{},on:v,addListener:b,once:w,off:E,removeListener:A,removeAllListeners:T,emit:_,binding:function(e){throw new Error("process.binding is not supported")},cwd:function(){return"/"},chdir:function(e){throw new Error("process.chdir is not supported")},umask:function(){return 0},hrtime:function(e){var t=.001*O.call(C),r=Math.floor(t),n=Math.floor(t%1*1e9);return e&&(r-=e[0],(n-=e[1])<0&&(r--,n+=1e9)),[r,n]},platform:"browser",release:{},config:{},uptime:function(){return(new Date-D)/1e3}},S={exports:{}};function N(){if(R)return x;R=1;var e=1e3,t=60*e,r=60*t,n=24*r,i=7*n,a=365.25*n;function o(e,t,r,n){var i=t>=1.5*r;return Math.round(e/r)+" "+n+(i?"s":"")}return x=function(s,c){c=c||{};var u=typeof s;if("string"===u&&s.length>0)return function(o){if((o=String(o)).length>100)return;var s=/^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(o);if(!s)return;var c=parseFloat(s[1]);switch((s[2]||"ms").toLowerCase()){case"years":case"year":case"yrs":case"yr":case"y":return c*a;case"weeks":case"week":case"w":return c*i;case"days":case"day":case"d":return c*n;case"hours":case"hour":case"hrs":case"hr":case"h":return c*r;case"minutes":case"minute":case"mins":case"min":case"m":return c*t;case"seconds":case"second":case"secs":case"sec":case"s":return c*e;case"milliseconds":case"millisecond":case"msecs":case"msec":case"ms":return c;default:return}}(s);if("number"===u&&isFinite(s))return c.long?function(i){var a=Math.abs(i);if(a>=n)return o(i,a,n,"day");if(a>=r)return o(i,a,r,"hour");if(a>=t)return o(i,a,t,"minute");if(a>=e)return o(i,a,e,"second");return i+" ms"}(s):function(i){var a=Math.abs(i);if(a>=n)return Math.round(i/n)+"d";if(a>=r)return Math.round(i/r)+"h";if(a>=t)return Math.round(i/t)+"m";if(a>=e)return Math.round(i/e)+"s";return i+"ms"}(s);throw new Error("val is not a non-empty string or a valid number. val="+JSON.stringify(s))},x}var L=function(e){function t(e){let n,i,a,o=null;function s(...e){if(!s.enabled)return;const r=s,i=Number(new Date),a=i-(n||i);r.diff=a,r.prev=n,r.curr=i,n=i,e[0]=t.coerce(e[0]),"string"!=typeof e[0]&&e.unshift("%O");let o=0;e[0]=e[0].replace(/%([a-zA-Z%])/g,((n,i)=>{if("%%"===n)return"%";o++;const a=t.formatters[i];if("function"==typeof a){const t=e[o];n=a.call(r,t),e.splice(o,1),o--}return n})),t.formatArgs.call(r,e);(r.log||t.log).apply(r,e)}return s.namespace=e,s.useColors=t.useColors(),s.color=t.selectColor(e),s.extend=r,s.destroy=t.destroy,Object.defineProperty(s,"enabled",{enumerable:!0,configurable:!1,get:()=>null!==o?o:(i!==t.namespaces&&(i=t.namespaces,a=t.enabled(e)),a),set:e=>{o=e}}),"function"==typeof t.init&&t.init(s),s}function r(e,r){const n=t(this.namespace+(void 0===r?":":r)+e);return n.log=this.log,n}function n(e){return e.toString().substring(2,e.toString().length-2).replace(/\.\*\?$/,"*")}return t.debug=t,t.default=t,t.coerce=function(e){if(e instanceof Error)return e.stack||e.message;return e},t.disable=function(){const e=[...t.names.map(n),...t.skips.map(n).map((e=>"-"+e))].join(",");return t.enable(""),e},t.enable=function(e){let r;t.save(e),t.namespaces=e,t.names=[],t.skips=[];const n=("string"==typeof e?e:"").split(/[\s,]+/),i=n.length;for(r=0;r<i;r++)n[r]&&("-"===(e=n[r].replace(/\*/g,".*?"))[0]?t.skips.push(new RegExp("^"+e.slice(1)+"$")):t.names.push(new RegExp("^"+e+"$")))},t.enabled=function(e){if("*"===e[e.length-1])return!0;let r,n;for(r=0,n=t.skips.length;r<n;r++)if(t.skips[r].test(e))return!1;for(r=0,n=t.names.length;r<n;r++)if(t.names[r].test(e))return!0;return!1},t.humanize=N(),t.destroy=function(){console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.")},Object.keys(e).forEach((r=>{t[r]=e[r]})),t.names=[],t.skips=[],t.formatters={},t.selectColor=function(e){let r=0;for(let t=0;t<e.length;t++)r=(r<<5)-r+e.charCodeAt(t),r|=0;return t.colors[Math.abs(r)%t.colors.length]},t.enable(t.load()),t};!function(e,t){t.formatArgs=function(t){if(t[0]=(this.useColors?"%c":"")+this.namespace+(this.useColors?" %c":" ")+t[0]+(this.useColors?"%c ":" ")+"+"+e.exports.humanize(this.diff),!this.useColors)return;const r="color: "+this.color;t.splice(1,0,r,"color: inherit");let n=0,i=0;t[0].replace(/%[a-zA-Z%]/g,(e=>{"%%"!==e&&(n++,"%c"===e&&(i=n))})),t.splice(i,0,r)},t.save=function(e){try{e?t.storage.setItem("debug",e):t.storage.removeItem("debug")}catch(e){}},t.load=function(){let e;try{e=t.storage.getItem("debug")}catch(e){}!e&&void 0!==F&&"env"in F&&(e=F.env.DEBUG);return e},t.useColors=function(){if("undefined"!=typeof window&&window.process&&("renderer"===window.process.type||window.process.__nwjs))return!0;if("undefined"!=typeof navigator&&navigator.userAgent&&navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/))return!1;let e;return"undefined"!=typeof document&&document.documentElement&&document.documentElement.style&&document.documentElement.style.WebkitAppearance||"undefined"!=typeof window&&window.console&&(window.console.firebug||window.console.exception&&window.console.table)||"undefined"!=typeof navigator&&navigator.userAgent&&(e=navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/))&&parseInt(e[1],10)>=31||"undefined"!=typeof navigator&&navigator.userAgent&&navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/)},t.storage=function(){try{return localStorage}catch(e){}}(),t.destroy=(()=>{let e=!1;return()=>{e||(e=!0,console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."))}})(),t.colors=["#0000CC","#0000FF","#0033CC","#0033FF","#0066CC","#0066FF","#0099CC","#0099FF","#00CC00","#00CC33","#00CC66","#00CC99","#00CCCC","#00CCFF","#3300CC","#3300FF","#3333CC","#3333FF","#3366CC","#3366FF","#3399CC","#3399FF","#33CC00","#33CC33","#33CC66","#33CC99","#33CCCC","#33CCFF","#6600CC","#6600FF","#6633CC","#6633FF","#66CC00","#66CC33","#9900CC","#9900FF","#9933CC","#9933FF","#99CC00","#99CC33","#CC0000","#CC0033","#CC0066","#CC0099","#CC00CC","#CC00FF","#CC3300","#CC3333","#CC3366","#CC3399","#CC33CC","#CC33FF","#CC6600","#CC6633","#CC9900","#CC9933","#CCCC00","#CCCC33","#FF0000","#FF0033","#FF0066","#FF0099","#FF00CC","#FF00FF","#FF3300","#FF3333","#FF3366","#FF3399","#FF33CC","#FF33FF","#FF6600","#FF6633","#FF9900","#FF9933","#FFCC00","#FFCC33"],t.log=console.debug||console.log||(()=>{}),e.exports=L(t);const{formatters:r}=e.exports;r.j=function(e){try{return JSON.stringify(e)}catch(e){return"[UnexpectedJSONParseError]: "+e.message}}}(S,S.exports);var k,I=t(S.exports);!function(e){e.CALENDAR_SERVER="http://calendarserver.org/ns/",e.CALDAV_APPLE="http://apple.com/ns/ical/",e.CALDAV="urn:ietf:params:xml:ns:caldav",e.CARDDAV="urn:ietf:params:xml:ns:carddav",e.DAV="DAV:"}(k||(k={}));const U={[k.CALDAV]:"xmlns:c",[k.CARDDAV]:"xmlns:card",[k.CALENDAR_SERVER]:"xmlns:cs",[k.CALDAV_APPLE]:"xmlns:ca",[k.DAV]:"xmlns:d"};var P,j;!function(e){e.CALDAV="c",e.CARDDAV="card",e.CALENDAR_SERVER="cs",e.CALDAV_APPLE="ca",e.DAV="d"}(P||(P={})),function(e){e.VEVENT="VEVENT",e.VTODO="VTODO",e.VJOURNAL="VJOURNAL",e.VFREEBUSY="VFREEBUSY",e.VTIMEZONE="VTIMEZONE",e.VALARM="VALARM"}(j||(j={}));var B=[],V=[],M="undefined"!=typeof Uint8Array?Uint8Array:Array,$=!1;function K(){$=!0;for(var e="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",t=0;t<64;++t)B[t]=e[t],V[e.charCodeAt(t)]=t;V["-".charCodeAt(0)]=62,V["_".charCodeAt(0)]=63}function H(e,t,r){for(var n,i,a=[],o=t;o<r;o+=3)n=(e[o]<<16)+(e[o+1]<<8)+e[o+2],a.push(B[(i=n)>>18&63]+B[i>>12&63]+B[i>>6&63]+B[63&i]);return a.join("")}function Y(e){var t;$||K();for(var r=e.length,n=r%3,i="",a=[],o=16383,s=0,c=r-n;s<c;s+=o)a.push(H(e,s,s+o>c?c:s+o));return 1===n?(t=e[r-1],i+=B[t>>2],i+=B[t<<4&63],i+="=="):2===n&&(t=(e[r-2]<<8)+e[r-1],i+=B[t>>10],i+=B[t>>4&63],i+=B[t<<2&63],i+="="),a.push(i),a.join("")}function q(e,t,r,n,i){var a,o,s=8*i-n-1,c=(1<<s)-1,u=c>>1,l=-7,h=r?i-1:0,d=r?-1:1,f=e[t+h];for(h+=d,a=f&(1<<-l)-1,f>>=-l,l+=s;l>0;a=256*a+e[t+h],h+=d,l-=8);for(o=a&(1<<-l)-1,a>>=-l,l+=n;l>0;o=256*o+e[t+h],h+=d,l-=8);if(0===a)a=1-u;else{if(a===c)return o?NaN:1/0*(f?-1:1);o+=Math.pow(2,n),a-=u}return(f?-1:1)*o*Math.pow(2,a-n)}function z(e,t,r,n,i,a){var o,s,c,u=8*a-i-1,l=(1<<u)-1,h=l>>1,d=23===i?Math.pow(2,-24)-Math.pow(2,-77):0,f=n?0:a-1,p=n?1:-1,g=t<0||0===t&&1/t<0?1:0;for(t=Math.abs(t),isNaN(t)||t===1/0?(s=isNaN(t)?1:0,o=l):(o=Math.floor(Math.log(t)/Math.LN2),t*(c=Math.pow(2,-o))<1&&(o--,c*=2),(t+=o+h>=1?d/c:d*Math.pow(2,1-h))*c>=2&&(o++,c/=2),o+h>=l?(s=0,o=l):o+h>=1?(s=(t*c-1)*Math.pow(2,i),o+=h):(s=t*Math.pow(2,h-1)*Math.pow(2,i),o=0));i>=8;e[r+f]=255&s,f+=p,s/=256,i-=8);for(o=o<<i|s,u+=i;u>0;e[r+f]=255&o,f+=p,o/=256,u-=8);e[r+f-p]|=128*g}var G={}.toString,W=Array.isArray||function(e){return"[object Array]"==G.call(e)};function Q(){return Z.TYPED_ARRAY_SUPPORT?2147483647:1073741823}function X(e,t){if(Q()<t)throw new RangeError("Invalid typed array length");return Z.TYPED_ARRAY_SUPPORT?(e=new Uint8Array(t)).__proto__=Z.prototype:(null===e&&(e=new Z(t)),e.length=t),e}function Z(e,t,r){if(!(Z.TYPED_ARRAY_SUPPORT||this instanceof Z))return new Z(e,t,r);if("number"==typeof e){if("string"==typeof t)throw new Error("If encoding is specified then the first argument must be a string");return te(this,e)}return J(this,e,t,r)}function J(e,t,r,n){if("number"==typeof t)throw new TypeError('"value" argument must not be a number');return"undefined"!=typeof ArrayBuffer&&t instanceof ArrayBuffer?function(e,t,r,n){if(t.byteLength,r<0||t.byteLength<r)throw new RangeError("'offset' is out of bounds");if(t.byteLength<r+(n||0))throw new RangeError("'length' is out of bounds");t=void 0===r&&void 0===n?new Uint8Array(t):void 0===n?new Uint8Array(t,r):new Uint8Array(t,r,n);Z.TYPED_ARRAY_SUPPORT?(e=t).__proto__=Z.prototype:e=re(e,t);return e}(e,t,r,n):"string"==typeof t?function(e,t,r){"string"==typeof r&&""!==r||(r="utf8");if(!Z.isEncoding(r))throw new TypeError('"encoding" must be a valid string encoding');var n=0|ae(t,r);e=X(e,n);var i=e.write(t,r);i!==n&&(e=e.slice(0,i));return e}(e,t,r):function(e,t){if(ie(t)){var r=0|ne(t.length);return 0===(e=X(e,r)).length||t.copy(e,0,0,r),e}if(t){if("undefined"!=typeof ArrayBuffer&&t.buffer instanceof ArrayBuffer||"length"in t)return"number"!=typeof t.length||(n=t.length)!=n?X(e,0):re(e,t);if("Buffer"===t.type&&W(t.data))return re(e,t.data)}var n;throw new TypeError("First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.")}(e,t)}function ee(e){if("number"!=typeof e)throw new TypeError('"size" argument must be a number');if(e<0)throw new RangeError('"size" argument must not be negative')}function te(e,t){if(ee(t),e=X(e,t<0?0:0|ne(t)),!Z.TYPED_ARRAY_SUPPORT)for(var r=0;r<t;++r)e[r]=0;return e}function re(e,t){var r=t.length<0?0:0|ne(t.length);e=X(e,r);for(var n=0;n<r;n+=1)e[n]=255&t[n];return e}function ne(e){if(e>=Q())throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x"+Q().toString(16)+" bytes");return 0|e}function ie(e){return!(null==e||!e._isBuffer)}function ae(e,t){if(ie(e))return e.length;if("undefined"!=typeof ArrayBuffer&&"function"==typeof ArrayBuffer.isView&&(ArrayBuffer.isView(e)||e instanceof ArrayBuffer))return e.byteLength;"string"!=typeof e&&(e=""+e);var r=e.length;if(0===r)return 0;for(var n=!1;;)switch(t){case"ascii":case"latin1":case"binary":return r;case"utf8":case"utf-8":case void 0:return Ne(e).length;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return 2*r;case"hex":return r>>>1;case"base64":return Le(e).length;default:if(n)return Ne(e).length;t=(""+t).toLowerCase(),n=!0}}function oe(e,t,r){var n=!1;if((void 0===t||t<0)&&(t=0),t>this.length)return"";if((void 0===r||r>this.length)&&(r=this.length),r<=0)return"";if((r>>>=0)<=(t>>>=0))return"";for(e||(e="utf8");;)switch(e){case"hex":return Ee(this,t,r);case"utf8":case"utf-8":return me(this,t,r);case"ascii":return be(this,t,r);case"latin1":case"binary":return we(this,t,r);case"base64":return ye(this,t,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return Ae(this,t,r);default:if(n)throw new TypeError("Unknown encoding: "+e);e=(e+"").toLowerCase(),n=!0}}function se(e,t,r){var n=e[t];e[t]=e[r],e[r]=n}function ce(e,t,r,n,i){if(0===e.length)return-1;if("string"==typeof r?(n=r,r=0):r>2147483647?r=2147483647:r<-2147483648&&(r=-2147483648),r=+r,isNaN(r)&&(r=i?0:e.length-1),r<0&&(r=e.length+r),r>=e.length){if(i)return-1;r=e.length-1}else if(r<0){if(!i)return-1;r=0}if("string"==typeof t&&(t=Z.from(t,n)),ie(t))return 0===t.length?-1:ue(e,t,r,n,i);if("number"==typeof t)return t&=255,Z.TYPED_ARRAY_SUPPORT&&"function"==typeof Uint8Array.prototype.indexOf?i?Uint8Array.prototype.indexOf.call(e,t,r):Uint8Array.prototype.lastIndexOf.call(e,t,r):ue(e,[t],r,n,i);throw new TypeError("val must be string, number or Buffer")}function ue(e,t,r,n,i){var a,o=1,s=e.length,c=t.length;if(void 0!==n&&("ucs2"===(n=String(n).toLowerCase())||"ucs-2"===n||"utf16le"===n||"utf-16le"===n)){if(e.length<2||t.length<2)return-1;o=2,s/=2,c/=2,r/=2}function u(e,t){return 1===o?e[t]:e.readUInt16BE(t*o)}if(i){var l=-1;for(a=r;a<s;a++)if(u(e,a)===u(t,-1===l?0:a-l)){if(-1===l&&(l=a),a-l+1===c)return l*o}else-1!==l&&(a-=a-l),l=-1}else for(r+c>s&&(r=s-c),a=r;a>=0;a--){for(var h=!0,d=0;d<c;d++)if(u(e,a+d)!==u(t,d)){h=!1;break}if(h)return a}return-1}function le(e,t,r,n){r=Number(r)||0;var i=e.length-r;n?(n=Number(n))>i&&(n=i):n=i;var a=t.length;if(a%2!=0)throw new TypeError("Invalid hex string");n>a/2&&(n=a/2);for(var o=0;o<n;++o){var s=parseInt(t.substr(2*o,2),16);if(isNaN(s))return o;e[r+o]=s}return o}function he(e,t,r,n){return ke(Ne(t,e.length-r),e,r,n)}function de(e,t,r,n){return ke(function(e){for(var t=[],r=0;r<e.length;++r)t.push(255&e.charCodeAt(r));return t}(t),e,r,n)}function fe(e,t,r,n){return de(e,t,r,n)}function pe(e,t,r,n){return ke(Le(t),e,r,n)}function ge(e,t,r,n){return ke(function(e,t){for(var r,n,i,a=[],o=0;o<e.length&&!((t-=2)<0);++o)n=(r=e.charCodeAt(o))>>8,i=r%256,a.push(i),a.push(n);return a}(t,e.length-r),e,r,n)}function ye(e,t,r){return 0===t&&r===e.length?Y(e):Y(e.slice(t,r))}function me(e,t,r){r=Math.min(e.length,r);for(var n=[],i=t;i<r;){var a,o,s,c,u=e[i],l=null,h=u>239?4:u>223?3:u>191?2:1;if(i+h<=r)switch(h){case 1:u<128&&(l=u);break;case 2:128==(192&(a=e[i+1]))&&(c=(31&u)<<6|63&a)>127&&(l=c);break;case 3:a=e[i+1],o=e[i+2],128==(192&a)&&128==(192&o)&&(c=(15&u)<<12|(63&a)<<6|63&o)>2047&&(c<55296||c>57343)&&(l=c);break;case 4:a=e[i+1],o=e[i+2],s=e[i+3],128==(192&a)&&128==(192&o)&&128==(192&s)&&(c=(15&u)<<18|(63&a)<<12|(63&o)<<6|63&s)>65535&&c<1114112&&(l=c)}null===l?(l=65533,h=1):l>65535&&(l-=65536,n.push(l>>>10&1023|55296),l=56320|1023&l),n.push(l),i+=h}return function(e){var t=e.length;if(t<=ve)return String.fromCharCode.apply(String,e);var r="",n=0;for(;n<t;)r+=String.fromCharCode.apply(String,e.slice(n,n+=ve));return r}(n)}Z.TYPED_ARRAY_SUPPORT=void 0===n.TYPED_ARRAY_SUPPORT||n.TYPED_ARRAY_SUPPORT,Q(),Z.poolSize=8192,Z._augment=function(e){return e.__proto__=Z.prototype,e},Z.from=function(e,t,r){return J(null,e,t,r)},Z.TYPED_ARRAY_SUPPORT&&(Z.prototype.__proto__=Uint8Array.prototype,Z.__proto__=Uint8Array,"undefined"!=typeof Symbol&&Symbol.species&&Z[Symbol.species]),Z.alloc=function(e,t,r){return function(e,t,r,n){return ee(t),t<=0?X(e,t):void 0!==r?"string"==typeof n?X(e,t).fill(r,n):X(e,t).fill(r):X(e,t)}(null,e,t,r)},Z.allocUnsafe=function(e){return te(null,e)},Z.allocUnsafeSlow=function(e){return te(null,e)},Z.isBuffer=function(e){return null!=e&&(!!e._isBuffer||Ie(e)||function(e){return"function"==typeof e.readFloatLE&&"function"==typeof e.slice&&Ie(e.slice(0,0))}(e))},Z.compare=function(e,t){if(!ie(e)||!ie(t))throw new TypeError("Arguments must be Buffers");if(e===t)return 0;for(var r=e.length,n=t.length,i=0,a=Math.min(r,n);i<a;++i)if(e[i]!==t[i]){r=e[i],n=t[i];break}return r<n?-1:n<r?1:0},Z.isEncoding=function(e){switch(String(e).toLowerCase()){case"hex":case"utf8":case"utf-8":case"ascii":case"latin1":case"binary":case"base64":case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return!0;default:return!1}},Z.concat=function(e,t){if(!W(e))throw new TypeError('"list" argument must be an Array of Buffers');if(0===e.length)return Z.alloc(0);var r;if(void 0===t)for(t=0,r=0;r<e.length;++r)t+=e[r].length;var n=Z.allocUnsafe(t),i=0;for(r=0;r<e.length;++r){var a=e[r];if(!ie(a))throw new TypeError('"list" argument must be an Array of Buffers');a.copy(n,i),i+=a.length}return n},Z.byteLength=ae,Z.prototype._isBuffer=!0,Z.prototype.swap16=function(){var e=this.length;if(e%2!=0)throw new RangeError("Buffer size must be a multiple of 16-bits");for(var t=0;t<e;t+=2)se(this,t,t+1);return this},Z.prototype.swap32=function(){var e=this.length;if(e%4!=0)throw new RangeError("Buffer size must be a multiple of 32-bits");for(var t=0;t<e;t+=4)se(this,t,t+3),se(this,t+1,t+2);return this},Z.prototype.swap64=function(){var e=this.length;if(e%8!=0)throw new RangeError("Buffer size must be a multiple of 64-bits");for(var t=0;t<e;t+=8)se(this,t,t+7),se(this,t+1,t+6),se(this,t+2,t+5),se(this,t+3,t+4);return this},Z.prototype.toString=function(){var e=0|this.length;return 0===e?"":0===arguments.length?me(this,0,e):oe.apply(this,arguments)},Z.prototype.equals=function(e){if(!ie(e))throw new TypeError("Argument must be a Buffer");return this===e||0===Z.compare(this,e)},Z.prototype.inspect=function(){var e="";return this.length>0&&(e=this.toString("hex",0,50).match(/.{2}/g).join(" "),this.length>50&&(e+=" ... ")),"<Buffer "+e+">"},Z.prototype.compare=function(e,t,r,n,i){if(!ie(e))throw new TypeError("Argument must be a Buffer");if(void 0===t&&(t=0),void 0===r&&(r=e?e.length:0),void 0===n&&(n=0),void 0===i&&(i=this.length),t<0||r>e.length||n<0||i>this.length)throw new RangeError("out of range index");if(n>=i&&t>=r)return 0;if(n>=i)return-1;if(t>=r)return 1;if(this===e)return 0;for(var a=(i>>>=0)-(n>>>=0),o=(r>>>=0)-(t>>>=0),s=Math.min(a,o),c=this.slice(n,i),u=e.slice(t,r),l=0;l<s;++l)if(c[l]!==u[l]){a=c[l],o=u[l];break}return a<o?-1:o<a?1:0},Z.prototype.includes=function(e,t,r){return-1!==this.indexOf(e,t,r)},Z.prototype.indexOf=function(e,t,r){return ce(this,e,t,r,!0)},Z.prototype.lastIndexOf=function(e,t,r){return ce(this,e,t,r,!1)},Z.prototype.write=function(e,t,r,n){if(void 0===t)n="utf8",r=this.length,t=0;else if(void 0===r&&"string"==typeof t)n=t,r=this.length,t=0;else{if(!isFinite(t))throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");t|=0,isFinite(r)?(r|=0,void 0===n&&(n="utf8")):(n=r,r=void 0)}var i=this.length-t;if((void 0===r||r>i)&&(r=i),e.length>0&&(r<0||t<0)||t>this.length)throw new RangeError("Attempt to write outside buffer bounds");n||(n="utf8");for(var a=!1;;)switch(n){case"hex":return le(this,e,t,r);case"utf8":case"utf-8":return he(this,e,t,r);case"ascii":return de(this,e,t,r);case"latin1":case"binary":return fe(this,e,t,r);case"base64":return pe(this,e,t,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return ge(this,e,t,r);default:if(a)throw new TypeError("Unknown encoding: "+n);n=(""+n).toLowerCase(),a=!0}},Z.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};var ve=4096;function be(e,t,r){var n="";r=Math.min(e.length,r);for(var i=t;i<r;++i)n+=String.fromCharCode(127&e[i]);return n}function we(e,t,r){var n="";r=Math.min(e.length,r);for(var i=t;i<r;++i)n+=String.fromCharCode(e[i]);return n}function Ee(e,t,r){var n=e.length;(!t||t<0)&&(t=0),(!r||r<0||r>n)&&(r=n);for(var i="",a=t;a<r;++a)i+=Se(e[a]);return i}function Ae(e,t,r){for(var n=e.slice(t,r),i="",a=0;a<n.length;a+=2)i+=String.fromCharCode(n[a]+256*n[a+1]);return i}function Te(e,t,r){if(e%1!=0||e<0)throw new RangeError("offset is not uint");if(e+t>r)throw new RangeError("Trying to access beyond buffer length")}function _e(e,t,r,n,i,a){if(!ie(e))throw new TypeError('"buffer" argument must be a Buffer instance');if(t>i||t<a)throw new RangeError('"value" argument is out of bounds');if(r+n>e.length)throw new RangeError("Index out of range")}function Ce(e,t,r,n){t<0&&(t=65535+t+1);for(var i=0,a=Math.min(e.length-r,2);i<a;++i)e[r+i]=(t&255<<8*(n?i:1-i))>>>8*(n?i:1-i)}function Oe(e,t,r,n){t<0&&(t=4294967295+t+1);for(var i=0,a=Math.min(e.length-r,4);i<a;++i)e[r+i]=t>>>8*(n?i:3-i)&255}function De(e,t,r,n,i,a){if(r+n>e.length)throw new RangeError("Index out of range");if(r<0)throw new RangeError("Index out of range")}function xe(e,t,r,n,i){return i||De(e,0,r,4),z(e,t,r,n,23,4),r+4}function Re(e,t,r,n,i){return i||De(e,0,r,8),z(e,t,r,n,52,8),r+8}Z.prototype.slice=function(e,t){var r,n=this.length;if((e=~~e)<0?(e+=n)<0&&(e=0):e>n&&(e=n),(t=void 0===t?n:~~t)<0?(t+=n)<0&&(t=0):t>n&&(t=n),t<e&&(t=e),Z.TYPED_ARRAY_SUPPORT)(r=this.subarray(e,t)).__proto__=Z.prototype;else{var i=t-e;r=new Z(i,void 0);for(var a=0;a<i;++a)r[a]=this[a+e]}return r},Z.prototype.readUIntLE=function(e,t,r){e|=0,t|=0,r||Te(e,t,this.length);for(var n=this[e],i=1,a=0;++a<t&&(i*=256);)n+=this[e+a]*i;return n},Z.prototype.readUIntBE=function(e,t,r){e|=0,t|=0,r||Te(e,t,this.length);for(var n=this[e+--t],i=1;t>0&&(i*=256);)n+=this[e+--t]*i;return n},Z.prototype.readUInt8=function(e,t){return t||Te(e,1,this.length),this[e]},Z.prototype.readUInt16LE=function(e,t){return t||Te(e,2,this.length),this[e]|this[e+1]<<8},Z.prototype.readUInt16BE=function(e,t){return t||Te(e,2,this.length),this[e]<<8|this[e+1]},Z.prototype.readUInt32LE=function(e,t){return t||Te(e,4,this.length),(this[e]|this[e+1]<<8|this[e+2]<<16)+16777216*this[e+3]},Z.prototype.readUInt32BE=function(e,t){return t||Te(e,4,this.length),16777216*this[e]+(this[e+1]<<16|this[e+2]<<8|this[e+3])},Z.prototype.readIntLE=function(e,t,r){e|=0,t|=0,r||Te(e,t,this.length);for(var n=this[e],i=1,a=0;++a<t&&(i*=256);)n+=this[e+a]*i;return n>=(i*=128)&&(n-=Math.pow(2,8*t)),n},Z.prototype.readIntBE=function(e,t,r){e|=0,t|=0,r||Te(e,t,this.length);for(var n=t,i=1,a=this[e+--n];n>0&&(i*=256);)a+=this[e+--n]*i;return a>=(i*=128)&&(a-=Math.pow(2,8*t)),a},Z.prototype.readInt8=function(e,t){return t||Te(e,1,this.length),128&this[e]?-1*(255-this[e]+1):this[e]},Z.prototype.readInt16LE=function(e,t){t||Te(e,2,this.length);var r=this[e]|this[e+1]<<8;return 32768&r?4294901760|r:r},Z.prototype.readInt16BE=function(e,t){t||Te(e,2,this.length);var r=this[e+1]|this[e]<<8;return 32768&r?4294901760|r:r},Z.prototype.readInt32LE=function(e,t){return t||Te(e,4,this.length),this[e]|this[e+1]<<8|this[e+2]<<16|this[e+3]<<24},Z.prototype.readInt32BE=function(e,t){return t||Te(e,4,this.length),this[e]<<24|this[e+1]<<16|this[e+2]<<8|this[e+3]},Z.prototype.readFloatLE=function(e,t){return t||Te(e,4,this.length),q(this,e,!0,23,4)},Z.prototype.readFloatBE=function(e,t){return t||Te(e,4,this.length),q(this,e,!1,23,4)},Z.prototype.readDoubleLE=function(e,t){return t||Te(e,8,this.length),q(this,e,!0,52,8)},Z.prototype.readDoubleBE=function(e,t){return t||Te(e,8,this.length),q(this,e,!1,52,8)},Z.prototype.writeUIntLE=function(e,t,r,n){(e=+e,t|=0,r|=0,n)||_e(this,e,t,r,Math.pow(2,8*r)-1,0);var i=1,a=0;for(this[t]=255&e;++a<r&&(i*=256);)this[t+a]=e/i&255;return t+r},Z.prototype.writeUIntBE=function(e,t,r,n){(e=+e,t|=0,r|=0,n)||_e(this,e,t,r,Math.pow(2,8*r)-1,0);var i=r-1,a=1;for(this[t+i]=255&e;--i>=0&&(a*=256);)this[t+i]=e/a&255;return t+r},Z.prototype.writeUInt8=function(e,t,r){return e=+e,t|=0,r||_e(this,e,t,1,255,0),Z.TYPED_ARRAY_SUPPORT||(e=Math.floor(e)),this[t]=255&e,t+1},Z.prototype.writeUInt16LE=function(e,t,r){return e=+e,t|=0,r||_e(this,e,t,2,65535,0),Z.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8):Ce(this,e,t,!0),t+2},Z.prototype.writeUInt16BE=function(e,t,r){return e=+e,t|=0,r||_e(this,e,t,2,65535,0),Z.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):Ce(this,e,t,!1),t+2},Z.prototype.writeUInt32LE=function(e,t,r){return e=+e,t|=0,r||_e(this,e,t,4,4294967295,0),Z.TYPED_ARRAY_SUPPORT?(this[t+3]=e>>>24,this[t+2]=e>>>16,this[t+1]=e>>>8,this[t]=255&e):Oe(this,e,t,!0),t+4},Z.prototype.writeUInt32BE=function(e,t,r){return e=+e,t|=0,r||_e(this,e,t,4,4294967295,0),Z.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):Oe(this,e,t,!1),t+4},Z.prototype.writeIntLE=function(e,t,r,n){if(e=+e,t|=0,!n){var i=Math.pow(2,8*r-1);_e(this,e,t,r,i-1,-i)}var a=0,o=1,s=0;for(this[t]=255&e;++a<r&&(o*=256);)e<0&&0===s&&0!==this[t+a-1]&&(s=1),this[t+a]=(e/o|0)-s&255;return t+r},Z.prototype.writeIntBE=function(e,t,r,n){if(e=+e,t|=0,!n){var i=Math.pow(2,8*r-1);_e(this,e,t,r,i-1,-i)}var a=r-1,o=1,s=0;for(this[t+a]=255&e;--a>=0&&(o*=256);)e<0&&0===s&&0!==this[t+a+1]&&(s=1),this[t+a]=(e/o|0)-s&255;return t+r},Z.prototype.writeInt8=function(e,t,r){return e=+e,t|=0,r||_e(this,e,t,1,127,-128),Z.TYPED_ARRAY_SUPPORT||(e=Math.floor(e)),e<0&&(e=255+e+1),this[t]=255&e,t+1},Z.prototype.writeInt16LE=function(e,t,r){return e=+e,t|=0,r||_e(this,e,t,2,32767,-32768),Z.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8):Ce(this,e,t,!0),t+2},Z.prototype.writeInt16BE=function(e,t,r){return e=+e,t|=0,r||_e(this,e,t,2,32767,-32768),Z.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):Ce(this,e,t,!1),t+2},Z.prototype.writeInt32LE=function(e,t,r){return e=+e,t|=0,r||_e(this,e,t,4,2147483647,-2147483648),Z.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8,this[t+2]=e>>>16,this[t+3]=e>>>24):Oe(this,e,t,!0),t+4},Z.prototype.writeInt32BE=function(e,t,r){return e=+e,t|=0,r||_e(this,e,t,4,2147483647,-2147483648),e<0&&(e=4294967295+e+1),Z.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):Oe(this,e,t,!1),t+4},Z.prototype.writeFloatLE=function(e,t,r){return xe(this,e,t,!0,r)},Z.prototype.writeFloatBE=function(e,t,r){return xe(this,e,t,!1,r)},Z.prototype.writeDoubleLE=function(e,t,r){return Re(this,e,t,!0,r)},Z.prototype.writeDoubleBE=function(e,t,r){return Re(this,e,t,!1,r)},Z.prototype.copy=function(e,t,r,n){if(r||(r=0),n||0===n||(n=this.length),t>=e.length&&(t=e.length),t||(t=0),n>0&&n<r&&(n=r),n===r)return 0;if(0===e.length||0===this.length)return 0;if(t<0)throw new RangeError("targetStart out of bounds");if(r<0||r>=this.length)throw new RangeError("sourceStart out of bounds");if(n<0)throw new RangeError("sourceEnd out of bounds");n>this.length&&(n=this.length),e.length-t<n-r&&(n=e.length-t+r);var i,a=n-r;if(this===e&&r<t&&t<n)for(i=a-1;i>=0;--i)e[i+t]=this[i+r];else if(a<1e3||!Z.TYPED_ARRAY_SUPPORT)for(i=0;i<a;++i)e[i+t]=this[i+r];else Uint8Array.prototype.set.call(e,this.subarray(r,r+a),t);return a},Z.prototype.fill=function(e,t,r,n){if("string"==typeof e){if("string"==typeof t?(n=t,t=0,r=this.length):"string"==typeof r&&(n=r,r=this.length),1===e.length){var i=e.charCodeAt(0);i<256&&(e=i)}if(void 0!==n&&"string"!=typeof n)throw new TypeError("encoding must be a string");if("string"==typeof n&&!Z.isEncoding(n))throw new TypeError("Unknown encoding: "+n)}else"number"==typeof e&&(e&=255);if(t<0||this.length<t||this.length<r)throw new RangeError("Out of range index");if(r<=t)return this;var a;if(t>>>=0,r=void 0===r?this.length:r>>>0,e||(e=0),"number"==typeof e)for(a=t;a<r;++a)this[a]=e;else{var o=ie(e)?e:Ne(new Z(e,n).toString()),s=o.length;for(a=0;a<r-t;++a)this[a+t]=o[a%s]}return this};var Fe=/[^+\/0-9A-Za-z-_]/g;function Se(e){return e<16?"0"+e.toString(16):e.toString(16)}function Ne(e,t){var r;t=t||1/0;for(var n=e.length,i=null,a=[],o=0;o<n;++o){if((r=e.charCodeAt(o))>55295&&r<57344){if(!i){if(r>56319){(t-=3)>-1&&a.push(239,191,189);continue}if(o+1===n){(t-=3)>-1&&a.push(239,191,189);continue}i=r;continue}if(r<56320){(t-=3)>-1&&a.push(239,191,189),i=r;continue}r=65536+(i-55296<<10|r-56320)}else i&&(t-=3)>-1&&a.push(239,191,189);if(i=null,r<128){if((t-=1)<0)break;a.push(r)}else if(r<2048){if((t-=2)<0)break;a.push(r>>6|192,63&r|128)}else if(r<65536){if((t-=3)<0)break;a.push(r>>12|224,r>>6&63|128,63&r|128)}else{if(!(r<1114112))throw new Error("Invalid code point");if((t-=4)<0)break;a.push(r>>18|240,r>>12&63|128,r>>6&63|128,63&r|128)}}return a}function Le(e){return function(e){var t,r,n,i,a,o;$||K();var s=e.length;if(s%4>0)throw new Error("Invalid string. Length must be a multiple of 4");a="="===e[s-2]?2:"="===e[s-1]?1:0,o=new M(3*s/4-a),n=a>0?s-4:s;var c=0;for(t=0,r=0;t<n;t+=4,r+=3)i=V[e.charCodeAt(t)]<<18|V[e.charCodeAt(t+1)]<<12|V[e.charCodeAt(t+2)]<<6|V[e.charCodeAt(t+3)],o[c++]=i>>16&255,o[c++]=i>>8&255,o[c++]=255&i;return 2===a?(i=V[e.charCodeAt(t)]<<2|V[e.charCodeAt(t+1)]>>4,o[c++]=255&i):1===a&&(i=V[e.charCodeAt(t)]<<10|V[e.charCodeAt(t+1)]<<4|V[e.charCodeAt(t+2)]>>2,o[c++]=i>>8&255,o[c++]=255&i),o}(function(e){if((e=function(e){return e.trim?e.trim():e.replace(/^\s+|\s+$/g,"")}(e).replace(Fe,"")).length<2)return"";for(;e.length%4!=0;)e+="=";return e}(e))}function ke(e,t,r,n){for(var i=0;i<n&&!(i+r>=t.length||i>=e.length);++i)t[i+r]=e[i];return i}function Ie(e){return!!e.constructor&&"function"==typeof e.constructor.isBuffer&&e.constructor.isBuffer(e)}var Ue,Pe={};function je(){}function Be(){Be.init.call(this)}function Ve(e){return void 0===e._maxListeners?Be.defaultMaxListeners:e._maxListeners}function Me(e,t,r,n){var i,a,o,s;if("function"!=typeof r)throw new TypeError('"listener" argument must be a function');if((a=e._events)?(a.newListener&&(e.emit("newListener",t,r.listener?r.listener:r),a=e._events),o=a[t]):(a=e._events=new je,e._eventsCount=0),o){if("function"==typeof o?o=a[t]=n?[r,o]:[o,r]:n?o.unshift(r):o.push(r),!o.warned&&(i=Ve(e))&&i>0&&o.length>i){o.warned=!0;var c=new Error("Possible EventEmitter memory leak detected. "+o.length+" "+t+" listeners added. Use emitter.setMaxListeners() to increase limit");c.name="MaxListenersExceededWarning",c.emitter=e,c.type=t,c.count=o.length,s=c,"function"==typeof console.warn?console.warn(s):console.log(s)}}else o=a[t]=r,++e._eventsCount;return e}function $e(e,t,r){var n=!1;function i(){e.removeListener(t,i),n||(n=!0,r.apply(e,arguments))}return i.listener=r,i}function Ke(e){var t=this._events;if(t){var r=t[e];if("function"==typeof r)return 1;if(r)return r.length}return 0}function He(e,t){for(var r=new Array(t);t--;)r[t]=e[t];return r}je.prototype=Object.create(null),Be.EventEmitter=Be,Be.usingDomains=!1,Be.prototype.domain=void 0,Be.prototype._events=void 0,Be.prototype._maxListeners=void 0,Be.defaultMaxListeners=10,Be.init=function(){this.domain=null,Be.usingDomains&&undefined.active,this._events&&this._events!==Object.getPrototypeOf(this)._events||(this._events=new je,this._eventsCount=0),this._maxListeners=this._maxListeners||void 0},Be.prototype.setMaxListeners=function(e){if("number"!=typeof e||e<0||isNaN(e))throw new TypeError('"n" argument must be a positive number');return this._maxListeners=e,this},Be.prototype.getMaxListeners=function(){return Ve(this)},Be.prototype.emit=function(e){var t,r,n,i,a,o,s,c="error"===e;if(o=this._events)c=c&&null==o.error;else if(!c)return!1;if(s=this.domain,c){if(t=arguments[1],!s){if(t instanceof Error)throw t;var u=new Error('Uncaught, unspecified "error" event. ('+t+")");throw u.context=t,u}return t||(t=new Error('Uncaught, unspecified "error" event')),t.domainEmitter=this,t.domain=s,t.domainThrown=!1,s.emit("error",t),!1}if(!(r=o[e]))return!1;var l="function"==typeof r;switch(n=arguments.length){case 1:!function(e,t,r){if(t)e.call(r);else for(var n=e.length,i=He(e,n),a=0;a<n;++a)i[a].call(r)}(r,l,this);break;case 2:!function(e,t,r,n){if(t)e.call(r,n);else for(var i=e.length,a=He(e,i),o=0;o<i;++o)a[o].call(r,n)}(r,l,this,arguments[1]);break;case 3:!function(e,t,r,n,i){if(t)e.call(r,n,i);else for(var a=e.length,o=He(e,a),s=0;s<a;++s)o[s].call(r,n,i)}(r,l,this,arguments[1],arguments[2]);break;case 4:!function(e,t,r,n,i,a){if(t)e.call(r,n,i,a);else for(var o=e.length,s=He(e,o),c=0;c<o;++c)s[c].call(r,n,i,a)}(r,l,this,arguments[1],arguments[2],arguments[3]);break;default:for(i=new Array(n-1),a=1;a<n;a++)i[a-1]=arguments[a];!function(e,t,r,n){if(t)e.apply(r,n);else for(var i=e.length,a=He(e,i),o=0;o<i;++o)a[o].apply(r,n)}(r,l,this,i)}return!0},Be.prototype.addListener=function(e,t){return Me(this,e,t,!1)},Be.prototype.on=Be.prototype.addListener,Be.prototype.prependListener=function(e,t){return Me(this,e,t,!0)},Be.prototype.once=function(e,t){if("function"!=typeof t)throw new TypeError('"listener" argument must be a function');return this.on(e,$e(this,e,t)),this},Be.prototype.prependOnceListener=function(e,t){if("function"!=typeof t)throw new TypeError('"listener" argument must be a function');return this.prependListener(e,$e(this,e,t)),this},Be.prototype.removeListener=function(e,t){var r,n,i,a,o;if("function"!=typeof t)throw new TypeError('"listener" argument must be a function');if(!(n=this._events))return this;if(!(r=n[e]))return this;if(r===t||r.listener&&r.listener===t)0==--this._eventsCount?this._events=new je:(delete n[e],n.removeListener&&this.emit("removeListener",e,r.listener||t));else if("function"!=typeof r){for(i=-1,a=r.length;a-- >0;)if(r[a]===t||r[a].listener&&r[a].listener===t){o=r[a].listener,i=a;break}if(i<0)return this;if(1===r.length){if(r[0]=void 0,0==--this._eventsCount)return this._events=new je,this;delete n[e]}else!function(e,t){for(var r=t,n=r+1,i=e.length;n<i;r+=1,n+=1)e[r]=e[n];e.pop()}(r,i);n.removeListener&&this.emit("removeListener",e,o||t)}return this},Be.prototype.off=function(e,t){return this.removeListener(e,t)},Be.prototype.removeAllListeners=function(e){var t,r;if(!(r=this._events))return this;if(!r.removeListener)return 0===arguments.length?(this._events=new je,this._eventsCount=0):r[e]&&(0==--this._eventsCount?this._events=new je:delete r[e]),this;if(0===arguments.length){for(var n,i=Object.keys(r),a=0;a<i.length;++a)"removeListener"!==(n=i[a])&&this.removeAllListeners(n);return this.removeAllListeners("removeListener"),this._events=new je,this._eventsCount=0,this}if("function"==typeof(t=r[e]))this.removeListener(e,t);else if(t)do{this.removeListener(e,t[t.length-1])}while(t[0]);return this},Be.prototype.listeners=function(e){var t,r=this._events;return r&&(t=r[e])?"function"==typeof t?[t.listener||t]:function(e){for(var t=new Array(e.length),r=0;r<t.length;++r)t[r]=e[r].listener||e[r];return t}(t):[]},Be.listenerCount=function(e,t){return"function"==typeof e.listenerCount?e.listenerCount(t):Ke.call(e,t)},Be.prototype.listenerCount=Ke,Be.prototype.eventNames=function(){return this._eventsCount>0?Reflect.ownKeys(this._events):[]},Ue="function"==typeof Object.create?function(e,t){e.super_=t,e.prototype=Object.create(t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}})}:function(e,t){e.super_=t;var r=function(){};r.prototype=t.prototype,e.prototype=new r,e.prototype.constructor=e};var Ye=/%[sdj%]/g;function qe(e){if(!it(e)){for(var t=[],r=0;r<arguments.length;r++)t.push(Qe(arguments[r]));return t.join(" ")}r=1;for(var n=arguments,i=n.length,a=String(e).replace(Ye,(function(e){if("%%"===e)return"%";if(r>=i)return e;switch(e){case"%s":return String(n[r++]);case"%d":return Number(n[r++]);case"%j":try{return JSON.stringify(n[r++])}catch(e){return"[Circular]"}default:return e}})),o=n[r];r<i;o=n[++r])nt(o)||!st(o)?a+=" "+o:a+=" "+Qe(o);return a}function ze(e,t){if(at(n.process))return function(){return ze(e,t).apply(this,arguments)};if(!0===F.noDeprecation)return e;var r=!1;return function(){if(!r){if(F.throwDeprecation)throw new Error(t);F.traceDeprecation?console.trace(t):console.error(t),r=!0}return e.apply(this,arguments)}}var Ge,We={};function Qe(e,t){var r={seen:[],stylize:Ze};return arguments.length>=3&&(r.depth=arguments[2]),arguments.length>=4&&(r.colors=arguments[3]),rt(t)?r.showHidden=t:t&&function(e,t){if(!t||!st(t))return e;var r=Object.keys(t),n=r.length;for(;n--;)e[r[n]]=t[r[n]]}(r,t),at(r.showHidden)&&(r.showHidden=!1),at(r.depth)&&(r.depth=2),at(r.colors)&&(r.colors=!1),at(r.customInspect)&&(r.customInspect=!0),r.colors&&(r.stylize=Xe),Je(r,e,r.depth)}function Xe(e,t){var r=Qe.styles[t];return r?"["+Qe.colors[r][0]+"m"+e+"["+Qe.colors[r][1]+"m":e}function Ze(e,t){return e}function Je(e,t,r){if(e.customInspect&&t&&lt(t.inspect)&&t.inspect!==Qe&&(!t.constructor||t.constructor.prototype!==t)){var n=t.inspect(r,e);return it(n)||(n=Je(e,n,r)),n}var i=function(e,t){if(at(t))return e.stylize("undefined","undefined");if(it(t)){var r="'"+JSON.stringify(t).replace(/^"|"$/g,"").replace(/'/g,"\\'").replace(/\\"/g,'"')+"'";return e.stylize(r,"string")}if(n=t,"number"==typeof n)return e.stylize(""+t,"number");var n;if(rt(t))return e.stylize(""+t,"boolean");if(nt(t))return e.stylize("null","null")}(e,t);if(i)return i;var a=Object.keys(t),o=function(e){var t={};return e.forEach((function(e,r){t[e]=!0})),t}(a);if(e.showHidden&&(a=Object.getOwnPropertyNames(t)),ut(t)&&(a.indexOf("message")>=0||a.indexOf("description")>=0))return et(t);if(0===a.length){if(lt(t)){var s=t.name?": "+t.name:"";return e.stylize("[Function"+s+"]","special")}if(ot(t))return e.stylize(RegExp.prototype.toString.call(t),"regexp");if(ct(t))return e.stylize(Date.prototype.toString.call(t),"date");if(ut(t))return et(t)}var c,u,l="",h=!1,d=["{","}"];(c=t,Array.isArray(c)&&(h=!0,d=["[","]"]),lt(t))&&(l=" [Function"+(t.name?": "+t.name:"")+"]");return ot(t)&&(l=" "+RegExp.prototype.toString.call(t)),ct(t)&&(l=" "+Date.prototype.toUTCString.call(t)),ut(t)&&(l=" "+et(t)),0!==a.length||h&&0!=t.length?r<0?ot(t)?e.stylize(RegExp.prototype.toString.call(t),"regexp"):e.stylize("[Object]","special"):(e.seen.push(t),u=h?function(e,t,r,n,i){for(var a=[],o=0,s=t.length;o<s;++o)dt(t,String(o))?a.push(tt(e,t,r,n,String(o),!0)):a.push("");return i.forEach((function(i){i.match(/^\d+$/)||a.push(tt(e,t,r,n,i,!0))})),a}(e,t,r,o,a):a.map((function(n){return tt(e,t,r,o,n,h)})),e.seen.pop(),function(e,t,r){var n=e.reduce((function(e,t){return t.indexOf("\n"),e+t.replace(/\u001b\[\d\d?m/g,"").length+1}),0);if(n>60)return r[0]+(""===t?"":t+"\n ")+" "+e.join(",\n  ")+" "+r[1];return r[0]+t+" "+e.join(", ")+" "+r[1]}(u,l,d)):d[0]+l+d[1]}function et(e){return"["+Error.prototype.toString.call(e)+"]"}function tt(e,t,r,n,i,a){var o,s,c;if((c=Object.getOwnPropertyDescriptor(t,i)||{value:t[i]}).get?s=c.set?e.stylize("[Getter/Setter]","special"):e.stylize("[Getter]","special"):c.set&&(s=e.stylize("[Setter]","special")),dt(n,i)||(o="["+i+"]"),s||(e.seen.indexOf(c.value)<0?(s=nt(r)?Je(e,c.value,null):Je(e,c.value,r-1)).indexOf("\n")>-1&&(s=a?s.split("\n").map((function(e){return"  "+e})).join("\n").substr(2):"\n"+s.split("\n").map((function(e){return"   "+e})).join("\n")):s=e.stylize("[Circular]","special")),at(o)){if(a&&i.match(/^\d+$/))return s;(o=JSON.stringify(""+i)).match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)?(o=o.substr(1,o.length-2),o=e.stylize(o,"name")):(o=o.replace(/'/g,"\\'").replace(/\\"/g,'"').replace(/(^"|"$)/g,"'"),o=e.stylize(o,"string"))}return o+": "+s}function rt(e){return"boolean"==typeof e}function nt(e){return null===e}function it(e){return"string"==typeof e}function at(e){return void 0===e}function ot(e){return st(e)&&"[object RegExp]"===ht(e)}function st(e){return"object"==typeof e&&null!==e}function ct(e){return st(e)&&"[object Date]"===ht(e)}function ut(e){return st(e)&&("[object Error]"===ht(e)||e instanceof Error)}function lt(e){return"function"==typeof e}function ht(e){return Object.prototype.toString.call(e)}function dt(e,t){return Object.prototype.hasOwnProperty.call(e,t)}function ft(){this.head=null,this.tail=null,this.length=0}Qe.colors={bold:[1,22],italic:[3,23],underline:[4,24],inverse:[7,27],white:[37,39],grey:[90,39],black:[30,39],blue:[34,39],cyan:[36,39],green:[32,39],magenta:[35,39],red:[31,39],yellow:[33,39]},Qe.styles={special:"cyan",number:"yellow",boolean:"yellow",undefined:"grey",null:"bold",string:"green",date:"magenta",regexp:"red"},ft.prototype.push=function(e){var t={data:e,next:null};this.length>0?this.tail.next=t:this.head=t,this.tail=t,++this.length},ft.prototype.unshift=function(e){var t={data:e,next:this.head};0===this.length&&(this.tail=t),this.head=t,++this.length},ft.prototype.shift=function(){if(0!==this.length){var e=this.head.data;return 1===this.length?this.head=this.tail=null:this.head=this.head.next,--this.length,e}},ft.prototype.clear=function(){this.head=this.tail=null,this.length=0},ft.prototype.join=function(e){if(0===this.length)return"";for(var t=this.head,r=""+t.data;t=t.next;)r+=e+t.data;return r},ft.prototype.concat=function(e){if(0===this.length)return Z.alloc(0);if(1===this.length)return this.head.data;for(var t=Z.allocUnsafe(e>>>0),r=this.head,n=0;r;)r.data.copy(t,n),n+=r.data.length,r=r.next;return t};var pt=Z.isEncoding||function(e){switch(e&&e.toLowerCase()){case"hex":case"utf8":case"utf-8":case"ascii":case"binary":case"base64":case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":case"raw":return!0;default:return!1}};function gt(e){switch(this.encoding=(e||"utf8").toLowerCase().replace(/[-_]/,""),function(e){if(e&&!pt(e))throw new Error("Unknown encoding: "+e)}(e),this.encoding){case"utf8":this.surrogateSize=3;break;case"ucs2":case"utf16le":this.surrogateSize=2,this.detectIncompleteChar=mt;break;case"base64":this.surrogateSize=3,this.detectIncompleteChar=vt;break;default:return void(this.write=yt)}this.charBuffer=new Z(6),this.charReceived=0,this.charLength=0}function yt(e){return e.toString(this.encoding)}function mt(e){this.charReceived=e.length%2,this.charLength=this.charReceived?2:0}function vt(e){this.charReceived=e.length%3,this.charLength=this.charReceived?3:0}gt.prototype.write=function(e){for(var t="";this.charLength;){var r=e.length>=this.charLength-this.charReceived?this.charLength-this.charReceived:e.length;if(e.copy(this.charBuffer,this.charReceived,0,r),this.charReceived+=r,this.charReceived<this.charLength)return"";if(e=e.slice(r,e.length),!((i=(t=this.charBuffer.slice(0,this.charLength).toString(this.encoding)).charCodeAt(t.length-1))>=55296&&i<=56319)){if(this.charReceived=this.charLength=0,0===e.length)return t;break}this.charLength+=this.surrogateSize,t=""}this.detectIncompleteChar(e);var n=e.length;this.charLength&&(e.copy(this.charBuffer,0,e.length-this.charReceived,n),n-=this.charReceived);var i;n=(t+=e.toString(this.encoding,0,n)).length-1;if((i=t.charCodeAt(n))>=55296&&i<=56319){var a=this.surrogateSize;return this.charLength+=a,this.charReceived+=a,this.charBuffer.copy(this.charBuffer,a,0,a),e.copy(this.charBuffer,0,0,a),t.substring(0,n)}return t},gt.prototype.detectIncompleteChar=function(e){for(var t=e.length>=3?3:e.length;t>0;t--){var r=e[e.length-t];if(1==t&&r>>5==6){this.charLength=2;break}if(t<=2&&r>>4==14){this.charLength=3;break}if(t<=3&&r>>3==30){this.charLength=4;break}}this.charReceived=t},gt.prototype.end=function(e){var t="";if(e&&e.length&&(t=this.write(e)),this.charReceived){var r=this.charReceived,n=this.charBuffer,i=this.encoding;t+=n.slice(0,r).toString(i)}return t};var bt=Object.freeze({__proto__:null,StringDecoder:gt});At.ReadableState=Et;var wt=function(e){if(at(Ge)&&(Ge=F.env.NODE_DEBUG||""),e=e.toUpperCase(),!We[e])if(new RegExp("\\b"+e+"\\b","i").test(Ge)){We[e]=function(){var t=qe.apply(null,arguments);console.error("%s %d: %s",e,0,t)}}else We[e]=function(){};return We[e]}("stream");function Et(e,t){e=e||{},this.objectMode=!!e.objectMode,t instanceof Qt&&(this.objectMode=this.objectMode||!!e.readableObjectMode);var r=e.highWaterMark,n=this.objectMode?16:16384;this.highWaterMark=r||0===r?r:n,this.highWaterMark=~~this.highWaterMark,this.buffer=new ft,this.length=0,this.pipes=null,this.pipesCount=0,this.flowing=null,this.ended=!1,this.endEmitted=!1,this.reading=!1,this.sync=!0,this.needReadable=!1,this.emittedReadable=!1,this.readableListening=!1,this.resumeScheduled=!1,this.defaultEncoding=e.defaultEncoding||"utf8",this.ranOut=!1,this.awaitDrain=0,this.readingMore=!1,this.decoder=null,this.encoding=null,e.encoding&&(this.decoder=new gt(e.encoding),this.encoding=e.encoding)}function At(e){if(!(this instanceof At))return new At(e);this._readableState=new Et(e,this),this.readable=!0,e&&"function"==typeof e.read&&(this._read=e.read),Be.call(this)}function Tt(e,t,r,n,i){var a=function(e,t){var r=null;Z.isBuffer(t)||"string"==typeof t||null==t||e.objectMode||(r=new TypeError("Invalid non-string/buffer chunk"));return r}(t,r);if(a)e.emit("error",a);else if(null===r)t.reading=!1,function(e,t){if(t.ended)return;if(t.decoder){var r=t.decoder.end();r&&r.length&&(t.buffer.push(r),t.length+=t.objectMode?1:r.length)}t.ended=!0,Ot(e)}(e,t);else if(t.objectMode||r&&r.length>0)if(t.ended&&!i){var o=new Error("stream.push() after EOF");e.emit("error",o)}else if(t.endEmitted&&i){var s=new Error("stream.unshift() after end event");e.emit("error",s)}else{var c;!t.decoder||i||n||(r=t.decoder.write(r),c=!t.objectMode&&0===r.length),i||(t.reading=!1),c||(t.flowing&&0===t.length&&!t.sync?(e.emit("data",r),e.read(0)):(t.length+=t.objectMode?1:r.length,i?t.buffer.unshift(r):t.buffer.push(r),t.needReadable&&Ot(e))),function(e,t){t.readingMore||(t.readingMore=!0,g(xt,e,t))}(e,t)}else i||(t.reading=!1);return function(e){return!e.ended&&(e.needReadable||e.length<e.highWaterMark||0===e.length)}(t)}Ue(At,Be),At.prototype.push=function(e,t){var r=this._readableState;return r.objectMode||"string"!=typeof e||(t=t||r.defaultEncoding)!==r.encoding&&(e=Z.from(e,t),t=""),Tt(this,r,e,t,!1)},At.prototype.unshift=function(e){return Tt(this,this._readableState,e,"",!0)},At.prototype.isPaused=function(){return!1===this._readableState.flowing},At.prototype.setEncoding=function(e){return this._readableState.decoder=new gt(e),this._readableState.encoding=e,this};var _t=8388608;function Ct(e,t){return e<=0||0===t.length&&t.ended?0:t.objectMode?1:e!=e?t.flowing&&t.length?t.buffer.head.data.length:t.length:(e>t.highWaterMark&&(t.highWaterMark=function(e){return e>=_t?e=_t:(e--,e|=e>>>1,e|=e>>>2,e|=e>>>4,e|=e>>>8,e|=e>>>16,e++),e}(e)),e<=t.length?e:t.ended?t.length:(t.needReadable=!0,0))}function Ot(e){var t=e._readableState;t.needReadable=!1,t.emittedReadable||(wt("emitReadable",t.flowing),t.emittedReadable=!0,t.sync?g(Dt,e):Dt(e))}function Dt(e){wt("emit readable"),e.emit("readable"),St(e)}function xt(e,t){for(var r=t.length;!t.reading&&!t.flowing&&!t.ended&&t.length<t.highWaterMark&&(wt("maybeReadMore read 0"),e.read(0),r!==t.length);)r=t.length;t.readingMore=!1}function Rt(e){wt("readable nexttick read 0"),e.read(0)}function Ft(e,t){t.reading||(wt("resume read 0"),e.read(0)),t.resumeScheduled=!1,t.awaitDrain=0,e.emit("resume"),St(e),t.flowing&&!t.reading&&e.read(0)}function St(e){var t=e._readableState;for(wt("flow",t.flowing);t.flowing&&null!==e.read(););}function Nt(e,t){return 0===t.length?null:(t.objectMode?r=t.buffer.shift():!e||e>=t.length?(r=t.decoder?t.buffer.join(""):1===t.buffer.length?t.buffer.head.data:t.buffer.concat(t.length),t.buffer.clear()):r=function(e,t,r){var n;e<t.head.data.length?(n=t.head.data.slice(0,e),t.head.data=t.head.data.slice(e)):n=e===t.head.data.length?t.shift():r?function(e,t){var r=t.head,n=1,i=r.data;e-=i.length;for(;r=r.next;){var a=r.data,o=e>a.length?a.length:e;if(o===a.length?i+=a:i+=a.slice(0,e),0===(e-=o)){o===a.length?(++n,r.next?t.head=r.next:t.head=t.tail=null):(t.head=r,r.data=a.slice(o));break}++n}return t.length-=n,i}(e,t):function(e,t){var r=Z.allocUnsafe(e),n=t.head,i=1;n.data.copy(r),e-=n.data.length;for(;n=n.next;){var a=n.data,o=e>a.length?a.length:e;if(a.copy(r,r.length-e,0,o),0===(e-=o)){o===a.length?(++i,n.next?t.head=n.next:t.head=t.tail=null):(t.head=n,n.data=a.slice(o));break}++i}return t.length-=i,r}(e,t);return n}(e,t.buffer,t.decoder),r);var r}function Lt(e){var t=e._readableState;if(t.length>0)throw new Error('"endReadable()" called on non-empty stream');t.endEmitted||(t.ended=!0,g(kt,t,e))}function kt(e,t){e.endEmitted||0!==e.length||(e.endEmitted=!0,t.readable=!1,t.emit("end"))}function It(e,t){for(var r=0,n=e.length;r<n;r++)if(e[r]===t)return r;return-1}function Ut(){}function Pt(e,t,r){this.chunk=e,this.encoding=t,this.callback=r,this.next=null}function jt(e,t){Object.defineProperty(this,"buffer",{get:ze((function(){return this.getBuffer()}),"_writableState.buffer is deprecated. Use _writableState.getBuffer instead.")}),e=e||{},this.objectMode=!!e.objectMode,t instanceof Qt&&(this.objectMode=this.objectMode||!!e.writableObjectMode);var r=e.highWaterMark,n=this.objectMode?16:16384;this.highWaterMark=r||0===r?r:n,this.highWaterMark=~~this.highWaterMark,this.needDrain=!1,this.ending=!1,this.ended=!1,this.finished=!1;var i=!1===e.decodeStrings;this.decodeStrings=!i,this.defaultEncoding=e.defaultEncoding||"utf8",this.length=0,this.writing=!1,this.corked=0,this.sync=!0,this.bufferProcessing=!1,this.onwrite=function(e){!function(e,t){var r=e._writableState,n=r.sync,i=r.writecb;if(function(e){e.writing=!1,e.writecb=null,e.length-=e.writelen,e.writelen=0}(r),t)!function(e,t,r,n,i){--t.pendingcb,r?g(i,n):i(n);e._writableState.errorEmitted=!0,e.emit("error",n)}(e,r,n,t,i);else{var a=Kt(r);a||r.corked||r.bufferProcessing||!r.bufferedRequest||$t(e,r),n?g(Mt,e,r,a,i):Mt(e,r,a,i)}}(t,e)},this.writecb=null,this.writelen=0,this.bufferedRequest=null,this.lastBufferedRequest=null,this.pendingcb=0,this.prefinished=!1,this.errorEmitted=!1,this.bufferedRequestCount=0,this.corkedRequestsFree=new qt(this)}function Bt(e){if(!(this instanceof Bt||this instanceof Qt))return new Bt(e);this._writableState=new jt(e,this),this.writable=!0,e&&("function"==typeof e.write&&(this._write=e.write),"function"==typeof e.writev&&(this._writev=e.writev)),Be.call(this)}function Vt(e,t,r,n,i,a,o){t.writelen=n,t.writecb=o,t.writing=!0,t.sync=!0,r?e._writev(i,t.onwrite):e._write(i,a,t.onwrite),t.sync=!1}function Mt(e,t,r,n){r||function(e,t){0===t.length&&t.needDrain&&(t.needDrain=!1,e.emit("drain"))}(e,t),t.pendingcb--,n(),Yt(e,t)}function $t(e,t){t.bufferProcessing=!0;var r=t.bufferedRequest;if(e._writev&&r&&r.next){var n=t.bufferedRequestCount,i=new Array(n),a=t.corkedRequestsFree;a.entry=r;for(var o=0;r;)i[o]=r,r=r.next,o+=1;Vt(e,t,!0,t.length,i,"",a.finish),t.pendingcb++,t.lastBufferedRequest=null,a.next?(t.corkedRequestsFree=a.next,a.next=null):t.corkedRequestsFree=new qt(t)}else{for(;r;){var s=r.chunk,c=r.encoding,u=r.callback;if(Vt(e,t,!1,t.objectMode?1:s.length,s,c,u),r=r.next,t.writing)break}null===r&&(t.lastBufferedRequest=null)}t.bufferedRequestCount=0,t.bufferedRequest=r,t.bufferProcessing=!1}function Kt(e){return e.ending&&0===e.length&&null===e.bufferedRequest&&!e.finished&&!e.writing}function Ht(e,t){t.prefinished||(t.prefinished=!0,e.emit("prefinish"))}function Yt(e,t){var r=Kt(t);return r&&(0===t.pendingcb?(Ht(e,t),t.finished=!0,e.emit("finish")):Ht(e,t)),r}function qt(e){var t=this;this.next=null,this.entry=null,this.finish=function(r){var n=t.entry;for(t.entry=null;n;){var i=n.callback;e.pendingcb--,i(r),n=n.next}e.corkedRequestsFree?e.corkedRequestsFree.next=t:e.corkedRequestsFree=t}}At.prototype.read=function(e){wt("read",e),e=parseInt(e,10);var t=this._readableState,r=e;if(0!==e&&(t.emittedReadable=!1),0===e&&t.needReadable&&(t.length>=t.highWaterMark||t.ended))return wt("read: emitReadable",t.length,t.ended),0===t.length&&t.ended?Lt(this):Ot(this),null;if(0===(e=Ct(e,t))&&t.ended)return 0===t.length&&Lt(this),null;var n,i=t.needReadable;return wt("need readable",i),(0===t.length||t.length-e<t.highWaterMark)&&wt("length less than watermark",i=!0),t.ended||t.reading?wt("reading or ended",i=!1):i&&(wt("do read"),t.reading=!0,t.sync=!0,0===t.length&&(t.needReadable=!0),this._read(t.highWaterMark),t.sync=!1,t.reading||(e=Ct(r,t))),null===(n=e>0?Nt(e,t):null)?(t.needReadable=!0,e=0):t.length-=e,0===t.length&&(t.ended||(t.needReadable=!0),r!==e&&t.ended&&Lt(this)),null!==n&&this.emit("data",n),n},At.prototype._read=function(e){this.emit("error",new Error("not implemented"))},At.prototype.pipe=function(e,t){var r=this,n=this._readableState;switch(n.pipesCount){case 0:n.pipes=e;break;case 1:n.pipes=[n.pipes,e];break;default:n.pipes.push(e)}n.pipesCount+=1,wt("pipe count=%d opts=%j",n.pipesCount,t);var i=!t||!1!==t.end?o:u;function a(e){wt("onunpipe"),e===r&&u()}function o(){wt("onend"),e.end()}n.endEmitted?g(i):r.once("end",i),e.on("unpipe",a);var s=function(e){return function(){var t=e._readableState;wt("pipeOnDrain",t.awaitDrain),t.awaitDrain&&t.awaitDrain--,0===t.awaitDrain&&e.listeners("data").length&&(t.flowing=!0,St(e))}}(r);e.on("drain",s);var c=!1;function u(){wt("cleanup"),e.removeListener("close",f),e.removeListener("finish",p),e.removeListener("drain",s),e.removeListener("error",d),e.removeListener("unpipe",a),r.removeListener("end",o),r.removeListener("end",u),r.removeListener("data",h),c=!0,!n.awaitDrain||e._writableState&&!e._writableState.needDrain||s()}var l=!1;function h(t){wt("ondata"),l=!1,!1!==e.write(t)||l||((1===n.pipesCount&&n.pipes===e||n.pipesCount>1&&-1!==It(n.pipes,e))&&!c&&(wt("false write response, pause",r._readableState.awaitDrain),r._readableState.awaitDrain++,l=!0),r.pause())}function d(t){var r;wt("onerror",t),y(),e.removeListener("error",d),0===(r="error",e.listeners(r).length)&&e.emit("error",t)}function f(){e.removeListener("finish",p),y()}function p(){wt("onfinish"),e.removeListener("close",f),y()}function y(){wt("unpipe"),r.unpipe(e)}return r.on("data",h),function(e,t,r){if("function"==typeof e.prependListener)return e.prependListener(t,r);e._events&&e._events[t]?Array.isArray(e._events[t])?e._events[t].unshift(r):e._events[t]=[r,e._events[t]]:e.on(t,r)}(e,"error",d),e.once("close",f),e.once("finish",p),e.emit("pipe",r),n.flowing||(wt("pipe resume"),r.resume()),e},At.prototype.unpipe=function(e){var t=this._readableState;if(0===t.pipesCount)return this;if(1===t.pipesCount)return e&&e!==t.pipes||(e||(e=t.pipes),t.pipes=null,t.pipesCount=0,t.flowing=!1,e&&e.emit("unpipe",this)),this;if(!e){var r=t.pipes,n=t.pipesCount;t.pipes=null,t.pipesCount=0,t.flowing=!1;for(var i=0;i<n;i++)r[i].emit("unpipe",this);return this}var a=It(t.pipes,e);return-1===a||(t.pipes.splice(a,1),t.pipesCount-=1,1===t.pipesCount&&(t.pipes=t.pipes[0]),e.emit("unpipe",this)),this},At.prototype.on=function(e,t){var r=Be.prototype.on.call(this,e,t);if("data"===e)!1!==this._readableState.flowing&&this.resume();else if("readable"===e){var n=this._readableState;n.endEmitted||n.readableListening||(n.readableListening=n.needReadable=!0,n.emittedReadable=!1,n.reading?n.length&&Ot(this):g(Rt,this))}return r},At.prototype.addListener=At.prototype.on,At.prototype.resume=function(){var e=this._readableState;return e.flowing||(wt("resume"),e.flowing=!0,function(e,t){t.resumeScheduled||(t.resumeScheduled=!0,g(Ft,e,t))}(this,e)),this},At.prototype.pause=function(){return wt("call pause flowing=%j",this._readableState.flowing),!1!==this._readableState.flowing&&(wt("pause"),this._readableState.flowing=!1,this.emit("pause")),this},At.prototype.wrap=function(e){var t=this._readableState,r=!1,n=this;for(var i in e.on("end",(function(){if(wt("wrapped end"),t.decoder&&!t.ended){var e=t.decoder.end();e&&e.length&&n.push(e)}n.push(null)})),e.on("data",(function(i){(wt("wrapped data"),t.decoder&&(i=t.decoder.write(i)),t.objectMode&&null==i)||(t.objectMode||i&&i.length)&&(n.push(i)||(r=!0,e.pause()))})),e)void 0===this[i]&&"function"==typeof e[i]&&(this[i]=function(t){return function(){return e[t].apply(e,arguments)}}(i));return function(e,t){for(var r=0,n=e.length;r<n;r++)t(e[r],r)}(["error","close","destroy","pause","resume"],(function(t){e.on(t,n.emit.bind(n,t))})),n._read=function(t){wt("wrapped _read",t),r&&(r=!1,e.resume())},n},At._fromList=Nt,Bt.WritableState=jt,Ue(Bt,Be),jt.prototype.getBuffer=function(){for(var e=this.bufferedRequest,t=[];e;)t.push(e),e=e.next;return t},Bt.prototype.pipe=function(){this.emit("error",new Error("Cannot pipe, not readable"))},Bt.prototype.write=function(e,t,r){var n=this._writableState,i=!1;return"function"==typeof t&&(r=t,t=null),Z.isBuffer(e)?t="buffer":t||(t=n.defaultEncoding),"function"!=typeof r&&(r=Ut),n.ended?function(e,t){var r=new Error("write after end");e.emit("error",r),g(t,r)}(this,r):function(e,t,r,n){var i=!0,a=!1;return null===r?a=new TypeError("May not write null values to stream"):Z.isBuffer(r)||"string"==typeof r||void 0===r||t.objectMode||(a=new TypeError("Invalid non-string/buffer chunk")),a&&(e.emit("error",a),g(n,a),i=!1),i}(this,n,e,r)&&(n.pendingcb++,i=function(e,t,r,n,i){r=function(e,t,r){e.objectMode||!1===e.decodeStrings||"string"!=typeof t||(t=Z.from(t,r));return t}(t,r,n),Z.isBuffer(r)&&(n="buffer");var a=t.objectMode?1:r.length;t.length+=a;var o=t.length<t.highWaterMark;o||(t.needDrain=!0);if(t.writing||t.corked){var s=t.lastBufferedRequest;t.lastBufferedRequest=new Pt(r,n,i),s?s.next=t.lastBufferedRequest:t.bufferedRequest=t.lastBufferedRequest,t.bufferedRequestCount+=1}else Vt(e,t,!1,a,r,n,i);return o}(this,n,e,t,r)),i},Bt.prototype.cork=function(){this._writableState.corked++},Bt.prototype.uncork=function(){var e=this._writableState;e.corked&&(e.corked--,e.writing||e.corked||e.finished||e.bufferProcessing||!e.bufferedRequest||$t(this,e))},Bt.prototype.setDefaultEncoding=function(e){if("string"==typeof e&&(e=e.toLowerCase()),!(["hex","utf8","utf-8","ascii","binary","base64","ucs2","ucs-2","utf16le","utf-16le","raw"].indexOf((e+"").toLowerCase())>-1))throw new TypeError("Unknown encoding: "+e);return this._writableState.defaultEncoding=e,this},Bt.prototype._write=function(e,t,r){r(new Error("not implemented"))},Bt.prototype._writev=null,Bt.prototype.end=function(e,t,r){var n=this._writableState;"function"==typeof e?(r=e,e=null,t=null):"function"==typeof t&&(r=t,t=null),null!=e&&this.write(e,t),n.corked&&(n.corked=1,this.uncork()),n.ending||n.finished||function(e,t,r){t.ending=!0,Yt(e,t),r&&(t.finished?g(r):e.once("finish",r));t.ended=!0,e.writable=!1}(this,n,r)},Ue(Qt,At);for(var zt=Object.keys(Bt.prototype),Gt=0;Gt<zt.length;Gt++){var Wt=zt[Gt];Qt.prototype[Wt]||(Qt.prototype[Wt]=Bt.prototype[Wt])}function Qt(e){if(!(this instanceof Qt))return new Qt(e);At.call(this,e),Bt.call(this,e),e&&!1===e.readable&&(this.readable=!1),e&&!1===e.writable&&(this.writable=!1),this.allowHalfOpen=!0,e&&!1===e.allowHalfOpen&&(this.allowHalfOpen=!1),this.once("end",Xt)}function Xt(){this.allowHalfOpen||this._writableState.ended||g(Zt,this)}function Zt(e){e.end()}function Jt(e){this.afterTransform=function(t,r){return function(e,t,r){var n=e._transformState;n.transforming=!1;var i=n.writecb;if(!i)return e.emit("error",new Error("no writecb in Transform class"));n.writechunk=null,n.writecb=null,null!=r&&e.push(r);i(t);var a=e._readableState;a.reading=!1,(a.needReadable||a.length<a.highWaterMark)&&e._read(a.highWaterMark)}(e,t,r)},this.needTransform=!1,this.transforming=!1,this.writecb=null,this.writechunk=null,this.writeencoding=null}function er(e){if(!(this instanceof er))return new er(e);Qt.call(this,e),this._transformState=new Jt(this);var t=this;this._readableState.needReadable=!0,this._readableState.sync=!1,e&&("function"==typeof e.transform&&(this._transform=e.transform),"function"==typeof e.flush&&(this._flush=e.flush)),this.once("prefinish",(function(){"function"==typeof this._flush?this._flush((function(e){tr(t,e)})):tr(t)}))}function tr(e,t){if(t)return e.emit("error",t);var r=e._writableState,n=e._transformState;if(r.length)throw new Error("Calling transform done when ws.length != 0");if(n.transforming)throw new Error("Calling transform done when still transforming");return e.push(null)}function rr(e){if(!(this instanceof rr))return new rr(e);er.call(this,e)}function nr(){Be.call(this)}Ue(er,Qt),er.prototype.push=function(e,t){return this._transformState.needTransform=!1,Qt.prototype.push.call(this,e,t)},er.prototype._transform=function(e,t,r){throw new Error("Not implemented")},er.prototype._write=function(e,t,r){var n=this._transformState;if(n.writecb=r,n.writechunk=e,n.writeencoding=t,!n.transforming){var i=this._readableState;(n.needTransform||i.needReadable||i.length<i.highWaterMark)&&this._read(i.highWaterMark)}},er.prototype._read=function(e){var t=this._transformState;null!==t.writechunk&&t.writecb&&!t.transforming?(t.transforming=!0,this._transform(t.writechunk,t.writeencoding,t.afterTransform)):t.needTransform=!0},Ue(rr,er),rr.prototype._transform=function(e,t,r){r(null,e)},Ue(nr,Be),nr.Readable=At,nr.Writable=Bt,nr.Duplex=Qt,nr.Transform=er,nr.PassThrough=rr,nr.Stream=nr,nr.prototype.pipe=function(e,t){var r=this;function n(t){e.writable&&!1===e.write(t)&&r.pause&&r.pause()}function i(){r.readable&&r.resume&&r.resume()}r.on("data",n),e.on("drain",i),e._isStdio||t&&!1===t.end||(r.on("end",o),r.on("close",s));var a=!1;function o(){a||(a=!0,e.end())}function s(){a||(a=!0,"function"==typeof e.destroy&&e.destroy())}function c(e){if(u(),0===Be.listenerCount(this,"error"))throw e}function u(){r.removeListener("data",n),e.removeListener("drain",i),r.removeListener("end",o),r.removeListener("close",s),r.removeListener("error",c),e.removeListener("error",c),r.removeListener("end",u),r.removeListener("close",u),e.removeListener("close",u)}return r.on("error",c),e.on("error",c),r.on("end",u),r.on("close",u),e.on("close",u),e.emit("pipe",r),e};var ir=r(Object.freeze({__proto__:null,Duplex:Qt,PassThrough:rr,Readable:At,Stream:nr,Transform:er,Writable:Bt,default:nr})),ar=r(bt);!function(e){e.parser=function(e,t){return new n(e,t)},e.SAXParser=n,e.SAXStream=a,e.createStream=function(e,t){return new a(e,t)},e.MAX_BUFFER_LENGTH=65536;var t,r=["comment","sgmlDecl","textNode","tagName","doctype","procInstName","procInstBody","entity","attribName","attribValue","cdata","script"];function n(t,i){if(!(this instanceof n))return new n(t,i);var a=this;!function(e){for(var t=0,n=r.length;t<n;t++)e[r[t]]=""}(a),a.q=a.c="",a.bufferCheckPosition=e.MAX_BUFFER_LENGTH,a.opt=i||{},a.opt.lowercase=a.opt.lowercase||a.opt.lowercasetags,a.looseCase=a.opt.lowercase?"toLowerCase":"toUpperCase",a.tags=[],a.closed=a.closedRoot=a.sawRoot=!1,a.tag=a.error=null,a.strict=!!t,a.noscript=!(!t&&!a.opt.noscript),a.state=T.BEGIN,a.strictEntities=a.opt.strictEntities,a.ENTITIES=a.strictEntities?Object.create(e.XML_ENTITIES):Object.create(e.ENTITIES),a.attribList=[],a.opt.xmlns&&(a.ns=Object.create(l)),void 0===a.opt.unquotedAttributeValues&&(a.opt.unquotedAttributeValues=!t),a.trackPosition=!1!==a.opt.position,a.trackPosition&&(a.position=a.line=a.column=0),C(a,"onready")}e.EVENTS=["text","processinginstruction","sgmldeclaration","doctype","comment","opentagstart","attribute","opentag","closetag","opencdata","cdata","closecdata","error","end","ready","script","opennamespace","closenamespace"],Object.create||(Object.create=function(e){function t(){}return t.prototype=e,new t}),Object.keys||(Object.keys=function(e){var t=[];for(var r in e)e.hasOwnProperty(r)&&t.push(r);return t}),n.prototype={end:function(){F(this)},write:function(t){var n=this;if(this.error)throw this.error;if(n.closed)return R(n,"Cannot write after close. Assign an onready handler.");if(null===t)return F(n);"object"==typeof t&&(t=t.toString());for(var i=0,a="";a=B(t,i++),n.c=a,a;)switch(n.trackPosition&&(n.position++,"\n"===a?(n.line++,n.column=0):n.column++),n.state){case T.BEGIN:if(n.state=T.BEGIN_WHITESPACE,"\ufeff"===a)continue;j(n,a);continue;case T.BEGIN_WHITESPACE:j(n,a);continue;case T.TEXT:if(n.sawRoot&&!n.closedRoot){for(var c=i-1;a&&"<"!==a&&"&"!==a;)(a=B(t,i++))&&n.trackPosition&&(n.position++,"\n"===a?(n.line++,n.column=0):n.column++);n.textNode+=t.substring(c,i-1)}"<"!==a||n.sawRoot&&n.closedRoot&&!n.strict?(g(a)||n.sawRoot&&!n.closedRoot||S(n,"Text data outside of root node."),"&"===a?n.state=T.TEXT_ENTITY:n.textNode+=a):(n.state=T.OPEN_WAKA,n.startTagPosition=n.position);continue;case T.SCRIPT:"<"===a?n.state=T.SCRIPT_ENDING:n.script+=a;continue;case T.SCRIPT_ENDING:"/"===a?n.state=T.CLOSE_TAG:(n.script+="<"+a,n.state=T.SCRIPT);continue;case T.OPEN_WAKA:if("!"===a)n.state=T.SGML_DECL,n.sgmlDecl="";else if(g(a));else if(v(h,a))n.state=T.OPEN_TAG,n.tagName=a;else if("/"===a)n.state=T.CLOSE_TAG,n.tagName="";else if("?"===a)n.state=T.PROC_INST,n.procInstName=n.procInstBody="";else{if(S(n,"Unencoded <"),n.startTagPosition+1<n.position){var u=n.position-n.startTagPosition;a=new Array(u).join(" ")+a}n.textNode+="<"+a,n.state=T.TEXT}continue;case T.SGML_DECL:if(n.sgmlDecl+a==="--"){n.state=T.COMMENT,n.comment="",n.sgmlDecl="";continue}n.doctype&&!0!==n.doctype&&n.sgmlDecl?(n.state=T.DOCTYPE_DTD,n.doctype+="<!"+n.sgmlDecl+a,n.sgmlDecl=""):(n.sgmlDecl+a).toUpperCase()===o?(O(n,"onopencdata"),n.state=T.CDATA,n.sgmlDecl="",n.cdata=""):(n.sgmlDecl+a).toUpperCase()===s?(n.state=T.DOCTYPE,(n.doctype||n.sawRoot)&&S(n,"Inappropriately located doctype declaration"),n.doctype="",n.sgmlDecl=""):">"===a?(O(n,"onsgmldeclaration",n.sgmlDecl),n.sgmlDecl="",n.state=T.TEXT):y(a)?(n.state=T.SGML_DECL_QUOTED,n.sgmlDecl+=a):n.sgmlDecl+=a;continue;case T.SGML_DECL_QUOTED:a===n.q&&(n.state=T.SGML_DECL,n.q=""),n.sgmlDecl+=a;continue;case T.DOCTYPE:">"===a?(n.state=T.TEXT,O(n,"ondoctype",n.doctype),n.doctype=!0):(n.doctype+=a,"["===a?n.state=T.DOCTYPE_DTD:y(a)&&(n.state=T.DOCTYPE_QUOTED,n.q=a));continue;case T.DOCTYPE_QUOTED:n.doctype+=a,a===n.q&&(n.q="",n.state=T.DOCTYPE);continue;case T.DOCTYPE_DTD:"]"===a?(n.doctype+=a,n.state=T.DOCTYPE):"<"===a?(n.state=T.OPEN_WAKA,n.startTagPosition=n.position):y(a)?(n.doctype+=a,n.state=T.DOCTYPE_DTD_QUOTED,n.q=a):n.doctype+=a;continue;case T.DOCTYPE_DTD_QUOTED:n.doctype+=a,a===n.q&&(n.state=T.DOCTYPE_DTD,n.q="");continue;case T.COMMENT:"-"===a?n.state=T.COMMENT_ENDING:n.comment+=a;continue;case T.COMMENT_ENDING:"-"===a?(n.state=T.COMMENT_ENDED,n.comment=x(n.opt,n.comment),n.comment&&O(n,"oncomment",n.comment),n.comment=""):(n.comment+="-"+a,n.state=T.COMMENT);continue;case T.COMMENT_ENDED:">"!==a?(S(n,"Malformed comment"),n.comment+="--"+a,n.state=T.COMMENT):n.doctype&&!0!==n.doctype?n.state=T.DOCTYPE_DTD:n.state=T.TEXT;continue;case T.CDATA:"]"===a?n.state=T.CDATA_ENDING:n.cdata+=a;continue;case T.CDATA_ENDING:"]"===a?n.state=T.CDATA_ENDING_2:(n.cdata+="]"+a,n.state=T.CDATA);continue;case T.CDATA_ENDING_2:">"===a?(n.cdata&&O(n,"oncdata",n.cdata),O(n,"onclosecdata"),n.cdata="",n.state=T.TEXT):"]"===a?n.cdata+="]":(n.cdata+="]]"+a,n.state=T.CDATA);continue;case T.PROC_INST:"?"===a?n.state=T.PROC_INST_ENDING:g(a)?n.state=T.PROC_INST_BODY:n.procInstName+=a;continue;case T.PROC_INST_BODY:if(!n.procInstBody&&g(a))continue;"?"===a?n.state=T.PROC_INST_ENDING:n.procInstBody+=a;continue;case T.PROC_INST_ENDING:">"===a?(O(n,"onprocessinginstruction",{name:n.procInstName,body:n.procInstBody}),n.procInstName=n.procInstBody="",n.state=T.TEXT):(n.procInstBody+="?"+a,n.state=T.PROC_INST_BODY);continue;case T.OPEN_TAG:v(d,a)?n.tagName+=a:(N(n),">"===a?I(n):"/"===a?n.state=T.OPEN_TAG_SLASH:(g(a)||S(n,"Invalid character in tag name"),n.state=T.ATTRIB));continue;case T.OPEN_TAG_SLASH:">"===a?(I(n,!0),U(n)):(S(n,"Forward-slash in opening tag not followed by >"),n.state=T.ATTRIB);continue;case T.ATTRIB:if(g(a))continue;">"===a?I(n):"/"===a?n.state=T.OPEN_TAG_SLASH:v(h,a)?(n.attribName=a,n.attribValue="",n.state=T.ATTRIB_NAME):S(n,"Invalid attribute name");continue;case T.ATTRIB_NAME:"="===a?n.state=T.ATTRIB_VALUE:">"===a?(S(n,"Attribute without value"),n.attribValue=n.attribName,k(n),I(n)):g(a)?n.state=T.ATTRIB_NAME_SAW_WHITE:v(d,a)?n.attribName+=a:S(n,"Invalid attribute name");continue;case T.ATTRIB_NAME_SAW_WHITE:if("="===a)n.state=T.ATTRIB_VALUE;else{if(g(a))continue;S(n,"Attribute without value"),n.tag.attributes[n.attribName]="",n.attribValue="",O(n,"onattribute",{name:n.attribName,value:""}),n.attribName="",">"===a?I(n):v(h,a)?(n.attribName=a,n.state=T.ATTRIB_NAME):(S(n,"Invalid attribute name"),n.state=T.ATTRIB)}continue;case T.ATTRIB_VALUE:if(g(a))continue;y(a)?(n.q=a,n.state=T.ATTRIB_VALUE_QUOTED):(n.opt.unquotedAttributeValues||R(n,"Unquoted attribute value"),n.state=T.ATTRIB_VALUE_UNQUOTED,n.attribValue=a);continue;case T.ATTRIB_VALUE_QUOTED:if(a!==n.q){"&"===a?n.state=T.ATTRIB_VALUE_ENTITY_Q:n.attribValue+=a;continue}k(n),n.q="",n.state=T.ATTRIB_VALUE_CLOSED;continue;case T.ATTRIB_VALUE_CLOSED:g(a)?n.state=T.ATTRIB:">"===a?I(n):"/"===a?n.state=T.OPEN_TAG_SLASH:v(h,a)?(S(n,"No whitespace between attributes"),n.attribName=a,n.attribValue="",n.state=T.ATTRIB_NAME):S(n,"Invalid attribute name");continue;case T.ATTRIB_VALUE_UNQUOTED:if(!m(a)){"&"===a?n.state=T.ATTRIB_VALUE_ENTITY_U:n.attribValue+=a;continue}k(n),">"===a?I(n):n.state=T.ATTRIB;continue;case T.CLOSE_TAG:if(n.tagName)">"===a?U(n):v(d,a)?n.tagName+=a:n.script?(n.script+="</"+n.tagName,n.tagName="",n.state=T.SCRIPT):(g(a)||S(n,"Invalid tagname in closing tag"),n.state=T.CLOSE_TAG_SAW_WHITE);else{if(g(a))continue;b(h,a)?n.script?(n.script+="</"+a,n.state=T.SCRIPT):S(n,"Invalid tagname in closing tag."):n.tagName=a}continue;case T.CLOSE_TAG_SAW_WHITE:if(g(a))continue;">"===a?U(n):S(n,"Invalid characters in closing tag");continue;case T.TEXT_ENTITY:case T.ATTRIB_VALUE_ENTITY_Q:case T.ATTRIB_VALUE_ENTITY_U:var l,w;switch(n.state){case T.TEXT_ENTITY:l=T.TEXT,w="textNode";break;case T.ATTRIB_VALUE_ENTITY_Q:l=T.ATTRIB_VALUE_QUOTED,w="attribValue";break;case T.ATTRIB_VALUE_ENTITY_U:l=T.ATTRIB_VALUE_UNQUOTED,w="attribValue"}if(";"===a){var E=P(n);n.opt.unparsedEntities&&!Object.values(e.XML_ENTITIES).includes(E)?(n.entity="",n.state=l,n.write(E)):(n[w]+=E,n.entity="",n.state=l)}else v(n.entity.length?p:f,a)?n.entity+=a:(S(n,"Invalid character in entity name"),n[w]+="&"+n.entity+a,n.entity="",n.state=l);continue;default:throw new Error(n,"Unknown state: "+n.state)}return n.position>=n.bufferCheckPosition&&function(t){for(var n=Math.max(e.MAX_BUFFER_LENGTH,10),i=0,a=0,o=r.length;a<o;a++){var s=t[r[a]].length;if(s>n)switch(r[a]){case"textNode":D(t);break;case"cdata":O(t,"oncdata",t.cdata),t.cdata="";break;case"script":O(t,"onscript",t.script),t.script="";break;default:R(t,"Max buffer length exceeded: "+r[a])}i=Math.max(i,s)}var c=e.MAX_BUFFER_LENGTH-i;t.bufferCheckPosition=c+t.position}(n),n}
-/*! http://mths.be/fromcodepoint v0.1.0 by @mathias */,resume:function(){return this.error=null,this},close:function(){return this.write(null)},flush:function(){var e;D(e=this),""!==e.cdata&&(O(e,"oncdata",e.cdata),e.cdata=""),""!==e.script&&(O(e,"onscript",e.script),e.script="")}};try{t=ir.Stream}catch(e){t=function(){}}t||(t=function(){});var i=e.EVENTS.filter((function(e){return"error"!==e&&"end"!==e}));function a(e,r){if(!(this instanceof a))return new a(e,r);t.apply(this),this._parser=new n(e,r),this.writable=!0,this.readable=!0;var o=this;this._parser.onend=function(){o.emit("end")},this._parser.onerror=function(e){o.emit("error",e),o._parser.error=null},this._decoder=null,i.forEach((function(e){Object.defineProperty(o,"on"+e,{get:function(){return o._parser["on"+e]},set:function(t){if(!t)return o.removeAllListeners(e),o._parser["on"+e]=t,t;o.on(e,t)},enumerable:!0,configurable:!1})}))}a.prototype=Object.create(t.prototype,{constructor:{value:a}}),a.prototype.write=function(e){if("function"==typeof Z.isBuffer&&Z.isBuffer(e)){if(!this._decoder){var t=ar.StringDecoder;this._decoder=new t("utf8")}e=this._decoder.write(e)}return this._parser.write(e.toString()),this.emit("data",e),!0},a.prototype.end=function(e){return e&&e.length&&this.write(e),this._parser.end(),!0},a.prototype.on=function(e,r){var n=this;return n._parser["on"+e]||-1===i.indexOf(e)||(n._parser["on"+e]=function(){var t=1===arguments.length?[arguments[0]]:Array.apply(null,arguments);t.splice(0,0,e),n.emit.apply(n,t)}),t.prototype.on.call(n,e,r)};var o="[CDATA[",s="DOCTYPE",c="http://www.w3.org/XML/1998/namespace",u="http://www.w3.org/2000/xmlns/",l={xml:c,xmlns:u},h=/[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/,d=/[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040.\d-]/,f=/[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/,p=/[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040.\d-]/;function g(e){return" "===e||"\n"===e||"\r"===e||"\t"===e}function y(e){return'"'===e||"'"===e}function m(e){return">"===e||g(e)}function v(e,t){return e.test(t)}function b(e,t){return!v(e,t)}var w,E,A,T=0;for(var _ in e.STATE={BEGIN:T++,BEGIN_WHITESPACE:T++,TEXT:T++,TEXT_ENTITY:T++,OPEN_WAKA:T++,SGML_DECL:T++,SGML_DECL_QUOTED:T++,DOCTYPE:T++,DOCTYPE_QUOTED:T++,DOCTYPE_DTD:T++,DOCTYPE_DTD_QUOTED:T++,COMMENT_STARTING:T++,COMMENT:T++,COMMENT_ENDING:T++,COMMENT_ENDED:T++,CDATA:T++,CDATA_ENDING:T++,CDATA_ENDING_2:T++,PROC_INST:T++,PROC_INST_BODY:T++,PROC_INST_ENDING:T++,OPEN_TAG:T++,OPEN_TAG_SLASH:T++,ATTRIB:T++,ATTRIB_NAME:T++,ATTRIB_NAME_SAW_WHITE:T++,ATTRIB_VALUE:T++,ATTRIB_VALUE_QUOTED:T++,ATTRIB_VALUE_CLOSED:T++,ATTRIB_VALUE_UNQUOTED:T++,ATTRIB_VALUE_ENTITY_Q:T++,ATTRIB_VALUE_ENTITY_U:T++,CLOSE_TAG:T++,CLOSE_TAG_SAW_WHITE:T++,SCRIPT:T++,SCRIPT_ENDING:T++},e.XML_ENTITIES={amp:"&",gt:">",lt:"<",quot:'"',apos:"'"},e.ENTITIES={amp:"&",gt:">",lt:"<",quot:'"',apos:"'",AElig:198,Aacute:193,Acirc:194,Agrave:192,Aring:197,Atilde:195,Auml:196,Ccedil:199,ETH:208,Eacute:201,Ecirc:202,Egrave:200,Euml:203,Iacute:205,Icirc:206,Igrave:204,Iuml:207,Ntilde:209,Oacute:211,Ocirc:212,Ograve:210,Oslash:216,Otilde:213,Ouml:214,THORN:222,Uacute:218,Ucirc:219,Ugrave:217,Uuml:220,Yacute:221,aacute:225,acirc:226,aelig:230,agrave:224,aring:229,atilde:227,auml:228,ccedil:231,eacute:233,ecirc:234,egrave:232,eth:240,euml:235,iacute:237,icirc:238,igrave:236,iuml:239,ntilde:241,oacute:243,ocirc:244,ograve:242,oslash:248,otilde:245,ouml:246,szlig:223,thorn:254,uacute:250,ucirc:251,ugrave:249,uuml:252,yacute:253,yuml:255,copy:169,reg:174,nbsp:160,iexcl:161,cent:162,pound:163,curren:164,yen:165,brvbar:166,sect:167,uml:168,ordf:170,laquo:171,not:172,shy:173,macr:175,deg:176,plusmn:177,sup1:185,sup2:178,sup3:179,acute:180,micro:181,para:182,middot:183,cedil:184,ordm:186,raquo:187,frac14:188,frac12:189,frac34:190,iquest:191,times:215,divide:247,OElig:338,oelig:339,Scaron:352,scaron:353,Yuml:376,fnof:402,circ:710,tilde:732,Alpha:913,Beta:914,Gamma:915,Delta:916,Epsilon:917,Zeta:918,Eta:919,Theta:920,Iota:921,Kappa:922,Lambda:923,Mu:924,Nu:925,Xi:926,Omicron:927,Pi:928,Rho:929,Sigma:931,Tau:932,Upsilon:933,Phi:934,Chi:935,Psi:936,Omega:937,alpha:945,beta:946,gamma:947,delta:948,epsilon:949,zeta:950,eta:951,theta:952,iota:953,kappa:954,lambda:955,mu:956,nu:957,xi:958,omicron:959,pi:960,rho:961,sigmaf:962,sigma:963,tau:964,upsilon:965,phi:966,chi:967,psi:968,omega:969,thetasym:977,upsih:978,piv:982,ensp:8194,emsp:8195,thinsp:8201,zwnj:8204,zwj:8205,lrm:8206,rlm:8207,ndash:8211,mdash:8212,lsquo:8216,rsquo:8217,sbquo:8218,ldquo:8220,rdquo:8221,bdquo:8222,dagger:8224,Dagger:8225,bull:8226,hellip:8230,permil:8240,prime:8242,Prime:8243,lsaquo:8249,rsaquo:8250,oline:8254,frasl:8260,euro:8364,image:8465,weierp:8472,real:8476,trade:8482,alefsym:8501,larr:8592,uarr:8593,rarr:8594,darr:8595,harr:8596,crarr:8629,lArr:8656,uArr:8657,rArr:8658,dArr:8659,hArr:8660,forall:8704,part:8706,exist:8707,empty:8709,nabla:8711,isin:8712,notin:8713,ni:8715,prod:8719,sum:8721,minus:8722,lowast:8727,radic:8730,prop:8733,infin:8734,ang:8736,and:8743,or:8744,cap:8745,cup:8746,int:8747,there4:8756,sim:8764,cong:8773,asymp:8776,ne:8800,equiv:8801,le:8804,ge:8805,sub:8834,sup:8835,nsub:8836,sube:8838,supe:8839,oplus:8853,otimes:8855,perp:8869,sdot:8901,lceil:8968,rceil:8969,lfloor:8970,rfloor:8971,lang:9001,rang:9002,loz:9674,spades:9824,clubs:9827,hearts:9829,diams:9830},Object.keys(e.ENTITIES).forEach((function(t){var r=e.ENTITIES[t],n="number"==typeof r?String.fromCharCode(r):r;e.ENTITIES[t]=n})),e.STATE)e.STATE[e.STATE[_]]=_;function C(e,t,r){e[t]&&e[t](r)}function O(e,t,r){e.textNode&&D(e),C(e,t,r)}function D(e){e.textNode=x(e.opt,e.textNode),e.textNode&&C(e,"ontext",e.textNode),e.textNode=""}function x(e,t){return e.trim&&(t=t.trim()),e.normalize&&(t=t.replace(/\s+/g," ")),t}function R(e,t){return D(e),e.trackPosition&&(t+="\nLine: "+e.line+"\nColumn: "+e.column+"\nChar: "+e.c),t=new Error(t),e.error=t,C(e,"onerror",t),e}function F(e){return e.sawRoot&&!e.closedRoot&&S(e,"Unclosed root tag"),e.state!==T.BEGIN&&e.state!==T.BEGIN_WHITESPACE&&e.state!==T.TEXT&&R(e,"Unexpected end"),D(e),e.c="",e.closed=!0,C(e,"onend"),n.call(e,e.strict,e.opt),e}function S(e,t){if("object"!=typeof e||!(e instanceof n))throw new Error("bad call to strictFail");e.strict&&R(e,t)}function N(e){e.strict||(e.tagName=e.tagName[e.looseCase]());var t=e.tags[e.tags.length-1]||e,r=e.tag={name:e.tagName,attributes:{}};e.opt.xmlns&&(r.ns=t.ns),e.attribList.length=0,O(e,"onopentagstart",r)}function L(e,t){var r=e.indexOf(":")<0?["",e]:e.split(":"),n=r[0],i=r[1];return t&&"xmlns"===e&&(n="xmlns",i=""),{prefix:n,local:i}}function k(e){if(e.strict||(e.attribName=e.attribName[e.looseCase]()),-1!==e.attribList.indexOf(e.attribName)||e.tag.attributes.hasOwnProperty(e.attribName))e.attribName=e.attribValue="";else{if(e.opt.xmlns){var t=L(e.attribName,!0),r=t.prefix,n=t.local;if("xmlns"===r)if("xml"===n&&e.attribValue!==c)S(e,"xml: prefix must be bound to "+c+"\nActual: "+e.attribValue);else if("xmlns"===n&&e.attribValue!==u)S(e,"xmlns: prefix must be bound to "+u+"\nActual: "+e.attribValue);else{var i=e.tag,a=e.tags[e.tags.length-1]||e;i.ns===a.ns&&(i.ns=Object.create(a.ns)),i.ns[n]=e.attribValue}e.attribList.push([e.attribName,e.attribValue])}else e.tag.attributes[e.attribName]=e.attribValue,O(e,"onattribute",{name:e.attribName,value:e.attribValue});e.attribName=e.attribValue=""}}function I(e,t){if(e.opt.xmlns){var r=e.tag,n=L(e.tagName);r.prefix=n.prefix,r.local=n.local,r.uri=r.ns[n.prefix]||"",r.prefix&&!r.uri&&(S(e,"Unbound namespace prefix: "+JSON.stringify(e.tagName)),r.uri=n.prefix);var i=e.tags[e.tags.length-1]||e;r.ns&&i.ns!==r.ns&&Object.keys(r.ns).forEach((function(t){O(e,"onopennamespace",{prefix:t,uri:r.ns[t]})}));for(var a=0,o=e.attribList.length;a<o;a++){var s=e.attribList[a],c=s[0],u=s[1],l=L(c,!0),h=l.prefix,d=l.local,f=""===h?"":r.ns[h]||"",p={name:c,value:u,prefix:h,local:d,uri:f};h&&"xmlns"!==h&&!f&&(S(e,"Unbound namespace prefix: "+JSON.stringify(h)),p.uri=h),e.tag.attributes[c]=p,O(e,"onattribute",p)}e.attribList.length=0}e.tag.isSelfClosing=!!t,e.sawRoot=!0,e.tags.push(e.tag),O(e,"onopentag",e.tag),t||(e.noscript||"script"!==e.tagName.toLowerCase()?e.state=T.TEXT:e.state=T.SCRIPT,e.tag=null,e.tagName=""),e.attribName=e.attribValue="",e.attribList.length=0}function U(e){if(!e.tagName)return S(e,"Weird empty close tag."),e.textNode+="</>",void(e.state=T.TEXT);if(e.script){if("script"!==e.tagName)return e.script+="</"+e.tagName+">",e.tagName="",void(e.state=T.SCRIPT);O(e,"onscript",e.script),e.script=""}var t=e.tags.length,r=e.tagName;e.strict||(r=r[e.looseCase]());for(var n=r;t--&&e.tags[t].name!==n;)S(e,"Unexpected close tag");if(t<0)return S(e,"Unmatched closing tag: "+e.tagName),e.textNode+="</"+e.tagName+">",void(e.state=T.TEXT);e.tagName=r;for(var i=e.tags.length;i-- >t;){var a=e.tag=e.tags.pop();e.tagName=e.tag.name,O(e,"onclosetag",e.tagName);var o={};for(var s in a.ns)o[s]=a.ns[s];var c=e.tags[e.tags.length-1]||e;e.opt.xmlns&&a.ns!==c.ns&&Object.keys(a.ns).forEach((function(t){var r=a.ns[t];O(e,"onclosenamespace",{prefix:t,uri:r})}))}0===t&&(e.closedRoot=!0),e.tagName=e.attribValue=e.attribName="",e.attribList.length=0,e.state=T.TEXT}function P(e){var t,r=e.entity,n=r.toLowerCase(),i="";return e.ENTITIES[r]?e.ENTITIES[r]:e.ENTITIES[n]?e.ENTITIES[n]:("#"===(r=n).charAt(0)&&("x"===r.charAt(1)?(r=r.slice(2),i=(t=parseInt(r,16)).toString(16)):(r=r.slice(1),i=(t=parseInt(r,10)).toString(10))),r=r.replace(/^0+/,""),isNaN(t)||i.toLowerCase()!==r?(S(e,"Invalid character entity"),"&"+e.entity+";"):String.fromCodePoint(t))}function j(e,t){"<"===t?(e.state=T.OPEN_WAKA,e.startTagPosition=e.position):g(t)||(S(e,"Non-whitespace before first tag."),e.textNode=t,e.state=T.TEXT)}function B(e,t){var r="";return t<e.length&&(r=e.charAt(t)),r}T=e.STATE,String.fromCodePoint||(w=String.fromCharCode,E=Math.floor,A=function(){var e,t,r=[],n=-1,i=arguments.length;if(!i)return"";for(var a="";++n<i;){var o=Number(arguments[n]);if(!isFinite(o)||o<0||o>1114111||E(o)!==o)throw RangeError("Invalid code point: "+o);o<=65535?r.push(o):(e=55296+((o-=65536)>>10),t=o%1024+56320,r.push(e,t)),(n+1===i||r.length>16384)&&(a+=w.apply(null,r),r.length=0)}return a},Object.defineProperty?Object.defineProperty(String,"fromCodePoint",{value:A,configurable:!0,writable:!0}):String.fromCodePoint=A)}(Pe);var or,sr,cr=function(e){return Array.isArray?Array.isArray(e):"[object Array]"===Object.prototype.toString.call(e)},ur=cr,lr={copyOptions:function(e){var t,r={};for(t in e)e.hasOwnProperty(t)&&(r[t]=e[t]);return r},ensureFlagExists:function(e,t){e in t&&"boolean"==typeof t[e]||(t[e]=!1)},ensureSpacesExists:function(e){(!("spaces"in e)||"number"!=typeof e.spaces&&"string"!=typeof e.spaces)&&(e.spaces=0)},ensureAlwaysArrayExists:function(e){"alwaysArray"in e&&("boolean"==typeof e.alwaysArray||ur(e.alwaysArray))||(e.alwaysArray=!1)},ensureKeyExists:function(e,t){e+"Key"in t&&"string"==typeof t[e+"Key"]||(t[e+"Key"]=t.compact?"_"+e:e)},checkFnExists:function(e,t){return e+"Fn"in t}},hr=Pe,dr=lr,fr=cr;function pr(e){var t=Number(e);if(!isNaN(t))return t;var r=e.toLowerCase();return"true"===r||"false"!==r&&e}function gr(e,t){var r;if(or.compact){if(!sr[or[e+"Key"]]&&(fr(or.alwaysArray)?-1!==or.alwaysArray.indexOf(or[e+"Key"]):or.alwaysArray)&&(sr[or[e+"Key"]]=[]),sr[or[e+"Key"]]&&!fr(sr[or[e+"Key"]])&&(sr[or[e+"Key"]]=[sr[or[e+"Key"]]]),e+"Fn"in or&&"string"==typeof t&&(t=or[e+"Fn"](t,sr)),"instruction"===e&&("instructionFn"in or||"instructionNameFn"in or))for(r in t)if(t.hasOwnProperty(r))if("instructionFn"in or)t[r]=or.instructionFn(t[r],r,sr);else{var n=t[r];delete t[r],t[or.instructionNameFn(r,n,sr)]=n}fr(sr[or[e+"Key"]])?sr[or[e+"Key"]].push(t):sr[or[e+"Key"]]=t}else{sr[or.elementsKey]||(sr[or.elementsKey]=[]);var i={};if(i[or.typeKey]=e,"instruction"===e){for(r in t)if(t.hasOwnProperty(r))break;i[or.nameKey]="instructionNameFn"in or?or.instructionNameFn(r,t,sr):r,or.instructionHasAttributes?(i[or.attributesKey]=t[r][or.attributesKey],"instructionFn"in or&&(i[or.attributesKey]=or.instructionFn(i[or.attributesKey],r,sr))):("instructionFn"in or&&(t[r]=or.instructionFn(t[r],r,sr)),i[or.instructionKey]=t[r])}else e+"Fn"in or&&(t=or[e+"Fn"](t,sr)),i[or[e+"Key"]]=t;or.addParent&&(i[or.parentKey]=sr),sr[or.elementsKey].push(i)}}function yr(e){var t;if("attributesFn"in or&&e&&(e=or.attributesFn(e,sr)),(or.trim||"attributeValueFn"in or||"attributeNameFn"in or||or.nativeTypeAttributes)&&e)for(t in e)if(e.hasOwnProperty(t)&&(or.trim&&(e[t]=e[t].trim()),or.nativeTypeAttributes&&(e[t]=pr(e[t])),"attributeValueFn"in or&&(e[t]=or.attributeValueFn(e[t],t,sr)),"attributeNameFn"in or)){var r=e[t];delete e[t],e[or.attributeNameFn(t,e[t],sr)]=r}return e}function mr(e){var t={};if(e.body&&("xml"===e.name.toLowerCase()||or.instructionHasAttributes)){for(var r,n=/([\w:-]+)\s*=\s*(?:"([^"]*)"|'([^']*)'|(\w+))\s*/g;null!==(r=n.exec(e.body));)t[r[1]]=r[2]||r[3]||r[4];t=yr(t)}if("xml"===e.name.toLowerCase()){if(or.ignoreDeclaration)return;sr[or.declarationKey]={},Object.keys(t).length&&(sr[or.declarationKey][or.attributesKey]=t),or.addParent&&(sr[or.declarationKey][or.parentKey]=sr)}else{if(or.ignoreInstruction)return;or.trim&&(e.body=e.body.trim());var i={};or.instructionHasAttributes&&Object.keys(t).length?(i[e.name]={},i[e.name][or.attributesKey]=t):i[e.name]=e.body,gr("instruction",i)}}function vr(e,t){var r;if("object"==typeof e&&(t=e.attributes,e=e.name),t=yr(t),"elementNameFn"in or&&(e=or.elementNameFn(e,sr)),or.compact){var n;if(r={},!or.ignoreAttributes&&t&&Object.keys(t).length)for(n in r[or.attributesKey]={},t)t.hasOwnProperty(n)&&(r[or.attributesKey][n]=t[n]);!(e in sr)&&(fr(or.alwaysArray)?-1!==or.alwaysArray.indexOf(e):or.alwaysArray)&&(sr[e]=[]),sr[e]&&!fr(sr[e])&&(sr[e]=[sr[e]]),fr(sr[e])?sr[e].push(r):sr[e]=r}else sr[or.elementsKey]||(sr[or.elementsKey]=[]),(r={})[or.typeKey]="element",r[or.nameKey]=e,!or.ignoreAttributes&&t&&Object.keys(t).length&&(r[or.attributesKey]=t),or.alwaysChildren&&(r[or.elementsKey]=[]),sr[or.elementsKey].push(r);r[or.parentKey]=sr,sr=r}function br(e){or.ignoreText||(e.trim()||or.captureSpacesBetweenElements)&&(or.trim&&(e=e.trim()),or.nativeType&&(e=pr(e)),or.sanitize&&(e=e.replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;")),gr("text",e))}function wr(e){or.ignoreComment||(or.trim&&(e=e.trim()),gr("comment",e))}function Er(e){var t=sr[or.parentKey];or.addParent||delete sr[or.parentKey],sr=t}function Ar(e){or.ignoreCdata||(or.trim&&(e=e.trim()),gr("cdata",e))}function Tr(e){or.ignoreDoctype||(e=e.replace(/^ /,""),or.trim&&(e=e.trim()),gr("doctype",e))}function _r(e){e.note=e}var Cr=function(e,t){var r=hr.parser(!0,{}),n={};if(sr=n,or=function(e){return or=dr.copyOptions(e),dr.ensureFlagExists("ignoreDeclaration",or),dr.ensureFlagExists("ignoreInstruction",or),dr.ensureFlagExists("ignoreAttributes",or),dr.ensureFlagExists("ignoreText",or),dr.ensureFlagExists("ignoreComment",or),dr.ensureFlagExists("ignoreCdata",or),dr.ensureFlagExists("ignoreDoctype",or),dr.ensureFlagExists("compact",or),dr.ensureFlagExists("alwaysChildren",or),dr.ensureFlagExists("addParent",or),dr.ensureFlagExists("trim",or),dr.ensureFlagExists("nativeType",or),dr.ensureFlagExists("nativeTypeAttributes",or),dr.ensureFlagExists("sanitize",or),dr.ensureFlagExists("instructionHasAttributes",or),dr.ensureFlagExists("captureSpacesBetweenElements",or),dr.ensureAlwaysArrayExists(or),dr.ensureKeyExists("declaration",or),dr.ensureKeyExists("instruction",or),dr.ensureKeyExists("attributes",or),dr.ensureKeyExists("text",or),dr.ensureKeyExists("comment",or),dr.ensureKeyExists("cdata",or),dr.ensureKeyExists("doctype",or),dr.ensureKeyExists("type",or),dr.ensureKeyExists("name",or),dr.ensureKeyExists("elements",or),dr.ensureKeyExists("parent",or),dr.checkFnExists("doctype",or),dr.checkFnExists("instruction",or),dr.checkFnExists("cdata",or),dr.checkFnExists("comment",or),dr.checkFnExists("text",or),dr.checkFnExists("instructionName",or),dr.checkFnExists("elementName",or),dr.checkFnExists("attributeName",or),dr.checkFnExists("attributeValue",or),dr.checkFnExists("attributes",or),or}(t),r.opt={strictEntities:!0},r.onopentag=vr,r.ontext=br,r.oncomment=wr,r.onclosetag=Er,r.onerror=_r,r.oncdata=Ar,r.ondoctype=Tr,r.onprocessinginstruction=mr,r.write(e).close(),n[or.elementsKey]){var i=n[or.elementsKey];delete n[or.elementsKey],n[or.elementsKey]=i,delete n.text}return n},Or=lr,Dr=Cr;var xr,Rr,Fr=lr,Sr=cr;function Nr(e,t,r){return(!r&&e.spaces?"\n":"")+Array(t+1).join(e.spaces)}function Lr(e,t,r){if(t.ignoreAttributes)return"";"attributesFn"in t&&(e=t.attributesFn(e,Rr,xr));var n,i,a,o,s=[];for(n in e)e.hasOwnProperty(n)&&null!==e[n]&&void 0!==e[n]&&(o=t.noQuotesForNativeAttributes&&"string"!=typeof e[n]?"":'"',i=(i=""+e[n]).replace(/"/g,"&quot;"),a="attributeNameFn"in t?t.attributeNameFn(n,i,Rr,xr):n,s.push(t.spaces&&t.indentAttributes?Nr(t,r+1,!1):" "),s.push(a+"="+o+("attributeValueFn"in t?t.attributeValueFn(i,n,Rr,xr):i)+o));return e&&Object.keys(e).length&&t.spaces&&t.indentAttributes&&s.push(Nr(t,r,!1)),s.join("")}function kr(e,t,r){return xr=e,Rr="xml",t.ignoreDeclaration?"":"<?xml"+Lr(e[t.attributesKey],t,r)+"?>"}function Ir(e,t,r){if(t.ignoreInstruction)return"";var n;for(n in e)if(e.hasOwnProperty(n))break;var i="instructionNameFn"in t?t.instructionNameFn(n,e[n],Rr,xr):n;if("object"==typeof e[n])return xr=e,Rr=i,"<?"+i+Lr(e[n][t.attributesKey],t,r)+"?>";var a=e[n]?e[n]:"";return"instructionFn"in t&&(a=t.instructionFn(a,n,Rr,xr)),"<?"+i+(a?" "+a:"")+"?>"}function Ur(e,t){return t.ignoreComment?"":"\x3c!--"+("commentFn"in t?t.commentFn(e,Rr,xr):e)+"--\x3e"}function Pr(e,t){return t.ignoreCdata?"":"<![CDATA["+("cdataFn"in t?t.cdataFn(e,Rr,xr):e.replace("]]>","]]]]><![CDATA[>"))+"]]>"}function jr(e,t){return t.ignoreDoctype?"":"<!DOCTYPE "+("doctypeFn"in t?t.doctypeFn(e,Rr,xr):e)+">"}function Br(e,t){return t.ignoreText?"":(e=(e=(e=""+e).replace(/&amp;/g,"&")).replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;"),"textFn"in t?t.textFn(e,Rr,xr):e)}function Vr(e,t,r,n){return e.reduce((function(e,i){var a=Nr(t,r,n&&!e);switch(i.type){case"element":return e+a+function(e,t,r){xr=e,Rr=e.name;var n=[],i="elementNameFn"in t?t.elementNameFn(e.name,e):e.name;n.push("<"+i),e[t.attributesKey]&&n.push(Lr(e[t.attributesKey],t,r));var a=e[t.elementsKey]&&e[t.elementsKey].length||e[t.attributesKey]&&"preserve"===e[t.attributesKey]["xml:space"];return a||(a="fullTagEmptyElementFn"in t?t.fullTagEmptyElementFn(e.name,e):t.fullTagEmptyElement),a?(n.push(">"),e[t.elementsKey]&&e[t.elementsKey].length&&(n.push(Vr(e[t.elementsKey],t,r+1)),xr=e,Rr=e.name),n.push(t.spaces&&function(e,t){var r;if(e.elements&&e.elements.length)for(r=0;r<e.elements.length;++r)switch(e.elements[r][t.typeKey]){case"text":if(t.indentText)return!0;break;case"cdata":if(t.indentCdata)return!0;break;case"instruction":if(t.indentInstruction)return!0;break;default:return!0}return!1}(e,t)?"\n"+Array(r+1).join(t.spaces):""),n.push("</"+i+">")):n.push("/>"),n.join("")}(i,t,r);case"comment":return e+a+Ur(i[t.commentKey],t);case"doctype":return e+a+jr(i[t.doctypeKey],t);case"cdata":return e+(t.indentCdata?a:"")+Pr(i[t.cdataKey],t);case"text":return e+(t.indentText?a:"")+Br(i[t.textKey],t);case"instruction":var o={};return o[i[t.nameKey]]=i[t.attributesKey]?i:i[t.instructionKey],e+(t.indentInstruction?a:"")+Ir(o,t,r)}}),"")}function Mr(e,t,r){var n;for(n in e)if(e.hasOwnProperty(n))switch(n){case t.parentKey:case t.attributesKey:break;case t.textKey:if(t.indentText||r)return!0;break;case t.cdataKey:if(t.indentCdata||r)return!0;break;case t.instructionKey:if(t.indentInstruction||r)return!0;break;case t.doctypeKey:case t.commentKey:default:return!0}return!1}function $r(e,t,r,n,i){xr=e,Rr=t;var a="elementNameFn"in r?r.elementNameFn(t,e):t;if(null==e||""===e)return"fullTagEmptyElementFn"in r&&r.fullTagEmptyElementFn(t,e)||r.fullTagEmptyElement?"<"+a+"></"+a+">":"<"+a+"/>";var o=[];if(t){if(o.push("<"+a),"object"!=typeof e)return o.push(">"+Br(e,r)+"</"+a+">"),o.join("");e[r.attributesKey]&&o.push(Lr(e[r.attributesKey],r,n));var s=Mr(e,r,!0)||e[r.attributesKey]&&"preserve"===e[r.attributesKey]["xml:space"];if(s||(s="fullTagEmptyElementFn"in r?r.fullTagEmptyElementFn(t,e):r.fullTagEmptyElement),!s)return o.push("/>"),o.join("");o.push(">")}return o.push(Kr(e,r,n+1,!1)),xr=e,Rr=t,t&&o.push((i?Nr(r,n,!1):"")+"</"+a+">"),o.join("")}function Kr(e,t,r,n){var i,a,o,s=[];for(a in e)if(e.hasOwnProperty(a))for(o=Sr(e[a])?e[a]:[e[a]],i=0;i<o.length;++i){switch(a){case t.declarationKey:s.push(kr(o[i],t,r));break;case t.instructionKey:s.push((t.indentInstruction?Nr(t,r,n):"")+Ir(o[i],t,r));break;case t.attributesKey:case t.parentKey:break;case t.textKey:s.push((t.indentText?Nr(t,r,n):"")+Br(o[i],t));break;case t.cdataKey:s.push((t.indentCdata?Nr(t,r,n):"")+Pr(o[i],t));break;case t.doctypeKey:s.push(Nr(t,r,n)+jr(o[i],t));break;case t.commentKey:s.push(Nr(t,r,n)+Ur(o[i],t));break;default:s.push(Nr(t,r,n)+$r(o[i],a,t,r,Mr(o[i],t)))}n=n&&!s.length}return s.join("")}var Hr=function(e,t){t=function(e){var t=Fr.copyOptions(e);return Fr.ensureFlagExists("ignoreDeclaration",t),Fr.ensureFlagExists("ignoreInstruction",t),Fr.ensureFlagExists("ignoreAttributes",t),Fr.ensureFlagExists("ignoreText",t),Fr.ensureFlagExists("ignoreComment",t),Fr.ensureFlagExists("ignoreCdata",t),Fr.ensureFlagExists("ignoreDoctype",t),Fr.ensureFlagExists("compact",t),Fr.ensureFlagExists("indentText",t),Fr.ensureFlagExists("indentCdata",t),Fr.ensureFlagExists("indentAttributes",t),Fr.ensureFlagExists("indentInstruction",t),Fr.ensureFlagExists("fullTagEmptyElement",t),Fr.ensureFlagExists("noQuotesForNativeAttributes",t),Fr.ensureSpacesExists(t),"number"==typeof t.spaces&&(t.spaces=Array(t.spaces+1).join(" ")),Fr.ensureKeyExists("declaration",t),Fr.ensureKeyExists("instruction",t),Fr.ensureKeyExists("attributes",t),Fr.ensureKeyExists("text",t),Fr.ensureKeyExists("comment",t),Fr.ensureKeyExists("cdata",t),Fr.ensureKeyExists("doctype",t),Fr.ensureKeyExists("type",t),Fr.ensureKeyExists("name",t),Fr.ensureKeyExists("elements",t),Fr.checkFnExists("doctype",t),Fr.checkFnExists("instruction",t),Fr.checkFnExists("cdata",t),Fr.checkFnExists("comment",t),Fr.checkFnExists("text",t),Fr.checkFnExists("instructionName",t),Fr.checkFnExists("elementName",t),Fr.checkFnExists("attributeName",t),Fr.checkFnExists("attributeValue",t),Fr.checkFnExists("attributes",t),Fr.checkFnExists("fullTagEmptyElement",t),t}(t);var r=[];return xr=e,Rr="_root_",t.compact?r.push(Kr(e,t,0,!0)):(e[t.declarationKey]&&r.push(kr(e[t.declarationKey],t,0)),e[t.elementsKey]&&e[t.elementsKey].length&&r.push(Vr(e[t.elementsKey],t,0,!r.length))),r.join("")},Yr=Hr,qr=function(e,t){var r,n,i,a;return r=function(e){var t=Or.copyOptions(e);return Or.ensureSpacesExists(t),t}(t),n=Dr(e,r),a="compact"in r&&r.compact?"_parent":"parent",i="addParent"in r&&r.addParent?JSON.stringify(n,(function(e,t){return e===a?"_":t}),r.spaces):JSON.stringify(n,null,r.spaces),i.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")},zr=function(e,t){e instanceof Z&&(e=e.toString());var r=null;if("string"==typeof e)try{r=JSON.parse(e)}catch(e){throw new Error("The JSON structure is invalid")}else r=e;return Yr(r,t)},Gr=t({xml2js:Cr,xml2json:qr,js2xml:Hr,json2xml:zr});const Wr=e=>{const t=Number(e);if(!Number.isNaN(t))return t;const r=e.toLowerCase();return"true"===r||"false"!==r&&e},Qr=(e,t)=>{if(!e&&!t)return!0;if(!e||!t)return!1;const r=e.trim(),n=t.trim();if(Math.abs(r.length-n.length)>1)return!1;const i="/"===r.slice(-1)?r.slice(0,-1):r,a="/"===n.slice(-1)?n.slice(0,-1):n;return e.includes(a)||t.includes(i)},Xr=(e,t)=>{if(!e&&!t)return!0;if(!e||!t)return!1;const r=e.trim(),n=t.trim(),i="/"===r.slice(-1)?r.slice(0,-1):r,a="/"===n.slice(-1)?n.slice(0,-1):n;return e.includes(a)||t.includes(i)},Zr=e=>e.reduce(((e,t)=>({...e,[U[t]]:t})),{}),Jr=e=>Object.entries(e).reduce(((e,[t,r])=>r?{...e,[t]:r}:e),{}),en=(e,t)=>t?{[e]:t}:{},tn=(e,t)=>e?t&&0!==t.length?Object.fromEntries(Object.entries(e).filter((([e])=>!t.includes(e)))):e:{};var rn=Object.freeze({__proto__:null,cleanupFalsy:Jr,conditionalParam:en,excludeHeaders:tn,getDAVAttribute:Zr,urlContains:Xr,urlEquals:Qr});const nn=I("tsdav:request"),an=async e=>{var t;const{url:r,init:n,convertIncoming:i=!0,parseOutgoing:a=!0,fetchOptions:o={}}=e,{headers:s={},body:c,namespace:u,method:l,attributes:h}=n,d=i?Gr.js2xml({_declaration:{_attributes:{version:"1.0",encoding:"utf-8"}},...c,_attributes:h},{compact:!0,spaces:2,elementNameFn:e=>u&&!/^.+:.+/.test(e)?`${u}:${e}`:e}):c,f=await fetch(r,{headers:{"Content-Type":"text/xml;charset=UTF-8",...Jr(s)},body:d,method:l,...o}),p=await f.text();if(!f.ok||!(null===(t=f.headers.get("content-type"))||void 0===t?void 0:t.includes("xml"))||!a)return[{href:f.url,ok:f.ok,status:f.status,statusText:f.statusText,raw:p}];const g=Gr.xml2js(p,{compact:!0,trim:!0,textFn:(e,t)=>{try{const r=t._parent,n=Object.keys(r),i=n[n.length-1],a=r[i];if(a.length>0){a[a.length-1]=Wr(e)}else r[i]=Wr(e)}catch(e){nn(e.stack)}},elementNameFn:e=>e.replace(/^.+:/,"").replace(/([-_]\w)/g,(e=>e[1].toUpperCase())),attributesFn:e=>{const t={...e};return delete t.xmlns,t},ignoreDeclaration:!0});return(Array.isArray(g.multistatus.response)?g.multistatus.response:[g.multistatus.response]).map((e=>{var t,r;if(!e)return{status:f.status,statusText:f.statusText,ok:f.ok};const n=/^\S+\s(?<status>\d+)\s(?<statusText>.+)$/.exec(e.status);return{raw:g,href:e.href,status:(null==n?void 0:n.groups)?Number.parseInt(null==n?void 0:n.groups.status,10):f.status,statusText:null!==(r=null===(t=null==n?void 0:n.groups)||void 0===t?void 0:t.statusText)&&void 0!==r?r:f.statusText,ok:!e.error,error:e.error,responsedescription:e.responsedescription,props:(Array.isArray(e.propstat)?e.propstat:[e.propstat]).reduce(((e,t)=>({...e,...null==t?void 0:t.prop})),{})}}))},on=async e=>{const{url:t,props:r,depth:n,headers:i,headersToExclude:a,fetchOptions:o={}}=e;return an({url:t,init:{method:"PROPFIND",headers:tn(Jr({depth:n,...i}),a),namespace:P.DAV,body:{propfind:{_attributes:Zr([k.CALDAV,k.CALDAV_APPLE,k.CALENDAR_SERVER,k.CARDDAV,k.DAV]),prop:r}}},fetchOptions:o})},sn=async e=>{const{url:t,data:r,headers:n,headersToExclude:i,fetchOptions:a={}}=e;return fetch(t,{method:"PUT",body:r,headers:tn(n,i),...a})},cn=async e=>{const{url:t,data:r,etag:n,headers:i,headersToExclude:a,fetchOptions:o={}}=e;return fetch(t,{method:"PUT",body:r,headers:tn(Jr({"If-Match":n,...i}),a),...o})},un=async e=>{const{url:t,headers:r,etag:n,headersToExclude:i,fetchOptions:a={}}=e;return fetch(t,{method:"DELETE",headers:tn(Jr({"If-Match":n,...r}),i),...a})};var ln=Object.freeze({__proto__:null,createObject:sn,davRequest:an,deleteObject:un,propfind:on,updateObject:cn});function hn(e,t){const r=e=>t.every((t=>e[t]));return Array.isArray(e)?e.every((e=>r(e))):r(e)}const dn=(e,t)=>t.reduce(((t,r)=>e[r]?t:`${t.length?`${t},`:""}${r.toString()}`),""),fn=I("tsdav:collection"),pn=async e=>{const{url:t,body:r,depth:n,defaultNamespace:i=P.DAV,headers:a,headersToExclude:o,fetchOptions:s={}}=e,c=await an({url:t,init:{method:"REPORT",headers:tn(Jr({depth:n,...a}),o),namespace:i,body:r},fetchOptions:s});return 1!==c.length||c[0].raw?c:[]},gn=async e=>{const{url:t,props:r,depth:n,headers:i,headersToExclude:a,fetchOptions:o={}}=e;return an({url:t,init:{method:"MKCOL",headers:tn(Jr({depth:n,...i}),a),namespace:P.DAV,body:r?{mkcol:{set:{prop:r}}}:void 0},fetchOptions:o})},yn=async e=>{var t,r,n,i,a;const{collection:o,headers:s,headersToExclude:c,fetchOptions:u={}}=e;return null!==(a=null===(i=null===(n=null===(r=null===(t=(await on({url:o.url,props:{[`${P.DAV}:supported-report-set`]:{}},depth:"0",headers:tn(s,c),fetchOptions:u}))[0])||void 0===t?void 0:t.props)||void 0===r?void 0:r.supportedReportSet)||void 0===n?void 0:n.supportedReport)||void 0===i?void 0:i.map((e=>Object.keys(e.report)[0])))&&void 0!==a?a:[]},mn=async e=>{var t,r,n;const{collection:i,headers:a,headersToExclude:o,fetchOptions:s={}}=e,c=(await on({url:i.url,props:{[`${P.CALENDAR_SERVER}:getctag`]:{}},depth:"0",headers:tn(a,o),fetchOptions:s})).filter((e=>Xr(i.url,e.href)))[0];if(!c)throw new Error("Collection does not exist on server");return{isDirty:`${i.ctag}`!=`${null===(t=c.props)||void 0===t?void 0:t.getctag}`,newCtag:null===(n=null===(r=c.props)||void 0===r?void 0:r.getctag)||void 0===n?void 0:n.toString()}},vn=e=>{const{url:t,props:r,headers:n,syncLevel:i,syncToken:a,headersToExclude:o,fetchOptions:s}=e;return an({url:t,init:{method:"REPORT",namespace:P.DAV,headers:tn({...n},o),body:{"sync-collection":{_attributes:Zr([k.CALDAV,k.CARDDAV,k.DAV]),"sync-level":i,"sync-token":a,[`${P.DAV}:prop`]:r}}},fetchOptions:s})},bn=async e=>{var t,r,n,i,a,o,s,c,u,l,h;const{collection:d,method:f,headers:p,headersToExclude:g,account:y,detailedResult:m,fetchOptions:v={}}=e,b=["accountType","homeUrl"];if(!y||!hn(y,b)){if(!y)throw new Error("no account for smartCollectionSync");throw new Error(`account must have ${dn(y,b)} before smartCollectionSync`)}const w=null!=f?f:(null===(t=d.reports)||void 0===t?void 0:t.includes("syncCollection"))?"webdav":"basic";if(fn(`smart collection sync with type ${y.accountType} and method ${w}`),"webdav"===w){const e=await vn({url:d.url,props:{[`${P.DAV}:getetag`]:{},[`${"caldav"===y.accountType?P.CALDAV:P.CARDDAV}:${"caldav"===y.accountType?"calendar-data":"address-data"}`]:{},[`${P.DAV}:displayname`]:{}},syncLevel:1,syncToken:d.syncToken,headers:tn(p,g),fetchOptions:v}),t=e.filter((e=>{var t;const r="caldav"===y.accountType?".ics":".vcf";return(null===(t=e.href)||void 0===t?void 0:t.slice(-4))===r})),u=t.filter((e=>404!==e.status)).map((e=>e.href)),l=t.filter((e=>404===e.status)).map((e=>e.href)),h=(u.length&&null!==(n=await(null===(r=null==d?void 0:d.objectMultiGet)||void 0===r?void 0:r.call(d,{url:d.url,props:{[`${P.DAV}:getetag`]:{},[`${"caldav"===y.accountType?P.CALDAV:P.CARDDAV}:${"caldav"===y.accountType?"calendar-data":"address-data"}`]:{}},objectUrls:u,depth:"1",headers:tn(p,g),fetchOptions:v})))&&void 0!==n?n:[]).map((e=>{var t,r,n,i,a,o,s,c,u,l;return{url:null!==(t=e.href)&&void 0!==t?t:"",etag:null===(r=e.props)||void 0===r?void 0:r.getetag,data:"caldav"===(null==y?void 0:y.accountType)?null!==(a=null===(i=null===(n=e.props)||void 0===n?void 0:n.calendarData)||void 0===i?void 0:i._cdata)&&void 0!==a?a:null===(o=e.props)||void 0===o?void 0:o.calendarData:null!==(u=null===(c=null===(s=e.props)||void 0===s?void 0:s.addressData)||void 0===c?void 0:c._cdata)&&void 0!==u?u:null===(l=e.props)||void 0===l?void 0:l.addressData}})),f=null!==(i=d.objects)&&void 0!==i?i:[],b=h.filter((e=>f.every((t=>!Xr(t.url,e.url))))),w=f.reduce(((e,t)=>{const r=h.find((e=>Xr(e.url,t.url)));return r&&r.etag&&r.etag!==t.etag?[...e,r]:e}),[]),E=l.map((e=>({url:e,etag:""}))),A=f.filter((e=>h.some((t=>Xr(e.url,t.url)&&t.etag===e.etag))));return{...d,objects:m?{created:b,updated:w,deleted:E}:[...A,...b,...w],syncToken:null!==(c=null===(s=null===(o=null===(a=e[0])||void 0===a?void 0:a.raw)||void 0===o?void 0:o.multistatus)||void 0===s?void 0:s.syncToken)&&void 0!==c?c:d.syncToken}}if("basic"===w){const{isDirty:e,newCtag:t}=await mn({collection:d,headers:tn(p,g),fetchOptions:v}),r=null!==(u=d.objects)&&void 0!==u?u:[],n=null!==(h=await(null===(l=d.fetchObjects)||void 0===l?void 0:l.call(d,{collection:d,headers:tn(p,g),fetchOptions:v})))&&void 0!==h?h:[],i=n.filter((e=>r.every((t=>!Xr(t.url,e.url))))),a=r.reduce(((e,t)=>{const r=n.find((e=>Xr(e.url,t.url)));return r&&r.etag&&r.etag!==t.etag?[...e,r]:e}),[]),o=r.filter((e=>n.every((t=>!Xr(t.url,e.url))))),s=r.filter((e=>n.some((t=>Xr(e.url,t.url)&&t.etag===e.etag))));if(e)return{...d,objects:m?{created:i,updated:a,deleted:o}:[...s,...i,...a],ctag:t}}return m?{...d,objects:{created:[],updated:[],deleted:[]}}:d};var wn=Object.freeze({__proto__:null,collectionQuery:pn,isCollectionDirty:mn,makeCollection:gn,smartCollectionSync:bn,supportedReportSet:yn,syncCollection:vn});const En=I("tsdav:addressBook"),An=async e=>{const{url:t,props:r,filters:n,depth:i,headers:a,headersToExclude:o,fetchOptions:s={}}=e;return pn({url:t,body:{"addressbook-query":Jr({_attributes:Zr([k.CARDDAV,k.DAV]),[`${P.DAV}:prop`]:r,filter:null!=n?n:{"prop-filter":{_attributes:{name:"FN"}}}})},defaultNamespace:P.CARDDAV,depth:i,headers:tn(a,o),fetchOptions:s})},Tn=async e=>{const{url:t,props:r,objectUrls:n,depth:i,headers:a,headersToExclude:o,fetchOptions:s={}}=e;return pn({url:t,body:{"addressbook-multiget":Jr({_attributes:Zr([k.DAV,k.CARDDAV]),[`${P.DAV}:prop`]:r,[`${P.DAV}:href`]:n})},defaultNamespace:P.CARDDAV,depth:i,headers:tn(a,o),fetchOptions:s})},_n=async e=>{const{account:t,headers:r,props:n,headersToExclude:i,fetchOptions:a={}}=null!=e?e:{},o=["homeUrl","rootUrl"];if(!t||!hn(t,o)){if(!t)throw new Error("no account for fetchAddressBooks");throw new Error(`account must have ${dn(t,o)} before fetchAddressBooks`)}const s=await on({url:t.homeUrl,props:null!=n?n:{[`${P.DAV}:displayname`]:{},[`${P.CALENDAR_SERVER}:getctag`]:{},[`${P.DAV}:resourcetype`]:{},[`${P.DAV}:sync-token`]:{}},depth:"1",headers:tn(r,i),fetchOptions:a});return Promise.all(s.filter((e=>{var t,r;return Object.keys(null!==(r=null===(t=e.props)||void 0===t?void 0:t.resourcetype)&&void 0!==r?r:{}).includes("addressbook")})).map((e=>{var r,n,i,a,o,s,c,u,l;const h=null!==(i=null===(n=null===(r=e.props)||void 0===r?void 0:r.displayname)||void 0===n?void 0:n._cdata)&&void 0!==i?i:null===(a=e.props)||void 0===a?void 0:a.displayname;return En(`Found address book named ${"string"==typeof h?h:""},\n             props: ${JSON.stringify(e.props)}`),{url:new URL(null!==(o=e.href)&&void 0!==o?o:"",null!==(s=t.rootUrl)&&void 0!==s?s:"").href,ctag:null===(c=e.props)||void 0===c?void 0:c.getctag,displayName:"string"==typeof h?h:"",resourcetype:Object.keys(null===(u=e.props)||void 0===u?void 0:u.resourcetype),syncToken:null===(l=e.props)||void 0===l?void 0:l.syncToken}})).map((async e=>({...e,reports:await yn({collection:e,headers:tn(r,i),fetchOptions:a})}))))},Cn=async e=>{const{addressBook:t,headers:r,objectUrls:n,headersToExclude:i,urlFilter:a=e=>e,useMultiGet:o=!0,fetchOptions:s={}}=e;En(`Fetching vcards from ${null==t?void 0:t.url}`);const c=["url"];if(!t||!hn(t,c)){if(!t)throw new Error("cannot fetchVCards for undefined addressBook");throw new Error(`addressBook must have ${dn(t,c)} before fetchVCards`)}const u=(null!=n?n:(await An({url:t.url,props:{[`${P.DAV}:getetag`]:{}},depth:"1",headers:tn(r,i),fetchOptions:s})).map((e=>{var t;return e.ok&&null!==(t=e.href)&&void 0!==t?t:""}))).map((e=>e.startsWith("http")||!e?e:new URL(e,t.url).href)).filter(a).map((e=>new URL(e).pathname));let l=[];return u.length>0&&(l=o?await Tn({url:t.url,props:{[`${P.DAV}:getetag`]:{},[`${P.CARDDAV}:address-data`]:{}},objectUrls:u,depth:"1",headers:tn(r,i),fetchOptions:s}):await An({url:t.url,props:{[`${P.DAV}:getetag`]:{},[`${P.CARDDAV}:address-data`]:{}},depth:"1",headers:tn(r,i),fetchOptions:s})),l.map((e=>{var r,n,i,a,o,s;return{url:new URL(null!==(r=e.href)&&void 0!==r?r:"",t.url).href,etag:null===(n=e.props)||void 0===n?void 0:n.getetag,data:null!==(o=null===(a=null===(i=e.props)||void 0===i?void 0:i.addressData)||void 0===a?void 0:a._cdata)&&void 0!==o?o:null===(s=e.props)||void 0===s?void 0:s.addressData}}))},On=async e=>{const{addressBook:t,vCardString:r,filename:n,headers:i,headersToExclude:a,fetchOptions:o={}}=e;return sn({url:new URL(n,t.url).href,data:r,headers:tn({"content-type":"text/vcard; charset=utf-8","If-None-Match":"*",...i},a),fetchOptions:o})},Dn=async e=>{const{vCard:t,headers:r,headersToExclude:n,fetchOptions:i={}}=e;return cn({url:t.url,data:t.data,etag:t.etag,headers:tn({"content-type":"text/vcard; charset=utf-8",...r},n),fetchOptions:i})},xn=async e=>{const{vCard:t,headers:r,headersToExclude:n,fetchOptions:i={}}=e;return un({url:t.url,etag:t.etag,headers:tn(r,n),fetchOptions:i})};var Rn=Object.freeze({__proto__:null,addressBookMultiGet:Tn,addressBookQuery:An,createVCard:On,deleteVCard:xn,fetchAddressBooks:_n,fetchVCards:Cn,updateVCard:Dn});const Fn=I("tsdav:calendar"),Sn=async e=>{var t,r,n;const{account:i,headers:a,headersToExclude:o,fetchOptions:s={}}=e,c=["principalUrl","rootUrl"];if(!hn(i,c))throw new Error(`account must have ${dn(i,c)} before fetchUserAddresses`);Fn(`Fetch user addresses from ${i.principalUrl}`);const u=(await on({url:i.principalUrl,props:{[`${P.CALDAV}:calendar-user-address-set`]:{}},depth:"0",headers:tn(a,o),fetchOptions:s})).find((e=>Xr(i.principalUrl,e.href)));if(!u||!u.ok)throw new Error("cannot find calendarUserAddresses");const l=(null===(n=null===(r=null===(t=null==u?void 0:u.props)||void 0===t?void 0:t.calendarUserAddressSet)||void 0===r?void 0:r.href)||void 0===n?void 0:n.filter(Boolean))||[];return Fn(`Fetched calendar user addresses ${l}`),l},Nn=async e=>{const{url:t,props:r,filters:n,timezone:i,depth:a,headers:o,headersToExclude:s,fetchOptions:c={}}=e;return pn({url:t,body:{"calendar-query":Jr({_attributes:Zr([k.CALDAV,k.CALENDAR_SERVER,k.CALDAV_APPLE,k.DAV]),[`${P.DAV}:prop`]:r,filter:n,timezone:i})},defaultNamespace:P.CALDAV,depth:a,headers:tn(o,s),fetchOptions:c})},Ln=async e=>{const{url:t,props:r,objectUrls:n,filters:i,timezone:a,depth:o,headers:s,headersToExclude:c,fetchOptions:u={}}=e;return pn({url:t,body:{"calendar-multiget":Jr({_attributes:Zr([k.DAV,k.CALDAV]),[`${P.DAV}:prop`]:r,[`${P.DAV}:href`]:n,filter:i,timezone:a})},defaultNamespace:P.CALDAV,depth:o,headers:tn(s,c),fetchOptions:u})},kn=async e=>{const{url:t,props:r,depth:n,headers:i,headersToExclude:a,fetchOptions:o={}}=e;return an({url:t,init:{method:"MKCALENDAR",headers:tn(Jr({depth:n,...i}),a),namespace:P.DAV,body:{[`${P.CALDAV}:mkcalendar`]:{_attributes:Zr([k.DAV,k.CALDAV,k.CALDAV_APPLE]),set:{prop:r}}}},fetchOptions:o})},In=async e=>{const{headers:t,account:r,props:n,projectedProps:i,headersToExclude:a,fetchOptions:o={}}=null!=e?e:{},s=["homeUrl","rootUrl"];if(!r||!hn(r,s)){if(!r)throw new Error("no account for fetchCalendars");throw new Error(`account must have ${dn(r,s)} before fetchCalendars`)}const c=await on({url:r.homeUrl,props:null!=n?n:{[`${P.CALDAV}:calendar-description`]:{},[`${P.CALDAV}:calendar-timezone`]:{},[`${P.DAV}:displayname`]:{},[`${P.CALDAV_APPLE}:calendar-color`]:{},[`${P.CALENDAR_SERVER}:getctag`]:{},[`${P.DAV}:resourcetype`]:{},[`${P.CALDAV}:supported-calendar-component-set`]:{},[`${P.DAV}:sync-token`]:{}},depth:"1",headers:tn(t,a),fetchOptions:o});return Promise.all(c.filter((e=>{var t,r;return Object.keys(null!==(r=null===(t=e.props)||void 0===t?void 0:t.resourcetype)&&void 0!==r?r:{}).includes("calendar")})).filter((e=>{var t,r,n,i;return(Array.isArray(null===(t=e.props)||void 0===t?void 0:t.supportedCalendarComponentSet.comp)?null===(r=e.props)||void 0===r?void 0:r.supportedCalendarComponentSet.comp.map((e=>e._attributes.name)):[null===(i=null===(n=e.props)||void 0===n?void 0:n.supportedCalendarComponentSet.comp)||void 0===i?void 0:i._attributes.name]).some((e=>Object.values(j).includes(e)))})).map((e=>{var t,n,a,o,s,c,u,l,h,d,f,p,g,y,m,v;const b=null===(t=e.props)||void 0===t?void 0:t.calendarDescription,w=null===(n=e.props)||void 0===n?void 0:n.calendarTimezone;return{description:"string"==typeof b?b:"",timezone:"string"==typeof w?w:"",url:new URL(null!==(a=e.href)&&void 0!==a?a:"",null!==(o=r.rootUrl)&&void 0!==o?o:"").href,ctag:null===(s=e.props)||void 0===s?void 0:s.getctag,calendarColor:null===(c=e.props)||void 0===c?void 0:c.calendarColor,displayName:null!==(l=null===(u=e.props)||void 0===u?void 0:u.displayname._cdata)&&void 0!==l?l:null===(h=e.props)||void 0===h?void 0:h.displayname,components:Array.isArray(null===(d=e.props)||void 0===d?void 0:d.supportedCalendarComponentSet.comp)?null===(f=e.props)||void 0===f?void 0:f.supportedCalendarComponentSet.comp.map((e=>e._attributes.name)):[null===(g=null===(p=e.props)||void 0===p?void 0:p.supportedCalendarComponentSet.comp)||void 0===g?void 0:g._attributes.name],resourcetype:Object.keys(null===(y=e.props)||void 0===y?void 0:y.resourcetype),syncToken:null===(m=e.props)||void 0===m?void 0:m.syncToken,...en("projectedProps",Object.fromEntries(Object.entries(null!==(v=e.props)&&void 0!==v?v:{}).filter((([e])=>null==i?void 0:i[e]))))}})).map((async e=>({...e,reports:await yn({collection:e,headers:tn(t,a),fetchOptions:o})}))))},Un=async e=>{const{calendar:t,objectUrls:r,filters:n,timeRange:i,headers:a,expand:o,urlFilter:s=e=>Boolean(null==e?void 0:e.includes(".ics")),useMultiGet:c=!0,headersToExclude:u,fetchOptions:l={}}=e;if(i){const e=/^\d{4}(-\d\d(-\d\d(T\d\d:\d\d(:\d\d)?(\.\d+)?(([+-]\d\d:\d\d)|Z)?)?)?)?$/i,t=/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(\.\d+)?(([+-]\d\d:\d\d)|Z)?$/i;if(!(e.test(i.start)&&e.test(i.end)||t.test(i.start)&&t.test(i.end)))throw new Error("invalid timeRange format, not in ISO8601")}Fn(`Fetching calendar objects from ${null==t?void 0:t.url}`);const h=["url"];if(!t||!hn(t,h)){if(!t)throw new Error("cannot fetchCalendarObjects for undefined calendar");throw new Error(`calendar must have ${dn(t,h)} before fetchCalendarObjects`)}const d=null!=n?n:[{"comp-filter":{_attributes:{name:"VCALENDAR"},"comp-filter":{_attributes:{name:"VEVENT"},...i?{"time-range":{_attributes:{start:`${new Date(i.start).toISOString().slice(0,19).replace(/[-:.]/g,"")}Z`,end:`${new Date(i.end).toISOString().slice(0,19).replace(/[-:.]/g,"")}Z`}}}:{}}}}],f=(null!=r?r:(await Nn({url:t.url,props:{[`${P.DAV}:getetag`]:{...o&&i?{[`${P.CALDAV}:expand`]:{_attributes:{start:`${new Date(i.start).toISOString().slice(0,19).replace(/[-:.]/g,"")}Z`,end:`${new Date(i.end).toISOString().slice(0,19).replace(/[-:.]/g,"")}Z`}}}:{}}},filters:d,depth:"1",headers:tn(a,u),fetchOptions:l})).map((e=>{var t;return null!==(t=e.href)&&void 0!==t?t:""}))).map((e=>e.startsWith("http")||!e?e:new URL(e,t.url).href)).filter(s).map((e=>new URL(e).pathname));let p=[];return f.length>0&&(p=!c||o?await Nn({url:t.url,props:{[`${P.DAV}:getetag`]:{},[`${P.CALDAV}:calendar-data`]:{...o&&i?{[`${P.CALDAV}:expand`]:{_attributes:{start:`${new Date(i.start).toISOString().slice(0,19).replace(/[-:.]/g,"")}Z`,end:`${new Date(i.end).toISOString().slice(0,19).replace(/[-:.]/g,"")}Z`}}}:{}}},filters:d,depth:"1",headers:tn(a,u),fetchOptions:l}):await Ln({url:t.url,props:{[`${P.DAV}:getetag`]:{},[`${P.CALDAV}:calendar-data`]:{...o&&i?{[`${P.CALDAV}:expand`]:{_attributes:{start:`${new Date(i.start).toISOString().slice(0,19).replace(/[-:.]/g,"")}Z`,end:`${new Date(i.end).toISOString().slice(0,19).replace(/[-:.]/g,"")}Z`}}}:{}}},objectUrls:f,depth:"1",headers:tn(a,u),fetchOptions:l})),p.map((e=>{var r,n,i,a,o,s;return{url:new URL(null!==(r=e.href)&&void 0!==r?r:"",t.url).href,etag:`${null===(n=e.props)||void 0===n?void 0:n.getetag}`,data:null!==(o=null===(a=null===(i=e.props)||void 0===i?void 0:i.calendarData)||void 0===a?void 0:a._cdata)&&void 0!==o?o:null===(s=e.props)||void 0===s?void 0:s.calendarData}}))},Pn=async e=>{const{calendar:t,iCalString:r,filename:n,headers:i,headersToExclude:a,fetchOptions:o={}}=e;return sn({url:new URL(n,t.url).href,data:r,headers:tn({"content-type":"text/calendar; charset=utf-8","If-None-Match":"*",...i},a),fetchOptions:o})},jn=async e=>{const{calendarObject:t,headers:r,headersToExclude:n,fetchOptions:i={}}=e;return cn({url:t.url,data:t.data,etag:t.etag,headers:tn({"content-type":"text/calendar; charset=utf-8",...r},n),fetchOptions:i})},Bn=async e=>{const{calendarObject:t,headers:r,headersToExclude:n,fetchOptions:i={}}=e;return un({url:t.url,etag:t.etag,headers:tn(r,n),fetchOptions:i})},Vn=async e=>{var t;const{oldCalendars:r,account:n,detailedResult:i,headers:a,headersToExclude:o,fetchOptions:s={}}=e;if(!n)throw new Error("Must have account before syncCalendars");const c=null!==(t=null!=r?r:n.calendars)&&void 0!==t?t:[],u=await In({account:n,headers:tn(a,o),fetchOptions:s}),l=u.filter((e=>c.every((t=>!Xr(t.url,e.url)))));Fn(`new calendars: ${l.map((e=>e.displayName))}`);const h=c.reduce(((e,t)=>{const r=u.find((e=>Xr(e.url,t.url)));return r&&(r.syncToken&&`${r.syncToken}`!=`${t.syncToken}`||r.ctag&&`${r.ctag}`!=`${t.ctag}`)?[...e,r]:e}),[]);Fn(`updated calendars: ${h.map((e=>e.displayName))}`);const d=await Promise.all(h.map((async e=>await bn({collection:{...e,objectMultiGet:Ln},method:"webdav",headers:tn(a,o),account:n,fetchOptions:s})))),f=c.filter((e=>u.every((t=>!Xr(t.url,e.url)))));Fn(`deleted calendars: ${f.map((e=>e.displayName))}`);const p=c.filter((e=>u.some((t=>Xr(t.url,e.url)&&(t.syncToken&&`${t.syncToken}`!=`${e.syncToken}`||t.ctag&&`${t.ctag}`!=`${e.ctag}`)))));return i?{created:l,updated:h,deleted:f}:[...p,...l,...d]},Mn=async e=>{const{url:t,timeRange:r,depth:n,headers:i,headersToExclude:a,fetchOptions:o={}}=e;if(!r)throw new Error("timeRange is required");{const e=/^\d{4}(-\d\d(-\d\d(T\d\d:\d\d(:\d\d)?(\.\d+)?(([+-]\d\d:\d\d)|Z)?)?)?)?$/i,t=/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(\.\d+)?(([+-]\d\d:\d\d)|Z)?$/i;if(!(e.test(r.start)&&e.test(r.end)||t.test(r.start)&&t.test(r.end)))throw new Error("invalid timeRange format, not in ISO8601")}return(await pn({url:t,body:{"free-busy-query":Jr({_attributes:Zr([k.CALDAV]),[`${P.CALDAV}:time-range`]:{_attributes:{start:`${new Date(r.start).toISOString().slice(0,19).replace(/[-:.]/g,"")}Z`,end:`${new Date(r.end).toISOString().slice(0,19).replace(/[-:.]/g,"")}Z`}}})},defaultNamespace:P.CALDAV,depth:n,headers:tn(i,a),fetchOptions:o}))[0]};var $n=Object.freeze({__proto__:null,calendarMultiGet:Ln,calendarQuery:Nn,createCalendarObject:Pn,deleteCalendarObject:Bn,fetchCalendarObjects:Un,fetchCalendarUserAddresses:Sn,fetchCalendars:In,freeBusyQuery:Mn,makeCalendar:kn,syncCalendars:Vn,updateCalendarObject:jn});const Kn=I("tsdav:account"),Hn=async e=>{var t,r;Kn("Service discovery...");const{account:n,headers:i,headersToExclude:a,fetchOptions:o={}}=e,s=new URL(n.serverUrl),c=new URL(`/.well-known/${n.accountType}`,s);c.protocol=null!==(t=s.protocol)&&void 0!==t?t:"http";try{const e=await fetch(c.href,{headers:tn(i,a),method:"PROPFIND",redirect:"manual",...o});if(e.status>=300&&e.status<400){const t=e.headers.get("Location");if("string"==typeof t&&t.length){Kn(`Service discovery redirected to ${t}`);const e=new URL(t,s);return e.hostname===c.hostname&&c.port&&!e.port&&(e.port=c.port),e.protocol=null!==(r=s.protocol)&&void 0!==r?r:"http",e.href}}}catch(e){Kn(`Service discovery failed: ${e.stack}`)}return s.href},Yn=async e=>{var t,r,n,i,a;const{account:o,headers:s,headersToExclude:c,fetchOptions:u={}}=e,l=["rootUrl"];if(!hn(o,l))throw new Error(`account must have ${dn(o,l)} before fetchPrincipalUrl`);Kn(`Fetching principal url from path ${o.rootUrl}`);const[h]=await on({url:o.rootUrl,props:{[`${P.DAV}:current-user-principal`]:{}},depth:"0",headers:tn(s,c),fetchOptions:u});if(!h.ok&&(Kn(`Fetch principal url failed: ${h.statusText}`),401===h.status))throw new Error("Invalid credentials");return Kn(`Fetched principal url ${null===(r=null===(t=h.props)||void 0===t?void 0:t.currentUserPrincipal)||void 0===r?void 0:r.href}`),new URL(null!==(a=null===(i=null===(n=h.props)||void 0===n?void 0:n.currentUserPrincipal)||void 0===i?void 0:i.href)&&void 0!==a?a:"",o.rootUrl).href},qn=async e=>{var t,r;const{account:n,headers:i,headersToExclude:a,fetchOptions:o={}}=e,s=["principalUrl","rootUrl"];if(!hn(n,s))throw new Error(`account must have ${dn(n,s)} before fetchHomeUrl`);Kn(`Fetch home url from ${n.principalUrl}`);const c=(await on({url:n.principalUrl,props:"caldav"===n.accountType?{[`${P.CALDAV}:calendar-home-set`]:{}}:{[`${P.CARDDAV}:addressbook-home-set`]:{}},depth:"0",headers:tn(i,a),fetchOptions:o})).find((e=>Xr(n.principalUrl,e.href)));if(!c||!c.ok)throw new Error("cannot find homeUrl");const u=new URL("caldav"===n.accountType?null===(t=null==c?void 0:c.props)||void 0===t?void 0:t.calendarHomeSet.href:null===(r=null==c?void 0:c.props)||void 0===r?void 0:r.addressbookHomeSet.href,n.rootUrl).href;return Kn(`Fetched home url ${u}`),u},zn=async e=>{const{account:t,headers:r,loadCollections:n=!1,loadObjects:i=!1,headersToExclude:a,fetchOptions:o={}}=e,s={...t};return s.rootUrl=await Hn({account:t,headers:tn(r,a),fetchOptions:o}),s.principalUrl=await Yn({account:s,headers:tn(r,a),fetchOptions:o}),s.homeUrl=await qn({account:s,headers:tn(r,a),fetchOptions:o}),(n||i)&&("caldav"===t.accountType?s.calendars=await In({headers:tn(r,a),account:s,fetchOptions:o}):"carddav"===t.accountType&&(s.addressBooks=await _n({headers:tn(r,a),account:s,fetchOptions:o}))),i&&("caldav"===t.accountType&&s.calendars?s.calendars=await Promise.all(s.calendars.map((async e=>({...e,objects:await Un({calendar:e,headers:tn(r,a),fetchOptions:o})})))):"carddav"===t.accountType&&s.addressBooks&&(s.addressBooks=await Promise.all(s.addressBooks.map((async e=>({...e,objects:await Cn({addressBook:e,headers:tn(r,a),fetchOptions:o})})))))),s};var Gn,Wn,Qn=Object.freeze({__proto__:null,createAccount:zn,fetchHomeUrl:qn,fetchPrincipalUrl:Yn,serviceDiscovery:Hn}),Xn={exports:{}};Gn=Xn,Wn=Xn.exports,function(t){var r=Wn,n=Gn&&Gn.exports==r&&Gn,i="object"==typeof e&&e;i.global!==i&&i.window!==i||(t=i);var a=function(e){this.message=e};(a.prototype=new Error).name="InvalidCharacterError";var o=function(e){throw new a(e)},s="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",c=/[\t\n\f\r ]/g,u={encode:function(e){e=String(e),/[^\0-\xFF]/.test(e)&&o("The string to be encoded contains characters outside of the Latin1 range.");for(var t,r,n,i,a=e.length%3,c="",u=-1,l=e.length-a;++u<l;)t=e.charCodeAt(u)<<16,r=e.charCodeAt(++u)<<8,n=e.charCodeAt(++u),c+=s.charAt((i=t+r+n)>>18&63)+s.charAt(i>>12&63)+s.charAt(i>>6&63)+s.charAt(63&i);return 2==a?(t=e.charCodeAt(u)<<8,r=e.charCodeAt(++u),c+=s.charAt((i=t+r)>>10)+s.charAt(i>>4&63)+s.charAt(i<<2&63)+"="):1==a&&(i=e.charCodeAt(u),c+=s.charAt(i>>2)+s.charAt(i<<4&63)+"=="),c},decode:function(e){var t=(e=String(e).replace(c,"")).length;t%4==0&&(t=(e=e.replace(/==?$/,"")).length),(t%4==1||/[^+a-zA-Z0-9/]/.test(e))&&o("Invalid character: the string to be decoded is not correctly encoded.");for(var r,n,i=0,a="",u=-1;++u<t;)n=s.indexOf(e.charAt(u)),r=i%4?64*r+n:n,i++%4&&(a+=String.fromCharCode(255&r>>(-2*i&6)));return a},version:"1.0.0"};if(r&&!r.nodeType)if(n)n.exports=u;else for(var l in u)u.hasOwnProperty(l)&&(r[l]=u[l]);else t.base64=u}(e);var Zn=Xn.exports;const Jn=I("tsdav:authHelper"),ei=(e,t)=>(...r)=>e({...t,...r[0]}),ti=e=>(Jn(`Basic auth token generated: ${Zn.encode(`${e.username}:${e.password}`)}`),{authorization:`Basic ${Zn.encode(`${e.username}:${e.password}`)}`}),ri=async(e,t)=>{const r=["authorizationCode","redirectUrl","clientId","clientSecret","tokenUrl"];if(!hn(e,r))throw new Error(`Oauth credentials missing: ${dn(e,r)}`);const n=new URLSearchParams({grant_type:"authorization_code",code:e.authorizationCode,redirect_uri:e.redirectUrl,client_id:e.clientId,client_secret:e.clientSecret});Jn(e.tokenUrl),Jn(n.toString());const i=await fetch(e.tokenUrl,{method:"POST",body:n.toString(),headers:{"content-length":`${n.toString().length}`,"content-type":"application/x-www-form-urlencoded"},...null!=t?t:{}});if(i.ok){return await i.json()}return Jn(`Fetch Oauth tokens failed: ${await i.text()}`),{}},ni=async(e,t)=>{const r=["refreshToken","clientId","clientSecret","tokenUrl"];if(!hn(e,r))throw new Error(`Oauth credentials missing: ${dn(e,r)}`);const n=new URLSearchParams({client_id:e.clientId,client_secret:e.clientSecret,refresh_token:e.refreshToken,grant_type:"refresh_token"}),i=await fetch(e.tokenUrl,{method:"POST",body:n.toString(),headers:{"Content-Type":"application/x-www-form-urlencoded"},...null!=t?t:{}});if(i.ok){return await i.json()}return Jn(`Refresh access token failed: ${await i.text()}`),{}},ii=async(e,t)=>{var r;Jn("Fetching oauth headers");let n={};return e.refreshToken?(e.refreshToken&&!e.accessToken||Date.now()>(null!==(r=e.expiration)&&void 0!==r?r:0))&&(n=await ni(e,t)):n=await ri(e,t),Jn(`Oauth tokens fetched: ${n.access_token}`),{tokens:n,headers:{authorization:`Bearer ${n.access_token}`}}};var ai=Object.freeze({__proto__:null,defaultParam:ei,fetchOauthTokens:ri,getBasicAuthHeaders:ti,getOauthHeaders:ii,refreshAccessToken:ni});const oi=async e=>{var t;const{serverUrl:r,credentials:n,authMethod:i,defaultAccountType:a,authFunction:o}=e;let s={};switch(i){case"Basic":s=ti(n);break;case"Oauth":s=(await ii(n)).headers;break;case"Digest":s={Authorization:`Digest ${n.digestString}`};break;case"Custom":s=null!==(t=await(null==o?void 0:o(n)))&&void 0!==t?t:{};break;default:throw new Error("Invalid auth method")}const c=a?await zn({account:{serverUrl:r,credentials:n,accountType:a},headers:s}):void 0,u=ei(sn,{url:r,headers:s}),l=ei(cn,{headers:s,url:r}),h=ei(un,{headers:s,url:r}),d=ei(on,{headers:s}),f=ei(pn,{headers:s}),p=ei(gn,{headers:s}),g=ei(vn,{headers:s}),y=ei(yn,{headers:s}),m=ei(mn,{headers:s}),v=ei(bn,{headers:s,account:c}),b=ei(Nn,{headers:s}),w=ei(Ln,{headers:s}),E=ei(kn,{headers:s}),A=ei(In,{headers:s,account:c}),T=ei(Sn,{headers:s,account:c}),_=ei(Un,{headers:s}),C=ei(Pn,{headers:s}),O=ei(jn,{headers:s}),D=ei(Bn,{headers:s}),x=ei(Vn,{account:c,headers:s}),R=ei(An,{headers:s}),F=ei(Tn,{headers:s});return{davRequest:async e=>{const{init:t,...r}=e,{headers:n,...i}=t;return an({...r,init:{...i,headers:{...s,...n}}})},propfind:d,createAccount:async e=>{const{account:t,headers:i,loadCollections:a,loadObjects:o}=e;return zn({account:{serverUrl:r,credentials:n,...t},headers:{...s,...i},loadCollections:a,loadObjects:o})},createObject:u,updateObject:l,deleteObject:h,calendarQuery:b,addressBookQuery:R,collectionQuery:f,makeCollection:p,calendarMultiGet:w,makeCalendar:E,syncCollection:g,supportedReportSet:y,isCollectionDirty:m,smartCollectionSync:v,fetchCalendars:A,fetchCalendarUserAddresses:T,fetchCalendarObjects:_,createCalendarObject:C,updateCalendarObject:O,deleteCalendarObject:D,syncCalendars:x,fetchAddressBooks:ei(_n,{account:c,headers:s}),addressBookMultiGet:F,fetchVCards:ei(Cn,{headers:s}),createVCard:ei(On,{headers:s}),updateVCard:ei(Dn,{headers:s}),deleteVCard:ei(xn,{headers:s})}};class si{constructor(e){var t,r,n;this.serverUrl=e.serverUrl,this.credentials=e.credentials,this.authMethod=null!==(t=e.authMethod)&&void 0!==t?t:"Basic",this.accountType=null!==(r=e.defaultAccountType)&&void 0!==r?r:"caldav",this.authFunction=e.authFunction,this.fetchOptions=null!==(n=e.fetchOptions)&&void 0!==n?n:{}}async login(){var e;switch(this.authMethod){case"Basic":this.authHeaders=ti(this.credentials);break;case"Oauth":this.authHeaders=(await ii(this.credentials,this.fetchOptions)).headers;break;case"Digest":this.authHeaders={Authorization:`Digest ${this.credentials.digestString}`};break;case"Custom":this.authHeaders=await(null===(e=this.authFunction)||void 0===e?void 0:e.call(this,this.credentials));break;default:throw new Error("Invalid auth method")}this.account=this.accountType?await zn({account:{serverUrl:this.serverUrl,credentials:this.credentials,accountType:this.accountType},headers:this.authHeaders,fetchOptions:this.fetchOptions}):void 0}async davRequest(e){const{init:t,...r}=e,{headers:n,...i}=t;return an({...r,init:{...i,headers:{...this.authHeaders,...n}},fetchOptions:this.fetchOptions})}async createObject(...e){return ei(sn,{url:this.serverUrl,headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async updateObject(...e){return ei(cn,{url:this.serverUrl,headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async deleteObject(...e){return ei(un,{url:this.serverUrl,headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async propfind(...e){return ei(on,{headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async createAccount(e){const{account:t,headers:r,loadCollections:n,loadObjects:i,fetchOptions:a}=e;return zn({account:{serverUrl:this.serverUrl,credentials:this.credentials,...t},headers:{...this.authHeaders,...r},loadCollections:n,loadObjects:i,fetchOptions:null!=a?a:this.fetchOptions})}async collectionQuery(...e){return ei(pn,{headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async makeCollection(...e){return ei(gn,{headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async syncCollection(...e){return ei(vn,{headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async supportedReportSet(...e){return ei(yn,{headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async isCollectionDirty(...e){return ei(mn,{headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async smartCollectionSync(...e){return ei(bn,{headers:this.authHeaders,fetchOptions:this.fetchOptions,account:this.account})(e[0])}async calendarQuery(...e){return ei(Nn,{headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async makeCalendar(...e){return ei(kn,{headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async calendarMultiGet(...e){return ei(Ln,{headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async fetchCalendars(...e){return ei(In,{headers:this.authHeaders,account:this.account,fetchOptions:this.fetchOptions})(null==e?void 0:e[0])}async fetchCalendarUserAddresses(...e){return ei(Sn,{headers:this.authHeaders,account:this.account,fetchOptions:this.fetchOptions})(null==e?void 0:e[0])}async fetchCalendarObjects(...e){return ei(Un,{headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async createCalendarObject(...e){return ei(Pn,{headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async updateCalendarObject(...e){return ei(jn,{headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async deleteCalendarObject(...e){return ei(Bn,{headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async syncCalendars(...e){return ei(Vn,{headers:this.authHeaders,account:this.account,fetchOptions:this.fetchOptions})(e[0])}async addressBookQuery(...e){return ei(An,{headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async addressBookMultiGet(...e){return ei(Tn,{headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async fetchAddressBooks(...e){return ei(_n,{headers:this.authHeaders,account:this.account,fetchOptions:this.fetchOptions})(null==e?void 0:e[0])}async fetchVCards(...e){return ei(Cn,{headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async createVCard(...e){return ei(On,{headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async updateVCard(...e){return ei(Dn,{headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async deleteVCard(...e){return ei(xn,{headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}}var ci={DAVNamespace:k,DAVNamespaceShort:P,DAVAttributeMap:U,...Object.freeze({__proto__:null,DAVClient:si,createDAVClient:oi}),...ln,...wn,...Qn,...Rn,...$n,...ai,...rn};export{U as DAVAttributeMap,si as DAVClient,k as DAVNamespace,P as DAVNamespaceShort,An as addressBookQuery,Ln as calendarMultiGet,Nn as calendarQuery,Jr as cleanupFalsy,pn as collectionQuery,zn as createAccount,Pn as createCalendarObject,oi as createDAVClient,sn as createObject,On as createVCard,an as davRequest,ci as default,Bn as deleteCalendarObject,un as deleteObject,xn as deleteVCard,_n as fetchAddressBooks,Un as fetchCalendarObjects,Sn as fetchCalendarUserAddresses,In as fetchCalendars,ri as fetchOauthTokens,Cn as fetchVCards,Mn as freeBusyQuery,ti as getBasicAuthHeaders,Zr as getDAVAttribute,ii as getOauthHeaders,mn as isCollectionDirty,kn as makeCalendar,on as propfind,ni as refreshAccessToken,bn as smartCollectionSync,yn as supportedReportSet,Vn as syncCalendars,vn as syncCollection,jn as updateCalendarObject,cn as updateObject,Dn as updateVCard,Xr as urlContains,Qr as urlEquals};
+var e="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{};function t(e){return e&&e.__esModule&&Object.prototype.hasOwnProperty.call(e,"default")?e.default:e}function r(e){if(e.__esModule)return e;var t=e.default;if("function"==typeof t){var r=function e(){return this instanceof e?Reflect.construct(t,arguments,this.constructor):t.apply(this,arguments)};r.prototype=t.prototype}else r={};return Object.defineProperty(r,"__esModule",{value:!0}),Object.keys(e).forEach((function(t){var n=Object.getOwnPropertyDescriptor(e,t);Object.defineProperty(r,t,n.get?n:{enumerable:!0,get:function(){return e[t]}})})),r}var n,i={};n||(n=1,function(e){!function(t){var r="undefined"!=typeof globalThis&&globalThis||void 0!==e&&e||void 0!==r&&r,n="URLSearchParams"in r,i="Symbol"in r&&"iterator"in Symbol,o="FileReader"in r&&"Blob"in r&&function(){try{return new Blob,!0}catch(e){return!1}}(),a="FormData"in r,s="ArrayBuffer"in r;if(s)var c=["[object Int8Array]","[object Uint8Array]","[object Uint8ClampedArray]","[object Int16Array]","[object Uint16Array]","[object Int32Array]","[object Uint32Array]","[object Float32Array]","[object Float64Array]"],u=ArrayBuffer.isView||function(e){return e&&c.indexOf(Object.prototype.toString.call(e))>-1};function l(e){if("string"!=typeof e&&(e=String(e)),/[^a-z0-9\-#$%&'*+.^_`|~!]/i.test(e)||""===e)throw new TypeError('Invalid character in header field name: "'+e+'"');return e.toLowerCase()}function h(e){return"string"!=typeof e&&(e=String(e)),e}function d(e){var t={next:function(){var t=e.shift();return{done:void 0===t,value:t}}};return i&&(t[Symbol.iterator]=function(){return t}),t}function f(e){this.map={},e instanceof f?e.forEach((function(e,t){this.append(t,e)}),this):Array.isArray(e)?e.forEach((function(e){this.append(e[0],e[1])}),this):e&&Object.getOwnPropertyNames(e).forEach((function(t){this.append(t,e[t])}),this)}function p(e){if(e.bodyUsed)return Promise.reject(new TypeError("Already read"));e.bodyUsed=!0}function y(e){return new Promise((function(t,r){e.onload=function(){t(e.result)},e.onerror=function(){r(e.error)}}))}function g(e){var t=new FileReader,r=y(t);return t.readAsArrayBuffer(e),r}function m(e){if(e.slice)return e.slice(0);var t=new Uint8Array(e.byteLength);return t.set(new Uint8Array(e)),t.buffer}function v(){return this.bodyUsed=!1,this._initBody=function(e){var t;this.bodyUsed=this.bodyUsed,this._bodyInit=e,e?"string"==typeof e?this._bodyText=e:o&&Blob.prototype.isPrototypeOf(e)?this._bodyBlob=e:a&&FormData.prototype.isPrototypeOf(e)?this._bodyFormData=e:n&&URLSearchParams.prototype.isPrototypeOf(e)?this._bodyText=e.toString():s&&o&&(t=e)&&DataView.prototype.isPrototypeOf(t)?(this._bodyArrayBuffer=m(e.buffer),this._bodyInit=new Blob([this._bodyArrayBuffer])):s&&(ArrayBuffer.prototype.isPrototypeOf(e)||u(e))?this._bodyArrayBuffer=m(e):this._bodyText=e=Object.prototype.toString.call(e):this._bodyText="",this.headers.get("content-type")||("string"==typeof e?this.headers.set("content-type","text/plain;charset=UTF-8"):this._bodyBlob&&this._bodyBlob.type?this.headers.set("content-type",this._bodyBlob.type):n&&URLSearchParams.prototype.isPrototypeOf(e)&&this.headers.set("content-type","application/x-www-form-urlencoded;charset=UTF-8"))},o&&(this.blob=function(){var e=p(this);if(e)return e;if(this._bodyBlob)return Promise.resolve(this._bodyBlob);if(this._bodyArrayBuffer)return Promise.resolve(new Blob([this._bodyArrayBuffer]));if(this._bodyFormData)throw new Error("could not read FormData body as blob");return Promise.resolve(new Blob([this._bodyText]))},this.arrayBuffer=function(){if(this._bodyArrayBuffer){var e=p(this);return e||(ArrayBuffer.isView(this._bodyArrayBuffer)?Promise.resolve(this._bodyArrayBuffer.buffer.slice(this._bodyArrayBuffer.byteOffset,this._bodyArrayBuffer.byteOffset+this._bodyArrayBuffer.byteLength)):Promise.resolve(this._bodyArrayBuffer))}return this.blob().then(g)}),this.text=function(){var e,t,r,n=p(this);if(n)return n;if(this._bodyBlob)return e=this._bodyBlob,t=new FileReader,r=y(t),t.readAsText(e),r;if(this._bodyArrayBuffer)return Promise.resolve(function(e){for(var t=new Uint8Array(e),r=new Array(t.length),n=0;n<t.length;n++)r[n]=String.fromCharCode(t[n]);return r.join("")}(this._bodyArrayBuffer));if(this._bodyFormData)throw new Error("could not read FormData body as text");return Promise.resolve(this._bodyText)},a&&(this.formData=function(){return this.text().then(E)}),this.json=function(){return this.text().then(JSON.parse)},this}f.prototype.append=function(e,t){e=l(e),t=h(t);var r=this.map[e];this.map[e]=r?r+", "+t:t},f.prototype.delete=function(e){delete this.map[l(e)]},f.prototype.get=function(e){return e=l(e),this.has(e)?this.map[e]:null},f.prototype.has=function(e){return this.map.hasOwnProperty(l(e))},f.prototype.set=function(e,t){this.map[l(e)]=h(t)},f.prototype.forEach=function(e,t){for(var r in this.map)this.map.hasOwnProperty(r)&&e.call(t,this.map[r],r,this)},f.prototype.keys=function(){var e=[];return this.forEach((function(t,r){e.push(r)})),d(e)},f.prototype.values=function(){var e=[];return this.forEach((function(t){e.push(t)})),d(e)},f.prototype.entries=function(){var e=[];return this.forEach((function(t,r){e.push([r,t])})),d(e)},i&&(f.prototype[Symbol.iterator]=f.prototype.entries);var b=["DELETE","GET","HEAD","OPTIONS","POST","PUT"];function w(e,t){if(!(this instanceof w))throw new TypeError('Please use the "new" operator, this DOM object constructor cannot be called as a function.');var r=(t=t||{}).body;if(e instanceof w){if(e.bodyUsed)throw new TypeError("Already read");this.url=e.url,this.credentials=e.credentials,t.headers||(this.headers=new f(e.headers)),this.method=e.method,this.mode=e.mode,this.signal=e.signal,r||null==e._bodyInit||(r=e._bodyInit,e.bodyUsed=!0)}else this.url=String(e);if(this.credentials=t.credentials||this.credentials||"same-origin",!t.headers&&this.headers||(this.headers=new f(t.headers)),this.method=function(e){var t=e.toUpperCase();return b.indexOf(t)>-1?t:e}(t.method||this.method||"GET"),this.mode=t.mode||this.mode||null,this.signal=t.signal||this.signal,this.referrer=null,("GET"===this.method||"HEAD"===this.method)&&r)throw new TypeError("Body not allowed for GET or HEAD requests");if(this._initBody(r),!("GET"!==this.method&&"HEAD"!==this.method||"no-store"!==t.cache&&"no-cache"!==t.cache)){var n=/([?&])_=[^&]*/;n.test(this.url)?this.url=this.url.replace(n,"$1_="+(new Date).getTime()):this.url+=(/\?/.test(this.url)?"&":"?")+"_="+(new Date).getTime()}}function E(e){var t=new FormData;return e.trim().split("&").forEach((function(e){if(e){var r=e.split("="),n=r.shift().replace(/\+/g," "),i=r.join("=").replace(/\+/g," ");t.append(decodeURIComponent(n),decodeURIComponent(i))}})),t}function A(e,t){if(!(this instanceof A))throw new TypeError('Please use the "new" operator, this DOM object constructor cannot be called as a function.');t||(t={}),this.type="default",this.status=void 0===t.status?200:t.status,this.ok=this.status>=200&&this.status<300,this.statusText=void 0===t.statusText?"":""+t.statusText,this.headers=new f(t.headers),this.url=t.url||"",this._initBody(e)}w.prototype.clone=function(){return new w(this,{body:this._bodyInit})},v.call(w.prototype),v.call(A.prototype),A.prototype.clone=function(){return new A(this._bodyInit,{status:this.status,statusText:this.statusText,headers:new f(this.headers),url:this.url})},A.error=function(){var e=new A(null,{status:0,statusText:""});return e.type="error",e};var T=[301,302,303,307,308];A.redirect=function(e,t){if(-1===T.indexOf(t))throw new RangeError("Invalid status code");return new A(null,{status:t,headers:{location:e}})},t.DOMException=r.DOMException;try{new t.DOMException}catch(e){t.DOMException=function(e,t){this.message=e,this.name=t;var r=Error(e);this.stack=r.stack},t.DOMException.prototype=Object.create(Error.prototype),t.DOMException.prototype.constructor=t.DOMException}function _(e,n){return new Promise((function(i,a){var c=new w(e,n);if(c.signal&&c.signal.aborted)return a(new t.DOMException("Aborted","AbortError"));var u=new XMLHttpRequest;function l(){u.abort()}u.onload=function(){var e,t,r={status:u.status,statusText:u.statusText,headers:(e=u.getAllResponseHeaders()||"",t=new f,e.replace(/\r?\n[\t ]+/g," ").split("\r").map((function(e){return 0===e.indexOf("\n")?e.substr(1,e.length):e})).forEach((function(e){var r=e.split(":"),n=r.shift().trim();if(n){var i=r.join(":").trim();t.append(n,i)}})),t)};r.url="responseURL"in u?u.responseURL:r.headers.get("X-Request-URL");var n="response"in u?u.response:u.responseText;setTimeout((function(){i(new A(n,r))}),0)},u.onerror=function(){setTimeout((function(){a(new TypeError("Network request failed"))}),0)},u.ontimeout=function(){setTimeout((function(){a(new TypeError("Network request failed"))}),0)},u.onabort=function(){setTimeout((function(){a(new t.DOMException("Aborted","AbortError"))}),0)},u.open(c.method,function(e){try{return""===e&&r.location.href?r.location.href:e}catch(t){return e}}(c.url),!0),"include"===c.credentials?u.withCredentials=!0:"omit"===c.credentials&&(u.withCredentials=!1),"responseType"in u&&(o?u.responseType="blob":s&&c.headers.get("Content-Type")&&-1!==c.headers.get("Content-Type").indexOf("application/octet-stream")&&(u.responseType="arraybuffer")),!n||"object"!=typeof n.headers||n.headers instanceof f?c.headers.forEach((function(e,t){u.setRequestHeader(t,e)})):Object.getOwnPropertyNames(n.headers).forEach((function(e){u.setRequestHeader(e,h(n.headers[e]))})),c.signal&&(c.signal.addEventListener("abort",l),u.onreadystatechange=function(){4===u.readyState&&c.signal.removeEventListener("abort",l)}),u.send(void 0===c._bodyInit?null:c._bodyInit)}))}_.polyfill=!0,r.fetch||(r.fetch=_,r.Headers=f,r.Request=w,r.Response=A),t.Headers=f,t.Request=w,t.Response=A,t.fetch=_}({})}("undefined"!=typeof self?self:i));var o="undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{};function a(){throw new Error("setTimeout has not been defined")}function s(){throw new Error("clearTimeout has not been defined")}var c=a,u=s;function l(e){if(c===setTimeout)return setTimeout(e,0);if((c===a||!c)&&setTimeout)return c=setTimeout,setTimeout(e,0);try{return c(e,0)}catch(t){try{return c.call(null,e,0)}catch(t){return c.call(this,e,0)}}}"function"==typeof o.setTimeout&&(c=setTimeout),"function"==typeof o.clearTimeout&&(u=clearTimeout);var h,d=[],f=!1,p=-1;function y(){f&&h&&(f=!1,h.length?d=h.concat(d):p=-1,d.length&&g())}function g(){if(!f){var e=l(y);f=!0;for(var t=d.length;t;){for(h=d,d=[];++p<t;)h&&h[p].run();p=-1,t=d.length}h=null,f=!1,function(e){if(u===clearTimeout)return clearTimeout(e);if((u===s||!u)&&clearTimeout)return u=clearTimeout,clearTimeout(e);try{return u(e)}catch(t){try{return u.call(null,e)}catch(t){return u.call(this,e)}}}(e)}}function m(e){var t=new Array(arguments.length-1);if(arguments.length>1)for(var r=1;r<arguments.length;r++)t[r-1]=arguments[r];d.push(new v(e,t)),1!==d.length||f||l(g)}function v(e,t){this.fun=e,this.array=t}v.prototype.run=function(){this.fun.apply(null,this.array)};function b(){}var w=b,E=b,A=b,T=b,_=b,C=b,O=b;var D=o.performance||{},x=D.now||D.mozNow||D.msNow||D.oNow||D.webkitNow||function(){return(new Date).getTime()};var R=new Date;var F,S,N,L,k,I={nextTick:m,title:"browser",browser:!0,env:{},argv:[],version:"",versions:{},on:w,addListener:E,once:A,off:T,removeListener:_,removeAllListeners:C,emit:O,binding:function(e){throw new Error("process.binding is not supported")},cwd:function(){return"/"},chdir:function(e){throw new Error("process.chdir is not supported")},umask:function(){return 0},hrtime:function(e){var t=.001*x.call(D),r=Math.floor(t),n=Math.floor(t%1*1e9);return e&&(r-=e[0],(n-=e[1])<0&&(r--,n+=1e9)),[r,n]},platform:"browser",release:{},config:{},uptime:function(){return(new Date-R)/1e3}},U={exports:{}};function P(){if(S)return F;S=1;var e=1e3,t=60*e,r=60*t,n=24*r,i=7*n,o=365.25*n;function a(e,t,r,n){var i=t>=1.5*r;return Math.round(e/r)+" "+n+(i?"s":"")}return F=function(s,c){c=c||{};var u=typeof s;if("string"===u&&s.length>0)return function(a){if((a=String(a)).length>100)return;var s=/^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(a);if(!s)return;var c=parseFloat(s[1]);switch((s[2]||"ms").toLowerCase()){case"years":case"year":case"yrs":case"yr":case"y":return c*o;case"weeks":case"week":case"w":return c*i;case"days":case"day":case"d":return c*n;case"hours":case"hour":case"hrs":case"hr":case"h":return c*r;case"minutes":case"minute":case"mins":case"min":case"m":return c*t;case"seconds":case"second":case"secs":case"sec":case"s":return c*e;case"milliseconds":case"millisecond":case"msecs":case"msec":case"ms":return c;default:return}}(s);if("number"===u&&isFinite(s))return c.long?function(i){var o=Math.abs(i);if(o>=n)return a(i,o,n,"day");if(o>=r)return a(i,o,r,"hour");if(o>=t)return a(i,o,t,"minute");if(o>=e)return a(i,o,e,"second");return i+" ms"}(s):function(i){var o=Math.abs(i);if(o>=n)return Math.round(i/n)+"d";if(o>=r)return Math.round(i/r)+"h";if(o>=t)return Math.round(i/t)+"m";if(o>=e)return Math.round(i/e)+"s";return i+"ms"}(s);throw new Error("val is not a non-empty string or a valid number. val="+JSON.stringify(s))}}var j,B=(k||(k=1,function(e,t){t.formatArgs=function(t){if(t[0]=(this.useColors?"%c":"")+this.namespace+(this.useColors?" %c":" ")+t[0]+(this.useColors?"%c ":" ")+"+"+e.exports.humanize(this.diff),!this.useColors)return;const r="color: "+this.color;t.splice(1,0,r,"color: inherit");let n=0,i=0;t[0].replace(/%[a-zA-Z%]/g,(e=>{"%%"!==e&&(n++,"%c"===e&&(i=n))})),t.splice(i,0,r)},t.save=function(e){try{e?t.storage.setItem("debug",e):t.storage.removeItem("debug")}catch(e){}},t.load=function(){let e;try{e=t.storage.getItem("debug")}catch(e){}return!e&&void 0!==I&&"env"in I&&(e=I.env.DEBUG),e},t.useColors=function(){if("undefined"!=typeof window&&window.process&&("renderer"===window.process.type||window.process.__nwjs))return!0;if("undefined"!=typeof navigator&&navigator.userAgent&&navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/))return!1;let e;return"undefined"!=typeof document&&document.documentElement&&document.documentElement.style&&document.documentElement.style.WebkitAppearance||"undefined"!=typeof window&&window.console&&(window.console.firebug||window.console.exception&&window.console.table)||"undefined"!=typeof navigator&&navigator.userAgent&&(e=navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/))&&parseInt(e[1],10)>=31||"undefined"!=typeof navigator&&navigator.userAgent&&navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/)},t.storage=function(){try{return localStorage}catch(e){}}(),t.destroy=(()=>{let e=!1;return()=>{e||(e=!0,console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."))}})(),t.colors=["#0000CC","#0000FF","#0033CC","#0033FF","#0066CC","#0066FF","#0099CC","#0099FF","#00CC00","#00CC33","#00CC66","#00CC99","#00CCCC","#00CCFF","#3300CC","#3300FF","#3333CC","#3333FF","#3366CC","#3366FF","#3399CC","#3399FF","#33CC00","#33CC33","#33CC66","#33CC99","#33CCCC","#33CCFF","#6600CC","#6600FF","#6633CC","#6633FF","#66CC00","#66CC33","#9900CC","#9900FF","#9933CC","#9933FF","#99CC00","#99CC33","#CC0000","#CC0033","#CC0066","#CC0099","#CC00CC","#CC00FF","#CC3300","#CC3333","#CC3366","#CC3399","#CC33CC","#CC33FF","#CC6600","#CC6633","#CC9900","#CC9933","#CCCC00","#CCCC33","#FF0000","#FF0033","#FF0066","#FF0099","#FF00CC","#FF00FF","#FF3300","#FF3333","#FF3366","#FF3399","#FF33CC","#FF33FF","#FF6600","#FF6633","#FF9900","#FF9933","#FFCC00","#FFCC33"],t.log=console.debug||console.log||(()=>{}),e.exports=(L||(L=1,N=function(e){function t(e){let n,i,o,a=null;function s(...e){if(!s.enabled)return;const r=s,i=Number(new Date),o=i-(n||i);r.diff=o,r.prev=n,r.curr=i,n=i,e[0]=t.coerce(e[0]),"string"!=typeof e[0]&&e.unshift("%O");let a=0;e[0]=e[0].replace(/%([a-zA-Z%])/g,((n,i)=>{if("%%"===n)return"%";a++;const o=t.formatters[i];if("function"==typeof o){const t=e[a];n=o.call(r,t),e.splice(a,1),a--}return n})),t.formatArgs.call(r,e),(r.log||t.log).apply(r,e)}return s.namespace=e,s.useColors=t.useColors(),s.color=t.selectColor(e),s.extend=r,s.destroy=t.destroy,Object.defineProperty(s,"enabled",{enumerable:!0,configurable:!1,get:()=>null!==a?a:(i!==t.namespaces&&(i=t.namespaces,o=t.enabled(e)),o),set:e=>{a=e}}),"function"==typeof t.init&&t.init(s),s}function r(e,r){const n=t(this.namespace+(void 0===r?":":r)+e);return n.log=this.log,n}function n(e,t){let r=0,n=0,i=-1,o=0;for(;r<e.length;)if(n<t.length&&(t[n]===e[r]||"*"===t[n]))"*"===t[n]?(i=n,o=r,n++):(r++,n++);else{if(-1===i)return!1;n=i+1,o++,r=o}for(;n<t.length&&"*"===t[n];)n++;return n===t.length}return t.debug=t,t.default=t,t.coerce=function(e){return e instanceof Error?e.stack||e.message:e},t.disable=function(){const e=[...t.names,...t.skips.map((e=>"-"+e))].join(",");return t.enable(""),e},t.enable=function(e){t.save(e),t.namespaces=e,t.names=[],t.skips=[];const r=("string"==typeof e?e:"").trim().replace(" ",",").split(",").filter(Boolean);for(const e of r)"-"===e[0]?t.skips.push(e.slice(1)):t.names.push(e)},t.enabled=function(e){for(const r of t.skips)if(n(e,r))return!1;for(const r of t.names)if(n(e,r))return!0;return!1},t.humanize=P(),t.destroy=function(){console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.")},Object.keys(e).forEach((r=>{t[r]=e[r]})),t.names=[],t.skips=[],t.formatters={},t.selectColor=function(e){let r=0;for(let t=0;t<e.length;t++)r=(r<<5)-r+e.charCodeAt(t),r|=0;return t.colors[Math.abs(r)%t.colors.length]},t.enable(t.load()),t}),N)(t);const{formatters:r}=e.exports;r.j=function(e){try{return JSON.stringify(e)}catch(e){return"[UnexpectedJSONParseError]: "+e.message}}}(U,U.exports)),U.exports),V=t(B);!function(e){e.CALENDAR_SERVER="http://calendarserver.org/ns/",e.CALDAV_APPLE="http://apple.com/ns/ical/",e.CALDAV="urn:ietf:params:xml:ns:caldav",e.CARDDAV="urn:ietf:params:xml:ns:carddav",e.DAV="DAV:"}(j||(j={}));const M={[j.CALDAV]:"xmlns:c",[j.CARDDAV]:"xmlns:card",[j.CALENDAR_SERVER]:"xmlns:cs",[j.CALDAV_APPLE]:"xmlns:ca",[j.DAV]:"xmlns:d"};var $,K;!function(e){e.CALDAV="c",e.CARDDAV="card",e.CALENDAR_SERVER="cs",e.CALDAV_APPLE="ca",e.DAV="d"}($||($={})),function(e){e.VEVENT="VEVENT",e.VTODO="VTODO",e.VJOURNAL="VJOURNAL",e.VFREEBUSY="VFREEBUSY",e.VTIMEZONE="VTIMEZONE",e.VALARM="VALARM"}(K||(K={}));var H=[],Y=[],q="undefined"!=typeof Uint8Array?Uint8Array:Array,z=!1;function G(){z=!0;for(var e="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",t=0;t<64;++t)H[t]=e[t],Y[e.charCodeAt(t)]=t;Y["-".charCodeAt(0)]=62,Y["_".charCodeAt(0)]=63}function W(e,t,r){for(var n,i,o=[],a=t;a<r;a+=3)n=(e[a]<<16)+(e[a+1]<<8)+e[a+2],o.push(H[(i=n)>>18&63]+H[i>>12&63]+H[i>>6&63]+H[63&i]);return o.join("")}function Q(e){var t;z||G();for(var r=e.length,n=r%3,i="",o=[],a=16383,s=0,c=r-n;s<c;s+=a)o.push(W(e,s,s+a>c?c:s+a));return 1===n?(t=e[r-1],i+=H[t>>2],i+=H[t<<4&63],i+="=="):2===n&&(t=(e[r-2]<<8)+e[r-1],i+=H[t>>10],i+=H[t>>4&63],i+=H[t<<2&63],i+="="),o.push(i),o.join("")}function X(e,t,r,n,i){var o,a,s=8*i-n-1,c=(1<<s)-1,u=c>>1,l=-7,h=r?i-1:0,d=r?-1:1,f=e[t+h];for(h+=d,o=f&(1<<-l)-1,f>>=-l,l+=s;l>0;o=256*o+e[t+h],h+=d,l-=8);for(a=o&(1<<-l)-1,o>>=-l,l+=n;l>0;a=256*a+e[t+h],h+=d,l-=8);if(0===o)o=1-u;else{if(o===c)return a?NaN:1/0*(f?-1:1);a+=Math.pow(2,n),o-=u}return(f?-1:1)*a*Math.pow(2,o-n)}function Z(e,t,r,n,i,o){var a,s,c,u=8*o-i-1,l=(1<<u)-1,h=l>>1,d=23===i?Math.pow(2,-24)-Math.pow(2,-77):0,f=n?0:o-1,p=n?1:-1,y=t<0||0===t&&1/t<0?1:0;for(t=Math.abs(t),isNaN(t)||t===1/0?(s=isNaN(t)?1:0,a=l):(a=Math.floor(Math.log(t)/Math.LN2),t*(c=Math.pow(2,-a))<1&&(a--,c*=2),(t+=a+h>=1?d/c:d*Math.pow(2,1-h))*c>=2&&(a++,c/=2),a+h>=l?(s=0,a=l):a+h>=1?(s=(t*c-1)*Math.pow(2,i),a+=h):(s=t*Math.pow(2,h-1)*Math.pow(2,i),a=0));i>=8;e[r+f]=255&s,f+=p,s/=256,i-=8);for(a=a<<i|s,u+=i;u>0;e[r+f]=255&a,f+=p,a/=256,u-=8);e[r+f-p]|=128*y}var J={}.toString,ee=Array.isArray||function(e){return"[object Array]"==J.call(e)};function te(){return ne.TYPED_ARRAY_SUPPORT?2147483647:1073741823}function re(e,t){if(te()<t)throw new RangeError("Invalid typed array length");return ne.TYPED_ARRAY_SUPPORT?(e=new Uint8Array(t)).__proto__=ne.prototype:(null===e&&(e=new ne(t)),e.length=t),e}function ne(e,t,r){if(!(ne.TYPED_ARRAY_SUPPORT||this instanceof ne))return new ne(e,t,r);if("number"==typeof e){if("string"==typeof t)throw new Error("If encoding is specified then the first argument must be a string");return ae(this,e)}return ie(this,e,t,r)}function ie(e,t,r,n){if("number"==typeof t)throw new TypeError('"value" argument must not be a number');return"undefined"!=typeof ArrayBuffer&&t instanceof ArrayBuffer?function(e,t,r,n){if(t.byteLength,r<0||t.byteLength<r)throw new RangeError("'offset' is out of bounds");if(t.byteLength<r+(n||0))throw new RangeError("'length' is out of bounds");t=void 0===r&&void 0===n?new Uint8Array(t):void 0===n?new Uint8Array(t,r):new Uint8Array(t,r,n);ne.TYPED_ARRAY_SUPPORT?(e=t).__proto__=ne.prototype:e=se(e,t);return e}(e,t,r,n):"string"==typeof t?function(e,t,r){"string"==typeof r&&""!==r||(r="utf8");if(!ne.isEncoding(r))throw new TypeError('"encoding" must be a valid string encoding');var n=0|le(t,r);e=re(e,n);var i=e.write(t,r);i!==n&&(e=e.slice(0,i));return e}(e,t,r):function(e,t){if(ue(t)){var r=0|ce(t.length);return 0===(e=re(e,r)).length||t.copy(e,0,0,r),e}if(t){if("undefined"!=typeof ArrayBuffer&&t.buffer instanceof ArrayBuffer||"length"in t)return"number"!=typeof t.length||(n=t.length)!=n?re(e,0):se(e,t);if("Buffer"===t.type&&ee(t.data))return se(e,t.data)}var n;throw new TypeError("First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.")}(e,t)}function oe(e){if("number"!=typeof e)throw new TypeError('"size" argument must be a number');if(e<0)throw new RangeError('"size" argument must not be negative')}function ae(e,t){if(oe(t),e=re(e,t<0?0:0|ce(t)),!ne.TYPED_ARRAY_SUPPORT)for(var r=0;r<t;++r)e[r]=0;return e}function se(e,t){var r=t.length<0?0:0|ce(t.length);e=re(e,r);for(var n=0;n<r;n+=1)e[n]=255&t[n];return e}function ce(e){if(e>=te())throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x"+te().toString(16)+" bytes");return 0|e}function ue(e){return!(null==e||!e._isBuffer)}function le(e,t){if(ue(e))return e.length;if("undefined"!=typeof ArrayBuffer&&"function"==typeof ArrayBuffer.isView&&(ArrayBuffer.isView(e)||e instanceof ArrayBuffer))return e.byteLength;"string"!=typeof e&&(e=""+e);var r=e.length;if(0===r)return 0;for(var n=!1;;)switch(t){case"ascii":case"latin1":case"binary":return r;case"utf8":case"utf-8":case void 0:return Pe(e).length;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return 2*r;case"hex":return r>>>1;case"base64":return je(e).length;default:if(n)return Pe(e).length;t=(""+t).toLowerCase(),n=!0}}function he(e,t,r){var n=!1;if((void 0===t||t<0)&&(t=0),t>this.length)return"";if((void 0===r||r>this.length)&&(r=this.length),r<=0)return"";if((r>>>=0)<=(t>>>=0))return"";for(e||(e="utf8");;)switch(e){case"hex":return Oe(this,t,r);case"utf8":case"utf-8":return Ae(this,t,r);case"ascii":return _e(this,t,r);case"latin1":case"binary":return Ce(this,t,r);case"base64":return Ee(this,t,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return De(this,t,r);default:if(n)throw new TypeError("Unknown encoding: "+e);e=(e+"").toLowerCase(),n=!0}}function de(e,t,r){var n=e[t];e[t]=e[r],e[r]=n}function fe(e,t,r,n,i){if(0===e.length)return-1;if("string"==typeof r?(n=r,r=0):r>2147483647?r=2147483647:r<-2147483648&&(r=-2147483648),r=+r,isNaN(r)&&(r=i?0:e.length-1),r<0&&(r=e.length+r),r>=e.length){if(i)return-1;r=e.length-1}else if(r<0){if(!i)return-1;r=0}if("string"==typeof t&&(t=ne.from(t,n)),ue(t))return 0===t.length?-1:pe(e,t,r,n,i);if("number"==typeof t)return t&=255,ne.TYPED_ARRAY_SUPPORT&&"function"==typeof Uint8Array.prototype.indexOf?i?Uint8Array.prototype.indexOf.call(e,t,r):Uint8Array.prototype.lastIndexOf.call(e,t,r):pe(e,[t],r,n,i);throw new TypeError("val must be string, number or Buffer")}function pe(e,t,r,n,i){var o,a=1,s=e.length,c=t.length;if(void 0!==n&&("ucs2"===(n=String(n).toLowerCase())||"ucs-2"===n||"utf16le"===n||"utf-16le"===n)){if(e.length<2||t.length<2)return-1;a=2,s/=2,c/=2,r/=2}function u(e,t){return 1===a?e[t]:e.readUInt16BE(t*a)}if(i){var l=-1;for(o=r;o<s;o++)if(u(e,o)===u(t,-1===l?0:o-l)){if(-1===l&&(l=o),o-l+1===c)return l*a}else-1!==l&&(o-=o-l),l=-1}else for(r+c>s&&(r=s-c),o=r;o>=0;o--){for(var h=!0,d=0;d<c;d++)if(u(e,o+d)!==u(t,d)){h=!1;break}if(h)return o}return-1}function ye(e,t,r,n){r=Number(r)||0;var i=e.length-r;n?(n=Number(n))>i&&(n=i):n=i;var o=t.length;if(o%2!=0)throw new TypeError("Invalid hex string");n>o/2&&(n=o/2);for(var a=0;a<n;++a){var s=parseInt(t.substr(2*a,2),16);if(isNaN(s))return a;e[r+a]=s}return a}function ge(e,t,r,n){return Be(Pe(t,e.length-r),e,r,n)}function me(e,t,r,n){return Be(function(e){for(var t=[],r=0;r<e.length;++r)t.push(255&e.charCodeAt(r));return t}(t),e,r,n)}function ve(e,t,r,n){return me(e,t,r,n)}function be(e,t,r,n){return Be(je(t),e,r,n)}function we(e,t,r,n){return Be(function(e,t){for(var r,n,i,o=[],a=0;a<e.length&&!((t-=2)<0);++a)n=(r=e.charCodeAt(a))>>8,i=r%256,o.push(i),o.push(n);return o}(t,e.length-r),e,r,n)}function Ee(e,t,r){return 0===t&&r===e.length?Q(e):Q(e.slice(t,r))}function Ae(e,t,r){r=Math.min(e.length,r);for(var n=[],i=t;i<r;){var o,a,s,c,u=e[i],l=null,h=u>239?4:u>223?3:u>191?2:1;if(i+h<=r)switch(h){case 1:u<128&&(l=u);break;case 2:128==(192&(o=e[i+1]))&&(c=(31&u)<<6|63&o)>127&&(l=c);break;case 3:o=e[i+1],a=e[i+2],128==(192&o)&&128==(192&a)&&(c=(15&u)<<12|(63&o)<<6|63&a)>2047&&(c<55296||c>57343)&&(l=c);break;case 4:o=e[i+1],a=e[i+2],s=e[i+3],128==(192&o)&&128==(192&a)&&128==(192&s)&&(c=(15&u)<<18|(63&o)<<12|(63&a)<<6|63&s)>65535&&c<1114112&&(l=c)}null===l?(l=65533,h=1):l>65535&&(l-=65536,n.push(l>>>10&1023|55296),l=56320|1023&l),n.push(l),i+=h}return function(e){var t=e.length;if(t<=Te)return String.fromCharCode.apply(String,e);var r="",n=0;for(;n<t;)r+=String.fromCharCode.apply(String,e.slice(n,n+=Te));return r}(n)}ne.TYPED_ARRAY_SUPPORT=void 0===o.TYPED_ARRAY_SUPPORT||o.TYPED_ARRAY_SUPPORT,te(),ne.poolSize=8192,ne._augment=function(e){return e.__proto__=ne.prototype,e},ne.from=function(e,t,r){return ie(null,e,t,r)},ne.TYPED_ARRAY_SUPPORT&&(ne.prototype.__proto__=Uint8Array.prototype,ne.__proto__=Uint8Array,"undefined"!=typeof Symbol&&Symbol.species&&ne[Symbol.species]),ne.alloc=function(e,t,r){return function(e,t,r,n){return oe(t),t<=0?re(e,t):void 0!==r?"string"==typeof n?re(e,t).fill(r,n):re(e,t).fill(r):re(e,t)}(null,e,t,r)},ne.allocUnsafe=function(e){return ae(null,e)},ne.allocUnsafeSlow=function(e){return ae(null,e)},ne.isBuffer=function(e){return null!=e&&(!!e._isBuffer||Ve(e)||function(e){return"function"==typeof e.readFloatLE&&"function"==typeof e.slice&&Ve(e.slice(0,0))}(e))},ne.compare=function(e,t){if(!ue(e)||!ue(t))throw new TypeError("Arguments must be Buffers");if(e===t)return 0;for(var r=e.length,n=t.length,i=0,o=Math.min(r,n);i<o;++i)if(e[i]!==t[i]){r=e[i],n=t[i];break}return r<n?-1:n<r?1:0},ne.isEncoding=function(e){switch(String(e).toLowerCase()){case"hex":case"utf8":case"utf-8":case"ascii":case"latin1":case"binary":case"base64":case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return!0;default:return!1}},ne.concat=function(e,t){if(!ee(e))throw new TypeError('"list" argument must be an Array of Buffers');if(0===e.length)return ne.alloc(0);var r;if(void 0===t)for(t=0,r=0;r<e.length;++r)t+=e[r].length;var n=ne.allocUnsafe(t),i=0;for(r=0;r<e.length;++r){var o=e[r];if(!ue(o))throw new TypeError('"list" argument must be an Array of Buffers');o.copy(n,i),i+=o.length}return n},ne.byteLength=le,ne.prototype._isBuffer=!0,ne.prototype.swap16=function(){var e=this.length;if(e%2!=0)throw new RangeError("Buffer size must be a multiple of 16-bits");for(var t=0;t<e;t+=2)de(this,t,t+1);return this},ne.prototype.swap32=function(){var e=this.length;if(e%4!=0)throw new RangeError("Buffer size must be a multiple of 32-bits");for(var t=0;t<e;t+=4)de(this,t,t+3),de(this,t+1,t+2);return this},ne.prototype.swap64=function(){var e=this.length;if(e%8!=0)throw new RangeError("Buffer size must be a multiple of 64-bits");for(var t=0;t<e;t+=8)de(this,t,t+7),de(this,t+1,t+6),de(this,t+2,t+5),de(this,t+3,t+4);return this},ne.prototype.toString=function(){var e=0|this.length;return 0===e?"":0===arguments.length?Ae(this,0,e):he.apply(this,arguments)},ne.prototype.equals=function(e){if(!ue(e))throw new TypeError("Argument must be a Buffer");return this===e||0===ne.compare(this,e)},ne.prototype.inspect=function(){var e="";return this.length>0&&(e=this.toString("hex",0,50).match(/.{2}/g).join(" "),this.length>50&&(e+=" ... ")),"<Buffer "+e+">"},ne.prototype.compare=function(e,t,r,n,i){if(!ue(e))throw new TypeError("Argument must be a Buffer");if(void 0===t&&(t=0),void 0===r&&(r=e?e.length:0),void 0===n&&(n=0),void 0===i&&(i=this.length),t<0||r>e.length||n<0||i>this.length)throw new RangeError("out of range index");if(n>=i&&t>=r)return 0;if(n>=i)return-1;if(t>=r)return 1;if(this===e)return 0;for(var o=(i>>>=0)-(n>>>=0),a=(r>>>=0)-(t>>>=0),s=Math.min(o,a),c=this.slice(n,i),u=e.slice(t,r),l=0;l<s;++l)if(c[l]!==u[l]){o=c[l],a=u[l];break}return o<a?-1:a<o?1:0},ne.prototype.includes=function(e,t,r){return-1!==this.indexOf(e,t,r)},ne.prototype.indexOf=function(e,t,r){return fe(this,e,t,r,!0)},ne.prototype.lastIndexOf=function(e,t,r){return fe(this,e,t,r,!1)},ne.prototype.write=function(e,t,r,n){if(void 0===t)n="utf8",r=this.length,t=0;else if(void 0===r&&"string"==typeof t)n=t,r=this.length,t=0;else{if(!isFinite(t))throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");t|=0,isFinite(r)?(r|=0,void 0===n&&(n="utf8")):(n=r,r=void 0)}var i=this.length-t;if((void 0===r||r>i)&&(r=i),e.length>0&&(r<0||t<0)||t>this.length)throw new RangeError("Attempt to write outside buffer bounds");n||(n="utf8");for(var o=!1;;)switch(n){case"hex":return ye(this,e,t,r);case"utf8":case"utf-8":return ge(this,e,t,r);case"ascii":return me(this,e,t,r);case"latin1":case"binary":return ve(this,e,t,r);case"base64":return be(this,e,t,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return we(this,e,t,r);default:if(o)throw new TypeError("Unknown encoding: "+n);n=(""+n).toLowerCase(),o=!0}},ne.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};var Te=4096;function _e(e,t,r){var n="";r=Math.min(e.length,r);for(var i=t;i<r;++i)n+=String.fromCharCode(127&e[i]);return n}function Ce(e,t,r){var n="";r=Math.min(e.length,r);for(var i=t;i<r;++i)n+=String.fromCharCode(e[i]);return n}function Oe(e,t,r){var n=e.length;(!t||t<0)&&(t=0),(!r||r<0||r>n)&&(r=n);for(var i="",o=t;o<r;++o)i+=Ue(e[o]);return i}function De(e,t,r){for(var n=e.slice(t,r),i="",o=0;o<n.length;o+=2)i+=String.fromCharCode(n[o]+256*n[o+1]);return i}function xe(e,t,r){if(e%1!=0||e<0)throw new RangeError("offset is not uint");if(e+t>r)throw new RangeError("Trying to access beyond buffer length")}function Re(e,t,r,n,i,o){if(!ue(e))throw new TypeError('"buffer" argument must be a Buffer instance');if(t>i||t<o)throw new RangeError('"value" argument is out of bounds');if(r+n>e.length)throw new RangeError("Index out of range")}function Fe(e,t,r,n){t<0&&(t=65535+t+1);for(var i=0,o=Math.min(e.length-r,2);i<o;++i)e[r+i]=(t&255<<8*(n?i:1-i))>>>8*(n?i:1-i)}function Se(e,t,r,n){t<0&&(t=4294967295+t+1);for(var i=0,o=Math.min(e.length-r,4);i<o;++i)e[r+i]=t>>>8*(n?i:3-i)&255}function Ne(e,t,r,n,i,o){if(r+n>e.length)throw new RangeError("Index out of range");if(r<0)throw new RangeError("Index out of range")}function Le(e,t,r,n,i){return i||Ne(e,0,r,4),Z(e,t,r,n,23,4),r+4}function ke(e,t,r,n,i){return i||Ne(e,0,r,8),Z(e,t,r,n,52,8),r+8}ne.prototype.slice=function(e,t){var r,n=this.length;if((e=~~e)<0?(e+=n)<0&&(e=0):e>n&&(e=n),(t=void 0===t?n:~~t)<0?(t+=n)<0&&(t=0):t>n&&(t=n),t<e&&(t=e),ne.TYPED_ARRAY_SUPPORT)(r=this.subarray(e,t)).__proto__=ne.prototype;else{var i=t-e;r=new ne(i,void 0);for(var o=0;o<i;++o)r[o]=this[o+e]}return r},ne.prototype.readUIntLE=function(e,t,r){e|=0,t|=0,r||xe(e,t,this.length);for(var n=this[e],i=1,o=0;++o<t&&(i*=256);)n+=this[e+o]*i;return n},ne.prototype.readUIntBE=function(e,t,r){e|=0,t|=0,r||xe(e,t,this.length);for(var n=this[e+--t],i=1;t>0&&(i*=256);)n+=this[e+--t]*i;return n},ne.prototype.readUInt8=function(e,t){return t||xe(e,1,this.length),this[e]},ne.prototype.readUInt16LE=function(e,t){return t||xe(e,2,this.length),this[e]|this[e+1]<<8},ne.prototype.readUInt16BE=function(e,t){return t||xe(e,2,this.length),this[e]<<8|this[e+1]},ne.prototype.readUInt32LE=function(e,t){return t||xe(e,4,this.length),(this[e]|this[e+1]<<8|this[e+2]<<16)+16777216*this[e+3]},ne.prototype.readUInt32BE=function(e,t){return t||xe(e,4,this.length),16777216*this[e]+(this[e+1]<<16|this[e+2]<<8|this[e+3])},ne.prototype.readIntLE=function(e,t,r){e|=0,t|=0,r||xe(e,t,this.length);for(var n=this[e],i=1,o=0;++o<t&&(i*=256);)n+=this[e+o]*i;return n>=(i*=128)&&(n-=Math.pow(2,8*t)),n},ne.prototype.readIntBE=function(e,t,r){e|=0,t|=0,r||xe(e,t,this.length);for(var n=t,i=1,o=this[e+--n];n>0&&(i*=256);)o+=this[e+--n]*i;return o>=(i*=128)&&(o-=Math.pow(2,8*t)),o},ne.prototype.readInt8=function(e,t){return t||xe(e,1,this.length),128&this[e]?-1*(255-this[e]+1):this[e]},ne.prototype.readInt16LE=function(e,t){t||xe(e,2,this.length);var r=this[e]|this[e+1]<<8;return 32768&r?4294901760|r:r},ne.prototype.readInt16BE=function(e,t){t||xe(e,2,this.length);var r=this[e+1]|this[e]<<8;return 32768&r?4294901760|r:r},ne.prototype.readInt32LE=function(e,t){return t||xe(e,4,this.length),this[e]|this[e+1]<<8|this[e+2]<<16|this[e+3]<<24},ne.prototype.readInt32BE=function(e,t){return t||xe(e,4,this.length),this[e]<<24|this[e+1]<<16|this[e+2]<<8|this[e+3]},ne.prototype.readFloatLE=function(e,t){return t||xe(e,4,this.length),X(this,e,!0,23,4)},ne.prototype.readFloatBE=function(e,t){return t||xe(e,4,this.length),X(this,e,!1,23,4)},ne.prototype.readDoubleLE=function(e,t){return t||xe(e,8,this.length),X(this,e,!0,52,8)},ne.prototype.readDoubleBE=function(e,t){return t||xe(e,8,this.length),X(this,e,!1,52,8)},ne.prototype.writeUIntLE=function(e,t,r,n){(e=+e,t|=0,r|=0,n)||Re(this,e,t,r,Math.pow(2,8*r)-1,0);var i=1,o=0;for(this[t]=255&e;++o<r&&(i*=256);)this[t+o]=e/i&255;return t+r},ne.prototype.writeUIntBE=function(e,t,r,n){(e=+e,t|=0,r|=0,n)||Re(this,e,t,r,Math.pow(2,8*r)-1,0);var i=r-1,o=1;for(this[t+i]=255&e;--i>=0&&(o*=256);)this[t+i]=e/o&255;return t+r},ne.prototype.writeUInt8=function(e,t,r){return e=+e,t|=0,r||Re(this,e,t,1,255,0),ne.TYPED_ARRAY_SUPPORT||(e=Math.floor(e)),this[t]=255&e,t+1},ne.prototype.writeUInt16LE=function(e,t,r){return e=+e,t|=0,r||Re(this,e,t,2,65535,0),ne.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8):Fe(this,e,t,!0),t+2},ne.prototype.writeUInt16BE=function(e,t,r){return e=+e,t|=0,r||Re(this,e,t,2,65535,0),ne.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):Fe(this,e,t,!1),t+2},ne.prototype.writeUInt32LE=function(e,t,r){return e=+e,t|=0,r||Re(this,e,t,4,4294967295,0),ne.TYPED_ARRAY_SUPPORT?(this[t+3]=e>>>24,this[t+2]=e>>>16,this[t+1]=e>>>8,this[t]=255&e):Se(this,e,t,!0),t+4},ne.prototype.writeUInt32BE=function(e,t,r){return e=+e,t|=0,r||Re(this,e,t,4,4294967295,0),ne.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):Se(this,e,t,!1),t+4},ne.prototype.writeIntLE=function(e,t,r,n){if(e=+e,t|=0,!n){var i=Math.pow(2,8*r-1);Re(this,e,t,r,i-1,-i)}var o=0,a=1,s=0;for(this[t]=255&e;++o<r&&(a*=256);)e<0&&0===s&&0!==this[t+o-1]&&(s=1),this[t+o]=(e/a|0)-s&255;return t+r},ne.prototype.writeIntBE=function(e,t,r,n){if(e=+e,t|=0,!n){var i=Math.pow(2,8*r-1);Re(this,e,t,r,i-1,-i)}var o=r-1,a=1,s=0;for(this[t+o]=255&e;--o>=0&&(a*=256);)e<0&&0===s&&0!==this[t+o+1]&&(s=1),this[t+o]=(e/a|0)-s&255;return t+r},ne.prototype.writeInt8=function(e,t,r){return e=+e,t|=0,r||Re(this,e,t,1,127,-128),ne.TYPED_ARRAY_SUPPORT||(e=Math.floor(e)),e<0&&(e=255+e+1),this[t]=255&e,t+1},ne.prototype.writeInt16LE=function(e,t,r){return e=+e,t|=0,r||Re(this,e,t,2,32767,-32768),ne.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8):Fe(this,e,t,!0),t+2},ne.prototype.writeInt16BE=function(e,t,r){return e=+e,t|=0,r||Re(this,e,t,2,32767,-32768),ne.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):Fe(this,e,t,!1),t+2},ne.prototype.writeInt32LE=function(e,t,r){return e=+e,t|=0,r||Re(this,e,t,4,2147483647,-2147483648),ne.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8,this[t+2]=e>>>16,this[t+3]=e>>>24):Se(this,e,t,!0),t+4},ne.prototype.writeInt32BE=function(e,t,r){return e=+e,t|=0,r||Re(this,e,t,4,2147483647,-2147483648),e<0&&(e=4294967295+e+1),ne.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):Se(this,e,t,!1),t+4},ne.prototype.writeFloatLE=function(e,t,r){return Le(this,e,t,!0,r)},ne.prototype.writeFloatBE=function(e,t,r){return Le(this,e,t,!1,r)},ne.prototype.writeDoubleLE=function(e,t,r){return ke(this,e,t,!0,r)},ne.prototype.writeDoubleBE=function(e,t,r){return ke(this,e,t,!1,r)},ne.prototype.copy=function(e,t,r,n){if(r||(r=0),n||0===n||(n=this.length),t>=e.length&&(t=e.length),t||(t=0),n>0&&n<r&&(n=r),n===r)return 0;if(0===e.length||0===this.length)return 0;if(t<0)throw new RangeError("targetStart out of bounds");if(r<0||r>=this.length)throw new RangeError("sourceStart out of bounds");if(n<0)throw new RangeError("sourceEnd out of bounds");n>this.length&&(n=this.length),e.length-t<n-r&&(n=e.length-t+r);var i,o=n-r;if(this===e&&r<t&&t<n)for(i=o-1;i>=0;--i)e[i+t]=this[i+r];else if(o<1e3||!ne.TYPED_ARRAY_SUPPORT)for(i=0;i<o;++i)e[i+t]=this[i+r];else Uint8Array.prototype.set.call(e,this.subarray(r,r+o),t);return o},ne.prototype.fill=function(e,t,r,n){if("string"==typeof e){if("string"==typeof t?(n=t,t=0,r=this.length):"string"==typeof r&&(n=r,r=this.length),1===e.length){var i=e.charCodeAt(0);i<256&&(e=i)}if(void 0!==n&&"string"!=typeof n)throw new TypeError("encoding must be a string");if("string"==typeof n&&!ne.isEncoding(n))throw new TypeError("Unknown encoding: "+n)}else"number"==typeof e&&(e&=255);if(t<0||this.length<t||this.length<r)throw new RangeError("Out of range index");if(r<=t)return this;var o;if(t>>>=0,r=void 0===r?this.length:r>>>0,e||(e=0),"number"==typeof e)for(o=t;o<r;++o)this[o]=e;else{var a=ue(e)?e:Pe(new ne(e,n).toString()),s=a.length;for(o=0;o<r-t;++o)this[o+t]=a[o%s]}return this};var Ie=/[^+\/0-9A-Za-z-_]/g;function Ue(e){return e<16?"0"+e.toString(16):e.toString(16)}function Pe(e,t){var r;t=t||1/0;for(var n=e.length,i=null,o=[],a=0;a<n;++a){if((r=e.charCodeAt(a))>55295&&r<57344){if(!i){if(r>56319){(t-=3)>-1&&o.push(239,191,189);continue}if(a+1===n){(t-=3)>-1&&o.push(239,191,189);continue}i=r;continue}if(r<56320){(t-=3)>-1&&o.push(239,191,189),i=r;continue}r=65536+(i-55296<<10|r-56320)}else i&&(t-=3)>-1&&o.push(239,191,189);if(i=null,r<128){if((t-=1)<0)break;o.push(r)}else if(r<2048){if((t-=2)<0)break;o.push(r>>6|192,63&r|128)}else if(r<65536){if((t-=3)<0)break;o.push(r>>12|224,r>>6&63|128,63&r|128)}else{if(!(r<1114112))throw new Error("Invalid code point");if((t-=4)<0)break;o.push(r>>18|240,r>>12&63|128,r>>6&63|128,63&r|128)}}return o}function je(e){return function(e){var t,r,n,i,o,a;z||G();var s=e.length;if(s%4>0)throw new Error("Invalid string. Length must be a multiple of 4");o="="===e[s-2]?2:"="===e[s-1]?1:0,a=new q(3*s/4-o),n=o>0?s-4:s;var c=0;for(t=0,r=0;t<n;t+=4,r+=3)i=Y[e.charCodeAt(t)]<<18|Y[e.charCodeAt(t+1)]<<12|Y[e.charCodeAt(t+2)]<<6|Y[e.charCodeAt(t+3)],a[c++]=i>>16&255,a[c++]=i>>8&255,a[c++]=255&i;return 2===o?(i=Y[e.charCodeAt(t)]<<2|Y[e.charCodeAt(t+1)]>>4,a[c++]=255&i):1===o&&(i=Y[e.charCodeAt(t)]<<10|Y[e.charCodeAt(t+1)]<<4|Y[e.charCodeAt(t+2)]>>2,a[c++]=i>>8&255,a[c++]=255&i),a}(function(e){if((e=function(e){return e.trim?e.trim():e.replace(/^\s+|\s+$/g,"")}(e).replace(Ie,"")).length<2)return"";for(;e.length%4!=0;)e+="=";return e}(e))}function Be(e,t,r,n){for(var i=0;i<n&&!(i+r>=t.length||i>=e.length);++i)t[i+r]=e[i];return i}function Ve(e){return!!e.constructor&&"function"==typeof e.constructor.isBuffer&&e.constructor.isBuffer(e)}var Me,$e={};function Ke(){}function He(){He.init.call(this)}function Ye(e){return void 0===e._maxListeners?He.defaultMaxListeners:e._maxListeners}function qe(e,t,r,n){var i,o,a,s;if("function"!=typeof r)throw new TypeError('"listener" argument must be a function');if((o=e._events)?(o.newListener&&(e.emit("newListener",t,r.listener?r.listener:r),o=e._events),a=o[t]):(o=e._events=new Ke,e._eventsCount=0),a){if("function"==typeof a?a=o[t]=n?[r,a]:[a,r]:n?a.unshift(r):a.push(r),!a.warned&&(i=Ye(e))&&i>0&&a.length>i){a.warned=!0;var c=new Error("Possible EventEmitter memory leak detected. "+a.length+" "+t+" listeners added. Use emitter.setMaxListeners() to increase limit");c.name="MaxListenersExceededWarning",c.emitter=e,c.type=t,c.count=a.length,s=c,"function"==typeof console.warn?console.warn(s):console.log(s)}}else a=o[t]=r,++e._eventsCount;return e}function ze(e,t,r){var n=!1;function i(){e.removeListener(t,i),n||(n=!0,r.apply(e,arguments))}return i.listener=r,i}function Ge(e){var t=this._events;if(t){var r=t[e];if("function"==typeof r)return 1;if(r)return r.length}return 0}function We(e,t){for(var r=new Array(t);t--;)r[t]=e[t];return r}Ke.prototype=Object.create(null),He.EventEmitter=He,He.usingDomains=!1,He.prototype.domain=void 0,He.prototype._events=void 0,He.prototype._maxListeners=void 0,He.defaultMaxListeners=10,He.init=function(){this.domain=null,He.usingDomains&&undefined.active,this._events&&this._events!==Object.getPrototypeOf(this)._events||(this._events=new Ke,this._eventsCount=0),this._maxListeners=this._maxListeners||void 0},He.prototype.setMaxListeners=function(e){if("number"!=typeof e||e<0||isNaN(e))throw new TypeError('"n" argument must be a positive number');return this._maxListeners=e,this},He.prototype.getMaxListeners=function(){return Ye(this)},He.prototype.emit=function(e){var t,r,n,i,o,a,s,c="error"===e;if(a=this._events)c=c&&null==a.error;else if(!c)return!1;if(s=this.domain,c){if(t=arguments[1],!s){if(t instanceof Error)throw t;var u=new Error('Uncaught, unspecified "error" event. ('+t+")");throw u.context=t,u}return t||(t=new Error('Uncaught, unspecified "error" event')),t.domainEmitter=this,t.domain=s,t.domainThrown=!1,s.emit("error",t),!1}if(!(r=a[e]))return!1;var l="function"==typeof r;switch(n=arguments.length){case 1:!function(e,t,r){if(t)e.call(r);else for(var n=e.length,i=We(e,n),o=0;o<n;++o)i[o].call(r)}(r,l,this);break;case 2:!function(e,t,r,n){if(t)e.call(r,n);else for(var i=e.length,o=We(e,i),a=0;a<i;++a)o[a].call(r,n)}(r,l,this,arguments[1]);break;case 3:!function(e,t,r,n,i){if(t)e.call(r,n,i);else for(var o=e.length,a=We(e,o),s=0;s<o;++s)a[s].call(r,n,i)}(r,l,this,arguments[1],arguments[2]);break;case 4:!function(e,t,r,n,i,o){if(t)e.call(r,n,i,o);else for(var a=e.length,s=We(e,a),c=0;c<a;++c)s[c].call(r,n,i,o)}(r,l,this,arguments[1],arguments[2],arguments[3]);break;default:for(i=new Array(n-1),o=1;o<n;o++)i[o-1]=arguments[o];!function(e,t,r,n){if(t)e.apply(r,n);else for(var i=e.length,o=We(e,i),a=0;a<i;++a)o[a].apply(r,n)}(r,l,this,i)}return!0},He.prototype.addListener=function(e,t){return qe(this,e,t,!1)},He.prototype.on=He.prototype.addListener,He.prototype.prependListener=function(e,t){return qe(this,e,t,!0)},He.prototype.once=function(e,t){if("function"!=typeof t)throw new TypeError('"listener" argument must be a function');return this.on(e,ze(this,e,t)),this},He.prototype.prependOnceListener=function(e,t){if("function"!=typeof t)throw new TypeError('"listener" argument must be a function');return this.prependListener(e,ze(this,e,t)),this},He.prototype.removeListener=function(e,t){var r,n,i,o,a;if("function"!=typeof t)throw new TypeError('"listener" argument must be a function');if(!(n=this._events))return this;if(!(r=n[e]))return this;if(r===t||r.listener&&r.listener===t)0==--this._eventsCount?this._events=new Ke:(delete n[e],n.removeListener&&this.emit("removeListener",e,r.listener||t));else if("function"!=typeof r){for(i=-1,o=r.length;o-- >0;)if(r[o]===t||r[o].listener&&r[o].listener===t){a=r[o].listener,i=o;break}if(i<0)return this;if(1===r.length){if(r[0]=void 0,0==--this._eventsCount)return this._events=new Ke,this;delete n[e]}else!function(e,t){for(var r=t,n=r+1,i=e.length;n<i;r+=1,n+=1)e[r]=e[n];e.pop()}(r,i);n.removeListener&&this.emit("removeListener",e,a||t)}return this},He.prototype.off=function(e,t){return this.removeListener(e,t)},He.prototype.removeAllListeners=function(e){var t,r;if(!(r=this._events))return this;if(!r.removeListener)return 0===arguments.length?(this._events=new Ke,this._eventsCount=0):r[e]&&(0==--this._eventsCount?this._events=new Ke:delete r[e]),this;if(0===arguments.length){for(var n,i=Object.keys(r),o=0;o<i.length;++o)"removeListener"!==(n=i[o])&&this.removeAllListeners(n);return this.removeAllListeners("removeListener"),this._events=new Ke,this._eventsCount=0,this}if("function"==typeof(t=r[e]))this.removeListener(e,t);else if(t)do{this.removeListener(e,t[t.length-1])}while(t[0]);return this},He.prototype.listeners=function(e){var t,r=this._events;return r&&(t=r[e])?"function"==typeof t?[t.listener||t]:function(e){for(var t=new Array(e.length),r=0;r<t.length;++r)t[r]=e[r].listener||e[r];return t}(t):[]},He.listenerCount=function(e,t){return"function"==typeof e.listenerCount?e.listenerCount(t):Ge.call(e,t)},He.prototype.listenerCount=Ge,He.prototype.eventNames=function(){return this._eventsCount>0?Reflect.ownKeys(this._events):[]},Me="function"==typeof Object.create?function(e,t){e.super_=t,e.prototype=Object.create(t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}})}:function(e,t){e.super_=t;var r=function(){};r.prototype=t.prototype,e.prototype=new r,e.prototype.constructor=e};var Qe=/%[sdj%]/g;function Xe(e){if(!ut(e)){for(var t=[],r=0;r<arguments.length;r++)t.push(tt(arguments[r]));return t.join(" ")}r=1;for(var n=arguments,i=n.length,o=String(e).replace(Qe,(function(e){if("%%"===e)return"%";if(r>=i)return e;switch(e){case"%s":return String(n[r++]);case"%d":return Number(n[r++]);case"%j":try{return JSON.stringify(n[r++])}catch(e){return"[Circular]"}default:return e}})),a=n[r];r<i;a=n[++r])ct(a)||!dt(a)?o+=" "+a:o+=" "+tt(a);return o}function Ze(e,t){if(lt(o.process))return function(){return Ze(e,t).apply(this,arguments)};if(!0===I.noDeprecation)return e;var r=!1;return function(){if(!r){if(I.throwDeprecation)throw new Error(t);I.traceDeprecation?console.trace(t):console.error(t),r=!0}return e.apply(this,arguments)}}var Je,et={};function tt(e,t){var r={seen:[],stylize:nt};return arguments.length>=3&&(r.depth=arguments[2]),arguments.length>=4&&(r.colors=arguments[3]),st(t)?r.showHidden=t:t&&function(e,t){if(!t||!dt(t))return e;var r=Object.keys(t),n=r.length;for(;n--;)e[r[n]]=t[r[n]]}(r,t),lt(r.showHidden)&&(r.showHidden=!1),lt(r.depth)&&(r.depth=2),lt(r.colors)&&(r.colors=!1),lt(r.customInspect)&&(r.customInspect=!0),r.colors&&(r.stylize=rt),it(r,e,r.depth)}function rt(e,t){var r=tt.styles[t];return r?"["+tt.colors[r][0]+"m"+e+"["+tt.colors[r][1]+"m":e}function nt(e,t){return e}function it(e,t,r){if(e.customInspect&&t&&yt(t.inspect)&&t.inspect!==tt&&(!t.constructor||t.constructor.prototype!==t)){var n=t.inspect(r,e);return ut(n)||(n=it(e,n,r)),n}var i=function(e,t){if(lt(t))return e.stylize("undefined","undefined");if(ut(t)){var r="'"+JSON.stringify(t).replace(/^"|"$/g,"").replace(/'/g,"\\'").replace(/\\"/g,'"')+"'";return e.stylize(r,"string")}if(n=t,"number"==typeof n)return e.stylize(""+t,"number");var n;if(st(t))return e.stylize(""+t,"boolean");if(ct(t))return e.stylize("null","null")}(e,t);if(i)return i;var o=Object.keys(t),a=function(e){var t={};return e.forEach((function(e,r){t[e]=!0})),t}(o);if(e.showHidden&&(o=Object.getOwnPropertyNames(t)),pt(t)&&(o.indexOf("message")>=0||o.indexOf("description")>=0))return ot(t);if(0===o.length){if(yt(t)){var s=t.name?": "+t.name:"";return e.stylize("[Function"+s+"]","special")}if(ht(t))return e.stylize(RegExp.prototype.toString.call(t),"regexp");if(ft(t))return e.stylize(Date.prototype.toString.call(t),"date");if(pt(t))return ot(t)}var c,u,l="",h=!1,d=["{","}"];(c=t,Array.isArray(c)&&(h=!0,d=["[","]"]),yt(t))&&(l=" [Function"+(t.name?": "+t.name:"")+"]");return ht(t)&&(l=" "+RegExp.prototype.toString.call(t)),ft(t)&&(l=" "+Date.prototype.toUTCString.call(t)),pt(t)&&(l=" "+ot(t)),0!==o.length||h&&0!=t.length?r<0?ht(t)?e.stylize(RegExp.prototype.toString.call(t),"regexp"):e.stylize("[Object]","special"):(e.seen.push(t),u=h?function(e,t,r,n,i){for(var o=[],a=0,s=t.length;a<s;++a)mt(t,String(a))?o.push(at(e,t,r,n,String(a),!0)):o.push("");return i.forEach((function(i){i.match(/^\d+$/)||o.push(at(e,t,r,n,i,!0))})),o}(e,t,r,a,o):o.map((function(n){return at(e,t,r,a,n,h)})),e.seen.pop(),function(e,t,r){var n=e.reduce((function(e,t){return t.indexOf("\n"),e+t.replace(/\u001b\[\d\d?m/g,"").length+1}),0);if(n>60)return r[0]+(""===t?"":t+"\n ")+" "+e.join(",\n  ")+" "+r[1];return r[0]+t+" "+e.join(", ")+" "+r[1]}(u,l,d)):d[0]+l+d[1]}function ot(e){return"["+Error.prototype.toString.call(e)+"]"}function at(e,t,r,n,i,o){var a,s,c;if((c=Object.getOwnPropertyDescriptor(t,i)||{value:t[i]}).get?s=c.set?e.stylize("[Getter/Setter]","special"):e.stylize("[Getter]","special"):c.set&&(s=e.stylize("[Setter]","special")),mt(n,i)||(a="["+i+"]"),s||(e.seen.indexOf(c.value)<0?(s=ct(r)?it(e,c.value,null):it(e,c.value,r-1)).indexOf("\n")>-1&&(s=o?s.split("\n").map((function(e){return"  "+e})).join("\n").substr(2):"\n"+s.split("\n").map((function(e){return"   "+e})).join("\n")):s=e.stylize("[Circular]","special")),lt(a)){if(o&&i.match(/^\d+$/))return s;(a=JSON.stringify(""+i)).match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)?(a=a.substr(1,a.length-2),a=e.stylize(a,"name")):(a=a.replace(/'/g,"\\'").replace(/\\"/g,'"').replace(/(^"|"$)/g,"'"),a=e.stylize(a,"string"))}return a+": "+s}function st(e){return"boolean"==typeof e}function ct(e){return null===e}function ut(e){return"string"==typeof e}function lt(e){return void 0===e}function ht(e){return dt(e)&&"[object RegExp]"===gt(e)}function dt(e){return"object"==typeof e&&null!==e}function ft(e){return dt(e)&&"[object Date]"===gt(e)}function pt(e){return dt(e)&&("[object Error]"===gt(e)||e instanceof Error)}function yt(e){return"function"==typeof e}function gt(e){return Object.prototype.toString.call(e)}function mt(e,t){return Object.prototype.hasOwnProperty.call(e,t)}function vt(){this.head=null,this.tail=null,this.length=0}tt.colors={bold:[1,22],italic:[3,23],underline:[4,24],inverse:[7,27],white:[37,39],grey:[90,39],black:[30,39],blue:[34,39],cyan:[36,39],green:[32,39],magenta:[35,39],red:[31,39],yellow:[33,39]},tt.styles={special:"cyan",number:"yellow",boolean:"yellow",undefined:"grey",null:"bold",string:"green",date:"magenta",regexp:"red"},vt.prototype.push=function(e){var t={data:e,next:null};this.length>0?this.tail.next=t:this.head=t,this.tail=t,++this.length},vt.prototype.unshift=function(e){var t={data:e,next:this.head};0===this.length&&(this.tail=t),this.head=t,++this.length},vt.prototype.shift=function(){if(0!==this.length){var e=this.head.data;return 1===this.length?this.head=this.tail=null:this.head=this.head.next,--this.length,e}},vt.prototype.clear=function(){this.head=this.tail=null,this.length=0},vt.prototype.join=function(e){if(0===this.length)return"";for(var t=this.head,r=""+t.data;t=t.next;)r+=e+t.data;return r},vt.prototype.concat=function(e){if(0===this.length)return ne.alloc(0);if(1===this.length)return this.head.data;for(var t=ne.allocUnsafe(e>>>0),r=this.head,n=0;r;)r.data.copy(t,n),n+=r.data.length,r=r.next;return t};var bt=ne.isEncoding||function(e){switch(e&&e.toLowerCase()){case"hex":case"utf8":case"utf-8":case"ascii":case"binary":case"base64":case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":case"raw":return!0;default:return!1}};function wt(e){switch(this.encoding=(e||"utf8").toLowerCase().replace(/[-_]/,""),function(e){if(e&&!bt(e))throw new Error("Unknown encoding: "+e)}(e),this.encoding){case"utf8":this.surrogateSize=3;break;case"ucs2":case"utf16le":this.surrogateSize=2,this.detectIncompleteChar=At;break;case"base64":this.surrogateSize=3,this.detectIncompleteChar=Tt;break;default:return void(this.write=Et)}this.charBuffer=new ne(6),this.charReceived=0,this.charLength=0}function Et(e){return e.toString(this.encoding)}function At(e){this.charReceived=e.length%2,this.charLength=this.charReceived?2:0}function Tt(e){this.charReceived=e.length%3,this.charLength=this.charReceived?3:0}wt.prototype.write=function(e){for(var t="";this.charLength;){var r=e.length>=this.charLength-this.charReceived?this.charLength-this.charReceived:e.length;if(e.copy(this.charBuffer,this.charReceived,0,r),this.charReceived+=r,this.charReceived<this.charLength)return"";if(e=e.slice(r,e.length),!((i=(t=this.charBuffer.slice(0,this.charLength).toString(this.encoding)).charCodeAt(t.length-1))>=55296&&i<=56319)){if(this.charReceived=this.charLength=0,0===e.length)return t;break}this.charLength+=this.surrogateSize,t=""}this.detectIncompleteChar(e);var n=e.length;this.charLength&&(e.copy(this.charBuffer,0,e.length-this.charReceived,n),n-=this.charReceived);var i;n=(t+=e.toString(this.encoding,0,n)).length-1;if((i=t.charCodeAt(n))>=55296&&i<=56319){var o=this.surrogateSize;return this.charLength+=o,this.charReceived+=o,this.charBuffer.copy(this.charBuffer,o,0,o),e.copy(this.charBuffer,0,0,o),t.substring(0,n)}return t},wt.prototype.detectIncompleteChar=function(e){for(var t=e.length>=3?3:e.length;t>0;t--){var r=e[e.length-t];if(1==t&&r>>5==6){this.charLength=2;break}if(t<=2&&r>>4==14){this.charLength=3;break}if(t<=3&&r>>3==30){this.charLength=4;break}}this.charReceived=t},wt.prototype.end=function(e){var t="";if(e&&e.length&&(t=this.write(e)),this.charReceived){var r=this.charReceived,n=this.charBuffer,i=this.encoding;t+=n.slice(0,r).toString(i)}return t};var _t=Object.freeze({__proto__:null,StringDecoder:wt});Dt.ReadableState=Ot;var Ct=function(e){if(lt(Je)&&(Je=I.env.NODE_DEBUG||""),e=e.toUpperCase(),!et[e])if(new RegExp("\\b"+e+"\\b","i").test(Je)){et[e]=function(){var t=Xe.apply(null,arguments);console.error("%s %d: %s",e,0,t)}}else et[e]=function(){};return et[e]}("stream");function Ot(e,t){e=e||{},this.objectMode=!!e.objectMode,t instanceof tr&&(this.objectMode=this.objectMode||!!e.readableObjectMode);var r=e.highWaterMark,n=this.objectMode?16:16384;this.highWaterMark=r||0===r?r:n,this.highWaterMark=~~this.highWaterMark,this.buffer=new vt,this.length=0,this.pipes=null,this.pipesCount=0,this.flowing=null,this.ended=!1,this.endEmitted=!1,this.reading=!1,this.sync=!0,this.needReadable=!1,this.emittedReadable=!1,this.readableListening=!1,this.resumeScheduled=!1,this.defaultEncoding=e.defaultEncoding||"utf8",this.ranOut=!1,this.awaitDrain=0,this.readingMore=!1,this.decoder=null,this.encoding=null,e.encoding&&(this.decoder=new wt(e.encoding),this.encoding=e.encoding)}function Dt(e){if(!(this instanceof Dt))return new Dt(e);this._readableState=new Ot(e,this),this.readable=!0,e&&"function"==typeof e.read&&(this._read=e.read),He.call(this)}function xt(e,t,r,n,i){var o=function(e,t){var r=null;ne.isBuffer(t)||"string"==typeof t||null==t||e.objectMode||(r=new TypeError("Invalid non-string/buffer chunk"));return r}(t,r);if(o)e.emit("error",o);else if(null===r)t.reading=!1,function(e,t){if(t.ended)return;if(t.decoder){var r=t.decoder.end();r&&r.length&&(t.buffer.push(r),t.length+=t.objectMode?1:r.length)}t.ended=!0,St(e)}(e,t);else if(t.objectMode||r&&r.length>0)if(t.ended&&!i){var a=new Error("stream.push() after EOF");e.emit("error",a)}else if(t.endEmitted&&i){var s=new Error("stream.unshift() after end event");e.emit("error",s)}else{var c;!t.decoder||i||n||(r=t.decoder.write(r),c=!t.objectMode&&0===r.length),i||(t.reading=!1),c||(t.flowing&&0===t.length&&!t.sync?(e.emit("data",r),e.read(0)):(t.length+=t.objectMode?1:r.length,i?t.buffer.unshift(r):t.buffer.push(r),t.needReadable&&St(e))),function(e,t){t.readingMore||(t.readingMore=!0,m(Lt,e,t))}(e,t)}else i||(t.reading=!1);return function(e){return!e.ended&&(e.needReadable||e.length<e.highWaterMark||0===e.length)}(t)}Me(Dt,He),Dt.prototype.push=function(e,t){var r=this._readableState;return r.objectMode||"string"!=typeof e||(t=t||r.defaultEncoding)!==r.encoding&&(e=ne.from(e,t),t=""),xt(this,r,e,t,!1)},Dt.prototype.unshift=function(e){return xt(this,this._readableState,e,"",!0)},Dt.prototype.isPaused=function(){return!1===this._readableState.flowing},Dt.prototype.setEncoding=function(e){return this._readableState.decoder=new wt(e),this._readableState.encoding=e,this};var Rt=8388608;function Ft(e,t){return e<=0||0===t.length&&t.ended?0:t.objectMode?1:e!=e?t.flowing&&t.length?t.buffer.head.data.length:t.length:(e>t.highWaterMark&&(t.highWaterMark=function(e){return e>=Rt?e=Rt:(e--,e|=e>>>1,e|=e>>>2,e|=e>>>4,e|=e>>>8,e|=e>>>16,e++),e}(e)),e<=t.length?e:t.ended?t.length:(t.needReadable=!0,0))}function St(e){var t=e._readableState;t.needReadable=!1,t.emittedReadable||(Ct("emitReadable",t.flowing),t.emittedReadable=!0,t.sync?m(Nt,e):Nt(e))}function Nt(e){Ct("emit readable"),e.emit("readable"),Ut(e)}function Lt(e,t){for(var r=t.length;!t.reading&&!t.flowing&&!t.ended&&t.length<t.highWaterMark&&(Ct("maybeReadMore read 0"),e.read(0),r!==t.length);)r=t.length;t.readingMore=!1}function kt(e){Ct("readable nexttick read 0"),e.read(0)}function It(e,t){t.reading||(Ct("resume read 0"),e.read(0)),t.resumeScheduled=!1,t.awaitDrain=0,e.emit("resume"),Ut(e),t.flowing&&!t.reading&&e.read(0)}function Ut(e){var t=e._readableState;for(Ct("flow",t.flowing);t.flowing&&null!==e.read(););}function Pt(e,t){return 0===t.length?null:(t.objectMode?r=t.buffer.shift():!e||e>=t.length?(r=t.decoder?t.buffer.join(""):1===t.buffer.length?t.buffer.head.data:t.buffer.concat(t.length),t.buffer.clear()):r=function(e,t,r){var n;e<t.head.data.length?(n=t.head.data.slice(0,e),t.head.data=t.head.data.slice(e)):n=e===t.head.data.length?t.shift():r?function(e,t){var r=t.head,n=1,i=r.data;e-=i.length;for(;r=r.next;){var o=r.data,a=e>o.length?o.length:e;if(a===o.length?i+=o:i+=o.slice(0,e),0===(e-=a)){a===o.length?(++n,r.next?t.head=r.next:t.head=t.tail=null):(t.head=r,r.data=o.slice(a));break}++n}return t.length-=n,i}(e,t):function(e,t){var r=ne.allocUnsafe(e),n=t.head,i=1;n.data.copy(r),e-=n.data.length;for(;n=n.next;){var o=n.data,a=e>o.length?o.length:e;if(o.copy(r,r.length-e,0,a),0===(e-=a)){a===o.length?(++i,n.next?t.head=n.next:t.head=t.tail=null):(t.head=n,n.data=o.slice(a));break}++i}return t.length-=i,r}(e,t);return n}(e,t.buffer,t.decoder),r);var r}function jt(e){var t=e._readableState;if(t.length>0)throw new Error('"endReadable()" called on non-empty stream');t.endEmitted||(t.ended=!0,m(Bt,t,e))}function Bt(e,t){e.endEmitted||0!==e.length||(e.endEmitted=!0,t.readable=!1,t.emit("end"))}function Vt(e,t){for(var r=0,n=e.length;r<n;r++)if(e[r]===t)return r;return-1}function Mt(){}function $t(e,t,r){this.chunk=e,this.encoding=t,this.callback=r,this.next=null}function Kt(e,t){Object.defineProperty(this,"buffer",{get:Ze((function(){return this.getBuffer()}),"_writableState.buffer is deprecated. Use _writableState.getBuffer instead.")}),e=e||{},this.objectMode=!!e.objectMode,t instanceof tr&&(this.objectMode=this.objectMode||!!e.writableObjectMode);var r=e.highWaterMark,n=this.objectMode?16:16384;this.highWaterMark=r||0===r?r:n,this.highWaterMark=~~this.highWaterMark,this.needDrain=!1,this.ending=!1,this.ended=!1,this.finished=!1;var i=!1===e.decodeStrings;this.decodeStrings=!i,this.defaultEncoding=e.defaultEncoding||"utf8",this.length=0,this.writing=!1,this.corked=0,this.sync=!0,this.bufferProcessing=!1,this.onwrite=function(e){!function(e,t){var r=e._writableState,n=r.sync,i=r.writecb;if(function(e){e.writing=!1,e.writecb=null,e.length-=e.writelen,e.writelen=0}(r),t)!function(e,t,r,n,i){--t.pendingcb,r?m(i,n):i(n);e._writableState.errorEmitted=!0,e.emit("error",n)}(e,r,n,t,i);else{var o=Gt(r);o||r.corked||r.bufferProcessing||!r.bufferedRequest||zt(e,r),n?m(qt,e,r,o,i):qt(e,r,o,i)}}(t,e)},this.writecb=null,this.writelen=0,this.bufferedRequest=null,this.lastBufferedRequest=null,this.pendingcb=0,this.prefinished=!1,this.errorEmitted=!1,this.bufferedRequestCount=0,this.corkedRequestsFree=new Xt(this)}function Ht(e){if(!(this instanceof Ht||this instanceof tr))return new Ht(e);this._writableState=new Kt(e,this),this.writable=!0,e&&("function"==typeof e.write&&(this._write=e.write),"function"==typeof e.writev&&(this._writev=e.writev)),He.call(this)}function Yt(e,t,r,n,i,o,a){t.writelen=n,t.writecb=a,t.writing=!0,t.sync=!0,r?e._writev(i,t.onwrite):e._write(i,o,t.onwrite),t.sync=!1}function qt(e,t,r,n){r||function(e,t){0===t.length&&t.needDrain&&(t.needDrain=!1,e.emit("drain"))}(e,t),t.pendingcb--,n(),Qt(e,t)}function zt(e,t){t.bufferProcessing=!0;var r=t.bufferedRequest;if(e._writev&&r&&r.next){var n=t.bufferedRequestCount,i=new Array(n),o=t.corkedRequestsFree;o.entry=r;for(var a=0;r;)i[a]=r,r=r.next,a+=1;Yt(e,t,!0,t.length,i,"",o.finish),t.pendingcb++,t.lastBufferedRequest=null,o.next?(t.corkedRequestsFree=o.next,o.next=null):t.corkedRequestsFree=new Xt(t)}else{for(;r;){var s=r.chunk,c=r.encoding,u=r.callback;if(Yt(e,t,!1,t.objectMode?1:s.length,s,c,u),r=r.next,t.writing)break}null===r&&(t.lastBufferedRequest=null)}t.bufferedRequestCount=0,t.bufferedRequest=r,t.bufferProcessing=!1}function Gt(e){return e.ending&&0===e.length&&null===e.bufferedRequest&&!e.finished&&!e.writing}function Wt(e,t){t.prefinished||(t.prefinished=!0,e.emit("prefinish"))}function Qt(e,t){var r=Gt(t);return r&&(0===t.pendingcb?(Wt(e,t),t.finished=!0,e.emit("finish")):Wt(e,t)),r}function Xt(e){var t=this;this.next=null,this.entry=null,this.finish=function(r){var n=t.entry;for(t.entry=null;n;){var i=n.callback;e.pendingcb--,i(r),n=n.next}e.corkedRequestsFree?e.corkedRequestsFree.next=t:e.corkedRequestsFree=t}}Dt.prototype.read=function(e){Ct("read",e),e=parseInt(e,10);var t=this._readableState,r=e;if(0!==e&&(t.emittedReadable=!1),0===e&&t.needReadable&&(t.length>=t.highWaterMark||t.ended))return Ct("read: emitReadable",t.length,t.ended),0===t.length&&t.ended?jt(this):St(this),null;if(0===(e=Ft(e,t))&&t.ended)return 0===t.length&&jt(this),null;var n,i=t.needReadable;return Ct("need readable",i),(0===t.length||t.length-e<t.highWaterMark)&&Ct("length less than watermark",i=!0),t.ended||t.reading?Ct("reading or ended",i=!1):i&&(Ct("do read"),t.reading=!0,t.sync=!0,0===t.length&&(t.needReadable=!0),this._read(t.highWaterMark),t.sync=!1,t.reading||(e=Ft(r,t))),null===(n=e>0?Pt(e,t):null)?(t.needReadable=!0,e=0):t.length-=e,0===t.length&&(t.ended||(t.needReadable=!0),r!==e&&t.ended&&jt(this)),null!==n&&this.emit("data",n),n},Dt.prototype._read=function(e){this.emit("error",new Error("not implemented"))},Dt.prototype.pipe=function(e,t){var r=this,n=this._readableState;switch(n.pipesCount){case 0:n.pipes=e;break;case 1:n.pipes=[n.pipes,e];break;default:n.pipes.push(e)}n.pipesCount+=1,Ct("pipe count=%d opts=%j",n.pipesCount,t);var i=!t||!1!==t.end?a:u;function o(e){Ct("onunpipe"),e===r&&u()}function a(){Ct("onend"),e.end()}n.endEmitted?m(i):r.once("end",i),e.on("unpipe",o);var s=function(e){return function(){var t=e._readableState;Ct("pipeOnDrain",t.awaitDrain),t.awaitDrain&&t.awaitDrain--,0===t.awaitDrain&&e.listeners("data").length&&(t.flowing=!0,Ut(e))}}(r);e.on("drain",s);var c=!1;function u(){Ct("cleanup"),e.removeListener("close",f),e.removeListener("finish",p),e.removeListener("drain",s),e.removeListener("error",d),e.removeListener("unpipe",o),r.removeListener("end",a),r.removeListener("end",u),r.removeListener("data",h),c=!0,!n.awaitDrain||e._writableState&&!e._writableState.needDrain||s()}var l=!1;function h(t){Ct("ondata"),l=!1,!1!==e.write(t)||l||((1===n.pipesCount&&n.pipes===e||n.pipesCount>1&&-1!==Vt(n.pipes,e))&&!c&&(Ct("false write response, pause",r._readableState.awaitDrain),r._readableState.awaitDrain++,l=!0),r.pause())}function d(t){var r;Ct("onerror",t),y(),e.removeListener("error",d),0===(r="error",e.listeners(r).length)&&e.emit("error",t)}function f(){e.removeListener("finish",p),y()}function p(){Ct("onfinish"),e.removeListener("close",f),y()}function y(){Ct("unpipe"),r.unpipe(e)}return r.on("data",h),function(e,t,r){if("function"==typeof e.prependListener)return e.prependListener(t,r);e._events&&e._events[t]?Array.isArray(e._events[t])?e._events[t].unshift(r):e._events[t]=[r,e._events[t]]:e.on(t,r)}(e,"error",d),e.once("close",f),e.once("finish",p),e.emit("pipe",r),n.flowing||(Ct("pipe resume"),r.resume()),e},Dt.prototype.unpipe=function(e){var t=this._readableState;if(0===t.pipesCount)return this;if(1===t.pipesCount)return e&&e!==t.pipes||(e||(e=t.pipes),t.pipes=null,t.pipesCount=0,t.flowing=!1,e&&e.emit("unpipe",this)),this;if(!e){var r=t.pipes,n=t.pipesCount;t.pipes=null,t.pipesCount=0,t.flowing=!1;for(var i=0;i<n;i++)r[i].emit("unpipe",this);return this}var o=Vt(t.pipes,e);return-1===o||(t.pipes.splice(o,1),t.pipesCount-=1,1===t.pipesCount&&(t.pipes=t.pipes[0]),e.emit("unpipe",this)),this},Dt.prototype.on=function(e,t){var r=He.prototype.on.call(this,e,t);if("data"===e)!1!==this._readableState.flowing&&this.resume();else if("readable"===e){var n=this._readableState;n.endEmitted||n.readableListening||(n.readableListening=n.needReadable=!0,n.emittedReadable=!1,n.reading?n.length&&St(this):m(kt,this))}return r},Dt.prototype.addListener=Dt.prototype.on,Dt.prototype.resume=function(){var e=this._readableState;return e.flowing||(Ct("resume"),e.flowing=!0,function(e,t){t.resumeScheduled||(t.resumeScheduled=!0,m(It,e,t))}(this,e)),this},Dt.prototype.pause=function(){return Ct("call pause flowing=%j",this._readableState.flowing),!1!==this._readableState.flowing&&(Ct("pause"),this._readableState.flowing=!1,this.emit("pause")),this},Dt.prototype.wrap=function(e){var t=this._readableState,r=!1,n=this;for(var i in e.on("end",(function(){if(Ct("wrapped end"),t.decoder&&!t.ended){var e=t.decoder.end();e&&e.length&&n.push(e)}n.push(null)})),e.on("data",(function(i){(Ct("wrapped data"),t.decoder&&(i=t.decoder.write(i)),t.objectMode&&null==i)||(t.objectMode||i&&i.length)&&(n.push(i)||(r=!0,e.pause()))})),e)void 0===this[i]&&"function"==typeof e[i]&&(this[i]=function(t){return function(){return e[t].apply(e,arguments)}}(i));return function(e,t){for(var r=0,n=e.length;r<n;r++)t(e[r],r)}(["error","close","destroy","pause","resume"],(function(t){e.on(t,n.emit.bind(n,t))})),n._read=function(t){Ct("wrapped _read",t),r&&(r=!1,e.resume())},n},Dt._fromList=Pt,Ht.WritableState=Kt,Me(Ht,He),Kt.prototype.getBuffer=function(){for(var e=this.bufferedRequest,t=[];e;)t.push(e),e=e.next;return t},Ht.prototype.pipe=function(){this.emit("error",new Error("Cannot pipe, not readable"))},Ht.prototype.write=function(e,t,r){var n=this._writableState,i=!1;return"function"==typeof t&&(r=t,t=null),ne.isBuffer(e)?t="buffer":t||(t=n.defaultEncoding),"function"!=typeof r&&(r=Mt),n.ended?function(e,t){var r=new Error("write after end");e.emit("error",r),m(t,r)}(this,r):function(e,t,r,n){var i=!0,o=!1;return null===r?o=new TypeError("May not write null values to stream"):ne.isBuffer(r)||"string"==typeof r||void 0===r||t.objectMode||(o=new TypeError("Invalid non-string/buffer chunk")),o&&(e.emit("error",o),m(n,o),i=!1),i}(this,n,e,r)&&(n.pendingcb++,i=function(e,t,r,n,i){r=function(e,t,r){e.objectMode||!1===e.decodeStrings||"string"!=typeof t||(t=ne.from(t,r));return t}(t,r,n),ne.isBuffer(r)&&(n="buffer");var o=t.objectMode?1:r.length;t.length+=o;var a=t.length<t.highWaterMark;a||(t.needDrain=!0);if(t.writing||t.corked){var s=t.lastBufferedRequest;t.lastBufferedRequest=new $t(r,n,i),s?s.next=t.lastBufferedRequest:t.bufferedRequest=t.lastBufferedRequest,t.bufferedRequestCount+=1}else Yt(e,t,!1,o,r,n,i);return a}(this,n,e,t,r)),i},Ht.prototype.cork=function(){this._writableState.corked++},Ht.prototype.uncork=function(){var e=this._writableState;e.corked&&(e.corked--,e.writing||e.corked||e.finished||e.bufferProcessing||!e.bufferedRequest||zt(this,e))},Ht.prototype.setDefaultEncoding=function(e){if("string"==typeof e&&(e=e.toLowerCase()),!(["hex","utf8","utf-8","ascii","binary","base64","ucs2","ucs-2","utf16le","utf-16le","raw"].indexOf((e+"").toLowerCase())>-1))throw new TypeError("Unknown encoding: "+e);return this._writableState.defaultEncoding=e,this},Ht.prototype._write=function(e,t,r){r(new Error("not implemented"))},Ht.prototype._writev=null,Ht.prototype.end=function(e,t,r){var n=this._writableState;"function"==typeof e?(r=e,e=null,t=null):"function"==typeof t&&(r=t,t=null),null!=e&&this.write(e,t),n.corked&&(n.corked=1,this.uncork()),n.ending||n.finished||function(e,t,r){t.ending=!0,Qt(e,t),r&&(t.finished?m(r):e.once("finish",r));t.ended=!0,e.writable=!1}(this,n,r)},Me(tr,Dt);for(var Zt=Object.keys(Ht.prototype),Jt=0;Jt<Zt.length;Jt++){var er=Zt[Jt];tr.prototype[er]||(tr.prototype[er]=Ht.prototype[er])}function tr(e){if(!(this instanceof tr))return new tr(e);Dt.call(this,e),Ht.call(this,e),e&&!1===e.readable&&(this.readable=!1),e&&!1===e.writable&&(this.writable=!1),this.allowHalfOpen=!0,e&&!1===e.allowHalfOpen&&(this.allowHalfOpen=!1),this.once("end",rr)}function rr(){this.allowHalfOpen||this._writableState.ended||m(nr,this)}function nr(e){e.end()}function ir(e){this.afterTransform=function(t,r){return function(e,t,r){var n=e._transformState;n.transforming=!1;var i=n.writecb;if(!i)return e.emit("error",new Error("no writecb in Transform class"));n.writechunk=null,n.writecb=null,null!=r&&e.push(r);i(t);var o=e._readableState;o.reading=!1,(o.needReadable||o.length<o.highWaterMark)&&e._read(o.highWaterMark)}(e,t,r)},this.needTransform=!1,this.transforming=!1,this.writecb=null,this.writechunk=null,this.writeencoding=null}function or(e){if(!(this instanceof or))return new or(e);tr.call(this,e),this._transformState=new ir(this);var t=this;this._readableState.needReadable=!0,this._readableState.sync=!1,e&&("function"==typeof e.transform&&(this._transform=e.transform),"function"==typeof e.flush&&(this._flush=e.flush)),this.once("prefinish",(function(){"function"==typeof this._flush?this._flush((function(e){ar(t,e)})):ar(t)}))}function ar(e,t){if(t)return e.emit("error",t);var r=e._writableState,n=e._transformState;if(r.length)throw new Error("Calling transform done when ws.length != 0");if(n.transforming)throw new Error("Calling transform done when still transforming");return e.push(null)}function sr(e){if(!(this instanceof sr))return new sr(e);or.call(this,e)}function cr(){He.call(this)}Me(or,tr),or.prototype.push=function(e,t){return this._transformState.needTransform=!1,tr.prototype.push.call(this,e,t)},or.prototype._transform=function(e,t,r){throw new Error("Not implemented")},or.prototype._write=function(e,t,r){var n=this._transformState;if(n.writecb=r,n.writechunk=e,n.writeencoding=t,!n.transforming){var i=this._readableState;(n.needTransform||i.needReadable||i.length<i.highWaterMark)&&this._read(i.highWaterMark)}},or.prototype._read=function(e){var t=this._transformState;null!==t.writechunk&&t.writecb&&!t.transforming?(t.transforming=!0,this._transform(t.writechunk,t.writeencoding,t.afterTransform)):t.needTransform=!0},Me(sr,or),sr.prototype._transform=function(e,t,r){r(null,e)},Me(cr,He),cr.Readable=Dt,cr.Writable=Ht,cr.Duplex=tr,cr.Transform=or,cr.PassThrough=sr,cr.Stream=cr,cr.prototype.pipe=function(e,t){var r=this;function n(t){e.writable&&!1===e.write(t)&&r.pause&&r.pause()}function i(){r.readable&&r.resume&&r.resume()}r.on("data",n),e.on("drain",i),e._isStdio||t&&!1===t.end||(r.on("end",a),r.on("close",s));var o=!1;function a(){o||(o=!0,e.end())}function s(){o||(o=!0,"function"==typeof e.destroy&&e.destroy())}function c(e){if(u(),0===He.listenerCount(this,"error"))throw e}function u(){r.removeListener("data",n),e.removeListener("drain",i),r.removeListener("end",a),r.removeListener("close",s),r.removeListener("error",c),e.removeListener("error",c),r.removeListener("end",u),r.removeListener("close",u),e.removeListener("close",u)}return r.on("error",c),e.on("error",c),r.on("end",u),r.on("close",u),e.on("close",u),e.emit("pipe",r),e};var ur,lr,hr,dr,fr,pr,yr,gr,mr,vr,br,wr,Er,Ar,Tr,_r=r(Object.freeze({__proto__:null,Duplex:tr,PassThrough:sr,Readable:Dt,Stream:cr,Transform:or,Writable:Ht,default:cr})),Cr=r(_t);function Or(){return ur||(ur=1,function(e){e.parser=function(e,t){return new n(e,t)},e.SAXParser=n,e.SAXStream=o,e.createStream=function(e,t){return new o(e,t)},e.MAX_BUFFER_LENGTH=65536;var t,r=["comment","sgmlDecl","textNode","tagName","doctype","procInstName","procInstBody","entity","attribName","attribValue","cdata","script"];function n(t,i){if(!(this instanceof n))return new n(t,i);var o=this;!function(e){for(var t=0,n=r.length;t<n;t++)e[r[t]]=""}(o),o.q=o.c="",o.bufferCheckPosition=e.MAX_BUFFER_LENGTH,o.opt=i||{},o.opt.lowercase=o.opt.lowercase||o.opt.lowercasetags,o.looseCase=o.opt.lowercase?"toLowerCase":"toUpperCase",o.tags=[],o.closed=o.closedRoot=o.sawRoot=!1,o.tag=o.error=null,o.strict=!!t,o.noscript=!(!t&&!o.opt.noscript),o.state=T.BEGIN,o.strictEntities=o.opt.strictEntities,o.ENTITIES=o.strictEntities?Object.create(e.XML_ENTITIES):Object.create(e.ENTITIES),o.attribList=[],o.opt.xmlns&&(o.ns=Object.create(l)),void 0===o.opt.unquotedAttributeValues&&(o.opt.unquotedAttributeValues=!t),o.trackPosition=!1!==o.opt.position,o.trackPosition&&(o.position=o.line=o.column=0),C(o,"onready")}e.EVENTS=["text","processinginstruction","sgmldeclaration","doctype","comment","opentagstart","attribute","opentag","closetag","opencdata","cdata","closecdata","error","end","ready","script","opennamespace","closenamespace"],Object.create||(Object.create=function(e){function t(){}return t.prototype=e,new t}),Object.keys||(Object.keys=function(e){var t=[];for(var r in e)e.hasOwnProperty(r)&&t.push(r);return t}),n.prototype={end:function(){F(this)},write:function(t){var n=this;if(this.error)throw this.error;if(n.closed)return R(n,"Cannot write after close. Assign an onready handler.");if(null===t)return F(n);"object"==typeof t&&(t=t.toString());for(var i=0,o="";o=B(t,i++),n.c=o,o;)switch(n.trackPosition&&(n.position++,"\n"===o?(n.line++,n.column=0):n.column++),n.state){case T.BEGIN:if(n.state=T.BEGIN_WHITESPACE,"\ufeff"===o)continue;j(n,o);continue;case T.BEGIN_WHITESPACE:j(n,o);continue;case T.TEXT:if(n.sawRoot&&!n.closedRoot){for(var c=i-1;o&&"<"!==o&&"&"!==o;)(o=B(t,i++))&&n.trackPosition&&(n.position++,"\n"===o?(n.line++,n.column=0):n.column++);n.textNode+=t.substring(c,i-1)}"<"!==o||n.sawRoot&&n.closedRoot&&!n.strict?(y(o)||n.sawRoot&&!n.closedRoot||S(n,"Text data outside of root node."),"&"===o?n.state=T.TEXT_ENTITY:n.textNode+=o):(n.state=T.OPEN_WAKA,n.startTagPosition=n.position);continue;case T.SCRIPT:"<"===o?n.state=T.SCRIPT_ENDING:n.script+=o;continue;case T.SCRIPT_ENDING:"/"===o?n.state=T.CLOSE_TAG:(n.script+="<"+o,n.state=T.SCRIPT);continue;case T.OPEN_WAKA:if("!"===o)n.state=T.SGML_DECL,n.sgmlDecl="";else if(y(o));else if(v(h,o))n.state=T.OPEN_TAG,n.tagName=o;else if("/"===o)n.state=T.CLOSE_TAG,n.tagName="";else if("?"===o)n.state=T.PROC_INST,n.procInstName=n.procInstBody="";else{if(S(n,"Unencoded <"),n.startTagPosition+1<n.position){var u=n.position-n.startTagPosition;o=new Array(u).join(" ")+o}n.textNode+="<"+o,n.state=T.TEXT}continue;case T.SGML_DECL:if(n.sgmlDecl+o==="--"){n.state=T.COMMENT,n.comment="",n.sgmlDecl="";continue}n.doctype&&!0!==n.doctype&&n.sgmlDecl?(n.state=T.DOCTYPE_DTD,n.doctype+="<!"+n.sgmlDecl+o,n.sgmlDecl=""):(n.sgmlDecl+o).toUpperCase()===a?(O(n,"onopencdata"),n.state=T.CDATA,n.sgmlDecl="",n.cdata=""):(n.sgmlDecl+o).toUpperCase()===s?(n.state=T.DOCTYPE,(n.doctype||n.sawRoot)&&S(n,"Inappropriately located doctype declaration"),n.doctype="",n.sgmlDecl=""):">"===o?(O(n,"onsgmldeclaration",n.sgmlDecl),n.sgmlDecl="",n.state=T.TEXT):g(o)?(n.state=T.SGML_DECL_QUOTED,n.sgmlDecl+=o):n.sgmlDecl+=o;continue;case T.SGML_DECL_QUOTED:o===n.q&&(n.state=T.SGML_DECL,n.q=""),n.sgmlDecl+=o;continue;case T.DOCTYPE:">"===o?(n.state=T.TEXT,O(n,"ondoctype",n.doctype),n.doctype=!0):(n.doctype+=o,"["===o?n.state=T.DOCTYPE_DTD:g(o)&&(n.state=T.DOCTYPE_QUOTED,n.q=o));continue;case T.DOCTYPE_QUOTED:n.doctype+=o,o===n.q&&(n.q="",n.state=T.DOCTYPE);continue;case T.DOCTYPE_DTD:"]"===o?(n.doctype+=o,n.state=T.DOCTYPE):"<"===o?(n.state=T.OPEN_WAKA,n.startTagPosition=n.position):g(o)?(n.doctype+=o,n.state=T.DOCTYPE_DTD_QUOTED,n.q=o):n.doctype+=o;continue;case T.DOCTYPE_DTD_QUOTED:n.doctype+=o,o===n.q&&(n.state=T.DOCTYPE_DTD,n.q="");continue;case T.COMMENT:"-"===o?n.state=T.COMMENT_ENDING:n.comment+=o;continue;case T.COMMENT_ENDING:"-"===o?(n.state=T.COMMENT_ENDED,n.comment=x(n.opt,n.comment),n.comment&&O(n,"oncomment",n.comment),n.comment=""):(n.comment+="-"+o,n.state=T.COMMENT);continue;case T.COMMENT_ENDED:">"!==o?(S(n,"Malformed comment"),n.comment+="--"+o,n.state=T.COMMENT):n.doctype&&!0!==n.doctype?n.state=T.DOCTYPE_DTD:n.state=T.TEXT;continue;case T.CDATA:"]"===o?n.state=T.CDATA_ENDING:n.cdata+=o;continue;case T.CDATA_ENDING:"]"===o?n.state=T.CDATA_ENDING_2:(n.cdata+="]"+o,n.state=T.CDATA);continue;case T.CDATA_ENDING_2:">"===o?(n.cdata&&O(n,"oncdata",n.cdata),O(n,"onclosecdata"),n.cdata="",n.state=T.TEXT):"]"===o?n.cdata+="]":(n.cdata+="]]"+o,n.state=T.CDATA);continue;case T.PROC_INST:"?"===o?n.state=T.PROC_INST_ENDING:y(o)?n.state=T.PROC_INST_BODY:n.procInstName+=o;continue;case T.PROC_INST_BODY:if(!n.procInstBody&&y(o))continue;"?"===o?n.state=T.PROC_INST_ENDING:n.procInstBody+=o;continue;case T.PROC_INST_ENDING:">"===o?(O(n,"onprocessinginstruction",{name:n.procInstName,body:n.procInstBody}),n.procInstName=n.procInstBody="",n.state=T.TEXT):(n.procInstBody+="?"+o,n.state=T.PROC_INST_BODY);continue;case T.OPEN_TAG:v(d,o)?n.tagName+=o:(N(n),">"===o?I(n):"/"===o?n.state=T.OPEN_TAG_SLASH:(y(o)||S(n,"Invalid character in tag name"),n.state=T.ATTRIB));continue;case T.OPEN_TAG_SLASH:">"===o?(I(n,!0),U(n)):(S(n,"Forward-slash in opening tag not followed by >"),n.state=T.ATTRIB);continue;case T.ATTRIB:if(y(o))continue;">"===o?I(n):"/"===o?n.state=T.OPEN_TAG_SLASH:v(h,o)?(n.attribName=o,n.attribValue="",n.state=T.ATTRIB_NAME):S(n,"Invalid attribute name");continue;case T.ATTRIB_NAME:"="===o?n.state=T.ATTRIB_VALUE:">"===o?(S(n,"Attribute without value"),n.attribValue=n.attribName,k(n),I(n)):y(o)?n.state=T.ATTRIB_NAME_SAW_WHITE:v(d,o)?n.attribName+=o:S(n,"Invalid attribute name");continue;case T.ATTRIB_NAME_SAW_WHITE:if("="===o)n.state=T.ATTRIB_VALUE;else{if(y(o))continue;S(n,"Attribute without value"),n.tag.attributes[n.attribName]="",n.attribValue="",O(n,"onattribute",{name:n.attribName,value:""}),n.attribName="",">"===o?I(n):v(h,o)?(n.attribName=o,n.state=T.ATTRIB_NAME):(S(n,"Invalid attribute name"),n.state=T.ATTRIB)}continue;case T.ATTRIB_VALUE:if(y(o))continue;g(o)?(n.q=o,n.state=T.ATTRIB_VALUE_QUOTED):(n.opt.unquotedAttributeValues||R(n,"Unquoted attribute value"),n.state=T.ATTRIB_VALUE_UNQUOTED,n.attribValue=o);continue;case T.ATTRIB_VALUE_QUOTED:if(o!==n.q){"&"===o?n.state=T.ATTRIB_VALUE_ENTITY_Q:n.attribValue+=o;continue}k(n),n.q="",n.state=T.ATTRIB_VALUE_CLOSED;continue;case T.ATTRIB_VALUE_CLOSED:y(o)?n.state=T.ATTRIB:">"===o?I(n):"/"===o?n.state=T.OPEN_TAG_SLASH:v(h,o)?(S(n,"No whitespace between attributes"),n.attribName=o,n.attribValue="",n.state=T.ATTRIB_NAME):S(n,"Invalid attribute name");continue;case T.ATTRIB_VALUE_UNQUOTED:if(!m(o)){"&"===o?n.state=T.ATTRIB_VALUE_ENTITY_U:n.attribValue+=o;continue}k(n),">"===o?I(n):n.state=T.ATTRIB;continue;case T.CLOSE_TAG:if(n.tagName)">"===o?U(n):v(d,o)?n.tagName+=o:n.script?(n.script+="</"+n.tagName,n.tagName="",n.state=T.SCRIPT):(y(o)||S(n,"Invalid tagname in closing tag"),n.state=T.CLOSE_TAG_SAW_WHITE);else{if(y(o))continue;b(h,o)?n.script?(n.script+="</"+o,n.state=T.SCRIPT):S(n,"Invalid tagname in closing tag."):n.tagName=o}continue;case T.CLOSE_TAG_SAW_WHITE:if(y(o))continue;">"===o?U(n):S(n,"Invalid characters in closing tag");continue;case T.TEXT_ENTITY:case T.ATTRIB_VALUE_ENTITY_Q:case T.ATTRIB_VALUE_ENTITY_U:var l,w;switch(n.state){case T.TEXT_ENTITY:l=T.TEXT,w="textNode";break;case T.ATTRIB_VALUE_ENTITY_Q:l=T.ATTRIB_VALUE_QUOTED,w="attribValue";break;case T.ATTRIB_VALUE_ENTITY_U:l=T.ATTRIB_VALUE_UNQUOTED,w="attribValue"}if(";"===o){var E=P(n);n.opt.unparsedEntities&&!Object.values(e.XML_ENTITIES).includes(E)?(n.entity="",n.state=l,n.write(E)):(n[w]+=E,n.entity="",n.state=l)}else v(n.entity.length?p:f,o)?n.entity+=o:(S(n,"Invalid character in entity name"),n[w]+="&"+n.entity+o,n.entity="",n.state=l);continue;default:throw new Error(n,"Unknown state: "+n.state)}return n.position>=n.bufferCheckPosition&&function(t){for(var n=Math.max(e.MAX_BUFFER_LENGTH,10),i=0,o=0,a=r.length;o<a;o++){var s=t[r[o]].length;if(s>n)switch(r[o]){case"textNode":D(t);break;case"cdata":O(t,"oncdata",t.cdata),t.cdata="";break;case"script":O(t,"onscript",t.script),t.script="";break;default:R(t,"Max buffer length exceeded: "+r[o])}i=Math.max(i,s)}var c=e.MAX_BUFFER_LENGTH-i;t.bufferCheckPosition=c+t.position}(n),n}
+/*! http://mths.be/fromcodepoint v0.1.0 by @mathias */,resume:function(){return this.error=null,this},close:function(){return this.write(null)},flush:function(){var e;D(e=this),""!==e.cdata&&(O(e,"oncdata",e.cdata),e.cdata=""),""!==e.script&&(O(e,"onscript",e.script),e.script="")}};try{t=_r.Stream}catch(e){t=function(){}}t||(t=function(){});var i=e.EVENTS.filter((function(e){return"error"!==e&&"end"!==e}));function o(e,r){if(!(this instanceof o))return new o(e,r);t.apply(this),this._parser=new n(e,r),this.writable=!0,this.readable=!0;var a=this;this._parser.onend=function(){a.emit("end")},this._parser.onerror=function(e){a.emit("error",e),a._parser.error=null},this._decoder=null,i.forEach((function(e){Object.defineProperty(a,"on"+e,{get:function(){return a._parser["on"+e]},set:function(t){if(!t)return a.removeAllListeners(e),a._parser["on"+e]=t,t;a.on(e,t)},enumerable:!0,configurable:!1})}))}o.prototype=Object.create(t.prototype,{constructor:{value:o}}),o.prototype.write=function(e){if("function"==typeof ne.isBuffer&&ne.isBuffer(e)){if(!this._decoder){var t=Cr.StringDecoder;this._decoder=new t("utf8")}e=this._decoder.write(e)}return this._parser.write(e.toString()),this.emit("data",e),!0},o.prototype.end=function(e){return e&&e.length&&this.write(e),this._parser.end(),!0},o.prototype.on=function(e,r){var n=this;return n._parser["on"+e]||-1===i.indexOf(e)||(n._parser["on"+e]=function(){var t=1===arguments.length?[arguments[0]]:Array.apply(null,arguments);t.splice(0,0,e),n.emit.apply(n,t)}),t.prototype.on.call(n,e,r)};var a="[CDATA[",s="DOCTYPE",c="http://www.w3.org/XML/1998/namespace",u="http://www.w3.org/2000/xmlns/",l={xml:c,xmlns:u},h=/[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/,d=/[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040.\d-]/,f=/[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/,p=/[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040.\d-]/;function y(e){return" "===e||"\n"===e||"\r"===e||"\t"===e}function g(e){return'"'===e||"'"===e}function m(e){return">"===e||y(e)}function v(e,t){return e.test(t)}function b(e,t){return!v(e,t)}var w,E,A,T=0;for(var _ in e.STATE={BEGIN:T++,BEGIN_WHITESPACE:T++,TEXT:T++,TEXT_ENTITY:T++,OPEN_WAKA:T++,SGML_DECL:T++,SGML_DECL_QUOTED:T++,DOCTYPE:T++,DOCTYPE_QUOTED:T++,DOCTYPE_DTD:T++,DOCTYPE_DTD_QUOTED:T++,COMMENT_STARTING:T++,COMMENT:T++,COMMENT_ENDING:T++,COMMENT_ENDED:T++,CDATA:T++,CDATA_ENDING:T++,CDATA_ENDING_2:T++,PROC_INST:T++,PROC_INST_BODY:T++,PROC_INST_ENDING:T++,OPEN_TAG:T++,OPEN_TAG_SLASH:T++,ATTRIB:T++,ATTRIB_NAME:T++,ATTRIB_NAME_SAW_WHITE:T++,ATTRIB_VALUE:T++,ATTRIB_VALUE_QUOTED:T++,ATTRIB_VALUE_CLOSED:T++,ATTRIB_VALUE_UNQUOTED:T++,ATTRIB_VALUE_ENTITY_Q:T++,ATTRIB_VALUE_ENTITY_U:T++,CLOSE_TAG:T++,CLOSE_TAG_SAW_WHITE:T++,SCRIPT:T++,SCRIPT_ENDING:T++},e.XML_ENTITIES={amp:"&",gt:">",lt:"<",quot:'"',apos:"'"},e.ENTITIES={amp:"&",gt:">",lt:"<",quot:'"',apos:"'",AElig:198,Aacute:193,Acirc:194,Agrave:192,Aring:197,Atilde:195,Auml:196,Ccedil:199,ETH:208,Eacute:201,Ecirc:202,Egrave:200,Euml:203,Iacute:205,Icirc:206,Igrave:204,Iuml:207,Ntilde:209,Oacute:211,Ocirc:212,Ograve:210,Oslash:216,Otilde:213,Ouml:214,THORN:222,Uacute:218,Ucirc:219,Ugrave:217,Uuml:220,Yacute:221,aacute:225,acirc:226,aelig:230,agrave:224,aring:229,atilde:227,auml:228,ccedil:231,eacute:233,ecirc:234,egrave:232,eth:240,euml:235,iacute:237,icirc:238,igrave:236,iuml:239,ntilde:241,oacute:243,ocirc:244,ograve:242,oslash:248,otilde:245,ouml:246,szlig:223,thorn:254,uacute:250,ucirc:251,ugrave:249,uuml:252,yacute:253,yuml:255,copy:169,reg:174,nbsp:160,iexcl:161,cent:162,pound:163,curren:164,yen:165,brvbar:166,sect:167,uml:168,ordf:170,laquo:171,not:172,shy:173,macr:175,deg:176,plusmn:177,sup1:185,sup2:178,sup3:179,acute:180,micro:181,para:182,middot:183,cedil:184,ordm:186,raquo:187,frac14:188,frac12:189,frac34:190,iquest:191,times:215,divide:247,OElig:338,oelig:339,Scaron:352,scaron:353,Yuml:376,fnof:402,circ:710,tilde:732,Alpha:913,Beta:914,Gamma:915,Delta:916,Epsilon:917,Zeta:918,Eta:919,Theta:920,Iota:921,Kappa:922,Lambda:923,Mu:924,Nu:925,Xi:926,Omicron:927,Pi:928,Rho:929,Sigma:931,Tau:932,Upsilon:933,Phi:934,Chi:935,Psi:936,Omega:937,alpha:945,beta:946,gamma:947,delta:948,epsilon:949,zeta:950,eta:951,theta:952,iota:953,kappa:954,lambda:955,mu:956,nu:957,xi:958,omicron:959,pi:960,rho:961,sigmaf:962,sigma:963,tau:964,upsilon:965,phi:966,chi:967,psi:968,omega:969,thetasym:977,upsih:978,piv:982,ensp:8194,emsp:8195,thinsp:8201,zwnj:8204,zwj:8205,lrm:8206,rlm:8207,ndash:8211,mdash:8212,lsquo:8216,rsquo:8217,sbquo:8218,ldquo:8220,rdquo:8221,bdquo:8222,dagger:8224,Dagger:8225,bull:8226,hellip:8230,permil:8240,prime:8242,Prime:8243,lsaquo:8249,rsaquo:8250,oline:8254,frasl:8260,euro:8364,image:8465,weierp:8472,real:8476,trade:8482,alefsym:8501,larr:8592,uarr:8593,rarr:8594,darr:8595,harr:8596,crarr:8629,lArr:8656,uArr:8657,rArr:8658,dArr:8659,hArr:8660,forall:8704,part:8706,exist:8707,empty:8709,nabla:8711,isin:8712,notin:8713,ni:8715,prod:8719,sum:8721,minus:8722,lowast:8727,radic:8730,prop:8733,infin:8734,ang:8736,and:8743,or:8744,cap:8745,cup:8746,int:8747,there4:8756,sim:8764,cong:8773,asymp:8776,ne:8800,equiv:8801,le:8804,ge:8805,sub:8834,sup:8835,nsub:8836,sube:8838,supe:8839,oplus:8853,otimes:8855,perp:8869,sdot:8901,lceil:8968,rceil:8969,lfloor:8970,rfloor:8971,lang:9001,rang:9002,loz:9674,spades:9824,clubs:9827,hearts:9829,diams:9830},Object.keys(e.ENTITIES).forEach((function(t){var r=e.ENTITIES[t],n="number"==typeof r?String.fromCharCode(r):r;e.ENTITIES[t]=n})),e.STATE)e.STATE[e.STATE[_]]=_;function C(e,t,r){e[t]&&e[t](r)}function O(e,t,r){e.textNode&&D(e),C(e,t,r)}function D(e){e.textNode=x(e.opt,e.textNode),e.textNode&&C(e,"ontext",e.textNode),e.textNode=""}function x(e,t){return e.trim&&(t=t.trim()),e.normalize&&(t=t.replace(/\s+/g," ")),t}function R(e,t){return D(e),e.trackPosition&&(t+="\nLine: "+e.line+"\nColumn: "+e.column+"\nChar: "+e.c),t=new Error(t),e.error=t,C(e,"onerror",t),e}function F(e){return e.sawRoot&&!e.closedRoot&&S(e,"Unclosed root tag"),e.state!==T.BEGIN&&e.state!==T.BEGIN_WHITESPACE&&e.state!==T.TEXT&&R(e,"Unexpected end"),D(e),e.c="",e.closed=!0,C(e,"onend"),n.call(e,e.strict,e.opt),e}function S(e,t){if("object"!=typeof e||!(e instanceof n))throw new Error("bad call to strictFail");e.strict&&R(e,t)}function N(e){e.strict||(e.tagName=e.tagName[e.looseCase]());var t=e.tags[e.tags.length-1]||e,r=e.tag={name:e.tagName,attributes:{}};e.opt.xmlns&&(r.ns=t.ns),e.attribList.length=0,O(e,"onopentagstart",r)}function L(e,t){var r=e.indexOf(":")<0?["",e]:e.split(":"),n=r[0],i=r[1];return t&&"xmlns"===e&&(n="xmlns",i=""),{prefix:n,local:i}}function k(e){if(e.strict||(e.attribName=e.attribName[e.looseCase]()),-1!==e.attribList.indexOf(e.attribName)||e.tag.attributes.hasOwnProperty(e.attribName))e.attribName=e.attribValue="";else{if(e.opt.xmlns){var t=L(e.attribName,!0),r=t.prefix,n=t.local;if("xmlns"===r)if("xml"===n&&e.attribValue!==c)S(e,"xml: prefix must be bound to "+c+"\nActual: "+e.attribValue);else if("xmlns"===n&&e.attribValue!==u)S(e,"xmlns: prefix must be bound to "+u+"\nActual: "+e.attribValue);else{var i=e.tag,o=e.tags[e.tags.length-1]||e;i.ns===o.ns&&(i.ns=Object.create(o.ns)),i.ns[n]=e.attribValue}e.attribList.push([e.attribName,e.attribValue])}else e.tag.attributes[e.attribName]=e.attribValue,O(e,"onattribute",{name:e.attribName,value:e.attribValue});e.attribName=e.attribValue=""}}function I(e,t){if(e.opt.xmlns){var r=e.tag,n=L(e.tagName);r.prefix=n.prefix,r.local=n.local,r.uri=r.ns[n.prefix]||"",r.prefix&&!r.uri&&(S(e,"Unbound namespace prefix: "+JSON.stringify(e.tagName)),r.uri=n.prefix);var i=e.tags[e.tags.length-1]||e;r.ns&&i.ns!==r.ns&&Object.keys(r.ns).forEach((function(t){O(e,"onopennamespace",{prefix:t,uri:r.ns[t]})}));for(var o=0,a=e.attribList.length;o<a;o++){var s=e.attribList[o],c=s[0],u=s[1],l=L(c,!0),h=l.prefix,d=l.local,f=""===h?"":r.ns[h]||"",p={name:c,value:u,prefix:h,local:d,uri:f};h&&"xmlns"!==h&&!f&&(S(e,"Unbound namespace prefix: "+JSON.stringify(h)),p.uri=h),e.tag.attributes[c]=p,O(e,"onattribute",p)}e.attribList.length=0}e.tag.isSelfClosing=!!t,e.sawRoot=!0,e.tags.push(e.tag),O(e,"onopentag",e.tag),t||(e.noscript||"script"!==e.tagName.toLowerCase()?e.state=T.TEXT:e.state=T.SCRIPT,e.tag=null,e.tagName=""),e.attribName=e.attribValue="",e.attribList.length=0}function U(e){if(!e.tagName)return S(e,"Weird empty close tag."),e.textNode+="</>",void(e.state=T.TEXT);if(e.script){if("script"!==e.tagName)return e.script+="</"+e.tagName+">",e.tagName="",void(e.state=T.SCRIPT);O(e,"onscript",e.script),e.script=""}var t=e.tags.length,r=e.tagName;e.strict||(r=r[e.looseCase]());for(var n=r;t--&&e.tags[t].name!==n;)S(e,"Unexpected close tag");if(t<0)return S(e,"Unmatched closing tag: "+e.tagName),e.textNode+="</"+e.tagName+">",void(e.state=T.TEXT);e.tagName=r;for(var i=e.tags.length;i-- >t;){var o=e.tag=e.tags.pop();e.tagName=e.tag.name,O(e,"onclosetag",e.tagName);var a={};for(var s in o.ns)a[s]=o.ns[s];var c=e.tags[e.tags.length-1]||e;e.opt.xmlns&&o.ns!==c.ns&&Object.keys(o.ns).forEach((function(t){var r=o.ns[t];O(e,"onclosenamespace",{prefix:t,uri:r})}))}0===t&&(e.closedRoot=!0),e.tagName=e.attribValue=e.attribName="",e.attribList.length=0,e.state=T.TEXT}function P(e){var t,r=e.entity,n=r.toLowerCase(),i="";return e.ENTITIES[r]?e.ENTITIES[r]:e.ENTITIES[n]?e.ENTITIES[n]:("#"===(r=n).charAt(0)&&("x"===r.charAt(1)?(r=r.slice(2),i=(t=parseInt(r,16)).toString(16)):(r=r.slice(1),i=(t=parseInt(r,10)).toString(10))),r=r.replace(/^0+/,""),isNaN(t)||i.toLowerCase()!==r?(S(e,"Invalid character entity"),"&"+e.entity+";"):String.fromCodePoint(t))}function j(e,t){"<"===t?(e.state=T.OPEN_WAKA,e.startTagPosition=e.position):y(t)||(S(e,"Non-whitespace before first tag."),e.textNode=t,e.state=T.TEXT)}function B(e,t){var r="";return t<e.length&&(r=e.charAt(t)),r}T=e.STATE,String.fromCodePoint||(w=String.fromCharCode,E=Math.floor,A=function(){var e,t,r=[],n=-1,i=arguments.length;if(!i)return"";for(var o="";++n<i;){var a=Number(arguments[n]);if(!isFinite(a)||a<0||a>1114111||E(a)!==a)throw RangeError("Invalid code point: "+a);a<=65535?r.push(a):(e=55296+((a-=65536)>>10),t=a%1024+56320,r.push(e,t)),(n+1===i||r.length>16384)&&(o+=w.apply(null,r),r.length=0)}return o},Object.defineProperty?Object.defineProperty(String,"fromCodePoint",{value:A,configurable:!0,writable:!0}):String.fromCodePoint=A)}($e)),$e}function Dr(){return hr?lr:(hr=1,lr={isArray:function(e){return Array.isArray?Array.isArray(e):"[object Array]"===Object.prototype.toString.call(e)}})}function xr(){if(fr)return dr;fr=1;var e=Dr().isArray;return dr={copyOptions:function(e){var t,r={};for(t in e)e.hasOwnProperty(t)&&(r[t]=e[t]);return r},ensureFlagExists:function(e,t){e in t&&"boolean"==typeof t[e]||(t[e]=!1)},ensureSpacesExists:function(e){(!("spaces"in e)||"number"!=typeof e.spaces&&"string"!=typeof e.spaces)&&(e.spaces=0)},ensureAlwaysArrayExists:function(t){"alwaysArray"in t&&("boolean"==typeof t.alwaysArray||e(t.alwaysArray))||(t.alwaysArray=!1)},ensureKeyExists:function(e,t){e+"Key"in t&&"string"==typeof t[e+"Key"]||(t[e+"Key"]=t.compact?"_"+e:e)},checkFnExists:function(e,t){return e+"Fn"in t}}}function Rr(){if(yr)return pr;yr=1;var e,t,r=Or(),n=xr(),i=Dr().isArray;function o(e){var t=Number(e);if(!isNaN(t))return t;var r=e.toLowerCase();return"true"===r||"false"!==r&&e}function a(r,n){var o;if(e.compact){if(!t[e[r+"Key"]]&&(i(e.alwaysArray)?-1!==e.alwaysArray.indexOf(e[r+"Key"]):e.alwaysArray)&&(t[e[r+"Key"]]=[]),t[e[r+"Key"]]&&!i(t[e[r+"Key"]])&&(t[e[r+"Key"]]=[t[e[r+"Key"]]]),r+"Fn"in e&&"string"==typeof n&&(n=e[r+"Fn"](n,t)),"instruction"===r&&("instructionFn"in e||"instructionNameFn"in e))for(o in n)if(n.hasOwnProperty(o))if("instructionFn"in e)n[o]=e.instructionFn(n[o],o,t);else{var a=n[o];delete n[o],n[e.instructionNameFn(o,a,t)]=a}i(t[e[r+"Key"]])?t[e[r+"Key"]].push(n):t[e[r+"Key"]]=n}else{t[e.elementsKey]||(t[e.elementsKey]=[]);var s={};if(s[e.typeKey]=r,"instruction"===r){for(o in n)if(n.hasOwnProperty(o))break;s[e.nameKey]="instructionNameFn"in e?e.instructionNameFn(o,n,t):o,e.instructionHasAttributes?(s[e.attributesKey]=n[o][e.attributesKey],"instructionFn"in e&&(s[e.attributesKey]=e.instructionFn(s[e.attributesKey],o,t))):("instructionFn"in e&&(n[o]=e.instructionFn(n[o],o,t)),s[e.instructionKey]=n[o])}else r+"Fn"in e&&(n=e[r+"Fn"](n,t)),s[e[r+"Key"]]=n;e.addParent&&(s[e.parentKey]=t),t[e.elementsKey].push(s)}}function s(r){var n;if("attributesFn"in e&&r&&(r=e.attributesFn(r,t)),(e.trim||"attributeValueFn"in e||"attributeNameFn"in e||e.nativeTypeAttributes)&&r)for(n in r)if(r.hasOwnProperty(n)&&(e.trim&&(r[n]=r[n].trim()),e.nativeTypeAttributes&&(r[n]=o(r[n])),"attributeValueFn"in e&&(r[n]=e.attributeValueFn(r[n],n,t)),"attributeNameFn"in e)){var i=r[n];delete r[n],r[e.attributeNameFn(n,r[n],t)]=i}return r}function c(r){var n={};if(r.body&&("xml"===r.name.toLowerCase()||e.instructionHasAttributes)){for(var i,o=/([\w:-]+)\s*=\s*(?:"([^"]*)"|'([^']*)'|(\w+))\s*/g;null!==(i=o.exec(r.body));)n[i[1]]=i[2]||i[3]||i[4];n=s(n)}if("xml"===r.name.toLowerCase()){if(e.ignoreDeclaration)return;t[e.declarationKey]={},Object.keys(n).length&&(t[e.declarationKey][e.attributesKey]=n),e.addParent&&(t[e.declarationKey][e.parentKey]=t)}else{if(e.ignoreInstruction)return;e.trim&&(r.body=r.body.trim());var c={};e.instructionHasAttributes&&Object.keys(n).length?(c[r.name]={},c[r.name][e.attributesKey]=n):c[r.name]=r.body,a("instruction",c)}}function u(r,n){var o;if("object"==typeof r&&(n=r.attributes,r=r.name),n=s(n),"elementNameFn"in e&&(r=e.elementNameFn(r,t)),e.compact){var a;if(o={},!e.ignoreAttributes&&n&&Object.keys(n).length)for(a in o[e.attributesKey]={},n)n.hasOwnProperty(a)&&(o[e.attributesKey][a]=n[a]);!(r in t)&&(i(e.alwaysArray)?-1!==e.alwaysArray.indexOf(r):e.alwaysArray)&&(t[r]=[]),t[r]&&!i(t[r])&&(t[r]=[t[r]]),i(t[r])?t[r].push(o):t[r]=o}else t[e.elementsKey]||(t[e.elementsKey]=[]),(o={})[e.typeKey]="element",o[e.nameKey]=r,!e.ignoreAttributes&&n&&Object.keys(n).length&&(o[e.attributesKey]=n),e.alwaysChildren&&(o[e.elementsKey]=[]),t[e.elementsKey].push(o);o[e.parentKey]=t,t=o}function l(t){e.ignoreText||(t.trim()||e.captureSpacesBetweenElements)&&(e.trim&&(t=t.trim()),e.nativeType&&(t=o(t)),e.sanitize&&(t=t.replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;")),a("text",t))}function h(t){e.ignoreComment||(e.trim&&(t=t.trim()),a("comment",t))}function d(r){var n=t[e.parentKey];e.addParent||delete t[e.parentKey],t=n}function f(t){e.ignoreCdata||(e.trim&&(t=t.trim()),a("cdata",t))}function p(t){e.ignoreDoctype||(t=t.replace(/^ /,""),e.trim&&(t=t.trim()),a("doctype",t))}function y(e){e.note=e}return pr=function(i,o){var a=r.parser(!0,{}),s={};if(t=s,e=function(t){return e=n.copyOptions(t),n.ensureFlagExists("ignoreDeclaration",e),n.ensureFlagExists("ignoreInstruction",e),n.ensureFlagExists("ignoreAttributes",e),n.ensureFlagExists("ignoreText",e),n.ensureFlagExists("ignoreComment",e),n.ensureFlagExists("ignoreCdata",e),n.ensureFlagExists("ignoreDoctype",e),n.ensureFlagExists("compact",e),n.ensureFlagExists("alwaysChildren",e),n.ensureFlagExists("addParent",e),n.ensureFlagExists("trim",e),n.ensureFlagExists("nativeType",e),n.ensureFlagExists("nativeTypeAttributes",e),n.ensureFlagExists("sanitize",e),n.ensureFlagExists("instructionHasAttributes",e),n.ensureFlagExists("captureSpacesBetweenElements",e),n.ensureAlwaysArrayExists(e),n.ensureKeyExists("declaration",e),n.ensureKeyExists("instruction",e),n.ensureKeyExists("attributes",e),n.ensureKeyExists("text",e),n.ensureKeyExists("comment",e),n.ensureKeyExists("cdata",e),n.ensureKeyExists("doctype",e),n.ensureKeyExists("type",e),n.ensureKeyExists("name",e),n.ensureKeyExists("elements",e),n.ensureKeyExists("parent",e),n.checkFnExists("doctype",e),n.checkFnExists("instruction",e),n.checkFnExists("cdata",e),n.checkFnExists("comment",e),n.checkFnExists("text",e),n.checkFnExists("instructionName",e),n.checkFnExists("elementName",e),n.checkFnExists("attributeName",e),n.checkFnExists("attributeValue",e),n.checkFnExists("attributes",e),e}(o),a.opt={strictEntities:!0},a.onopentag=u,a.ontext=l,a.oncomment=h,a.onclosetag=d,a.onerror=y,a.oncdata=f,a.ondoctype=p,a.onprocessinginstruction=c,a.write(i).close(),s[e.elementsKey]){var g=s[e.elementsKey];delete s[e.elementsKey],s[e.elementsKey]=g,delete s.text}return s}}function Fr(){if(mr)return gr;mr=1;var e=xr(),t=Rr();return gr=function(r,n){var i,o,a,s;return i=function(t){var r=e.copyOptions(t);return e.ensureSpacesExists(r),r}(n),o=t(r,i),s="compact"in i&&i.compact?"_parent":"parent",a="addParent"in i&&i.addParent?JSON.stringify(o,(function(e,t){return e===s?"_":t}),i.spaces):JSON.stringify(o,null,i.spaces),a.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")},gr}function Sr(){if(br)return vr;br=1;var e,t,r=xr(),n=Dr().isArray;function i(e,t,r){return(!r&&e.spaces?"\n":"")+Array(t+1).join(e.spaces)}function o(r,n,o){if(n.ignoreAttributes)return"";"attributesFn"in n&&(r=n.attributesFn(r,t,e));var a,s,c,u,l=[];for(a in r)r.hasOwnProperty(a)&&null!==r[a]&&void 0!==r[a]&&(u=n.noQuotesForNativeAttributes&&"string"!=typeof r[a]?"":'"',s=(s=""+r[a]).replace(/"/g,"&quot;"),c="attributeNameFn"in n?n.attributeNameFn(a,s,t,e):a,l.push(n.spaces&&n.indentAttributes?i(n,o+1,!1):" "),l.push(c+"="+u+("attributeValueFn"in n?n.attributeValueFn(s,a,t,e):s)+u));return r&&Object.keys(r).length&&n.spaces&&n.indentAttributes&&l.push(i(n,o,!1)),l.join("")}function a(r,n,i){return e=r,t="xml",n.ignoreDeclaration?"":"<?xml"+o(r[n.attributesKey],n,i)+"?>"}function s(r,n,i){if(n.ignoreInstruction)return"";var a;for(a in r)if(r.hasOwnProperty(a))break;var s="instructionNameFn"in n?n.instructionNameFn(a,r[a],t,e):a;if("object"==typeof r[a])return e=r,t=s,"<?"+s+o(r[a][n.attributesKey],n,i)+"?>";var c=r[a]?r[a]:"";return"instructionFn"in n&&(c=n.instructionFn(c,a,t,e)),"<?"+s+(c?" "+c:"")+"?>"}function c(r,n){return n.ignoreComment?"":"\x3c!--"+("commentFn"in n?n.commentFn(r,t,e):r)+"--\x3e"}function u(r,n){return n.ignoreCdata?"":"<![CDATA["+("cdataFn"in n?n.cdataFn(r,t,e):r.replace("]]>","]]]]><![CDATA[>"))+"]]>"}function l(r,n){return n.ignoreDoctype?"":"<!DOCTYPE "+("doctypeFn"in n?n.doctypeFn(r,t,e):r)+">"}function h(r,n){return n.ignoreText?"":(r=(r=(r=""+r).replace(/&amp;/g,"&")).replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;"),"textFn"in n?n.textFn(r,t,e):r)}function d(r,n,a,f){return r.reduce((function(r,p){var y=i(n,a,f&&!r);switch(p.type){case"element":return r+y+function(r,n,i){e=r,t=r.name;var a=[],s="elementNameFn"in n?n.elementNameFn(r.name,r):r.name;a.push("<"+s),r[n.attributesKey]&&a.push(o(r[n.attributesKey],n,i));var c=r[n.elementsKey]&&r[n.elementsKey].length||r[n.attributesKey]&&"preserve"===r[n.attributesKey]["xml:space"];return c||(c="fullTagEmptyElementFn"in n?n.fullTagEmptyElementFn(r.name,r):n.fullTagEmptyElement),c?(a.push(">"),r[n.elementsKey]&&r[n.elementsKey].length&&(a.push(d(r[n.elementsKey],n,i+1)),e=r,t=r.name),a.push(n.spaces&&function(e,t){var r;if(e.elements&&e.elements.length)for(r=0;r<e.elements.length;++r)switch(e.elements[r][t.typeKey]){case"text":if(t.indentText)return!0;break;case"cdata":if(t.indentCdata)return!0;break;case"instruction":if(t.indentInstruction)return!0;break;default:return!0}return!1}(r,n)?"\n"+Array(i+1).join(n.spaces):""),a.push("</"+s+">")):a.push("/>"),a.join("")}(p,n,a);case"comment":return r+y+c(p[n.commentKey],n);case"doctype":return r+y+l(p[n.doctypeKey],n);case"cdata":return r+(n.indentCdata?y:"")+u(p[n.cdataKey],n);case"text":return r+(n.indentText?y:"")+h(p[n.textKey],n);case"instruction":var g={};return g[p[n.nameKey]]=p[n.attributesKey]?p:p[n.instructionKey],r+(n.indentInstruction?y:"")+s(g,n,a)}}),"")}function f(e,t,r){var n;for(n in e)if(e.hasOwnProperty(n))switch(n){case t.parentKey:case t.attributesKey:break;case t.textKey:if(t.indentText||r)return!0;break;case t.cdataKey:if(t.indentCdata||r)return!0;break;case t.instructionKey:if(t.indentInstruction||r)return!0;break;case t.doctypeKey:case t.commentKey:default:return!0}return!1}function p(r,n,a,s,c){e=r,t=n;var u="elementNameFn"in a?a.elementNameFn(n,r):n;if(null==r||""===r)return"fullTagEmptyElementFn"in a&&a.fullTagEmptyElementFn(n,r)||a.fullTagEmptyElement?"<"+u+"></"+u+">":"<"+u+"/>";var l=[];if(n){if(l.push("<"+u),"object"!=typeof r)return l.push(">"+h(r,a)+"</"+u+">"),l.join("");r[a.attributesKey]&&l.push(o(r[a.attributesKey],a,s));var d=f(r,a,!0)||r[a.attributesKey]&&"preserve"===r[a.attributesKey]["xml:space"];if(d||(d="fullTagEmptyElementFn"in a?a.fullTagEmptyElementFn(n,r):a.fullTagEmptyElement),!d)return l.push("/>"),l.join("");l.push(">")}return l.push(y(r,a,s+1,!1)),e=r,t=n,n&&l.push((c?i(a,s,!1):"")+"</"+u+">"),l.join("")}function y(e,t,r,o){var d,y,g,m=[];for(y in e)if(e.hasOwnProperty(y))for(g=n(e[y])?e[y]:[e[y]],d=0;d<g.length;++d){switch(y){case t.declarationKey:m.push(a(g[d],t,r));break;case t.instructionKey:m.push((t.indentInstruction?i(t,r,o):"")+s(g[d],t,r));break;case t.attributesKey:case t.parentKey:break;case t.textKey:m.push((t.indentText?i(t,r,o):"")+h(g[d],t));break;case t.cdataKey:m.push((t.indentCdata?i(t,r,o):"")+u(g[d],t));break;case t.doctypeKey:m.push(i(t,r,o)+l(g[d],t));break;case t.commentKey:m.push(i(t,r,o)+c(g[d],t));break;default:m.push(i(t,r,o)+p(g[d],y,t,r,f(g[d],t)))}o=o&&!m.length}return m.join("")}return vr=function(n,i){i=function(e){var t=r.copyOptions(e);return r.ensureFlagExists("ignoreDeclaration",t),r.ensureFlagExists("ignoreInstruction",t),r.ensureFlagExists("ignoreAttributes",t),r.ensureFlagExists("ignoreText",t),r.ensureFlagExists("ignoreComment",t),r.ensureFlagExists("ignoreCdata",t),r.ensureFlagExists("ignoreDoctype",t),r.ensureFlagExists("compact",t),r.ensureFlagExists("indentText",t),r.ensureFlagExists("indentCdata",t),r.ensureFlagExists("indentAttributes",t),r.ensureFlagExists("indentInstruction",t),r.ensureFlagExists("fullTagEmptyElement",t),r.ensureFlagExists("noQuotesForNativeAttributes",t),r.ensureSpacesExists(t),"number"==typeof t.spaces&&(t.spaces=Array(t.spaces+1).join(" ")),r.ensureKeyExists("declaration",t),r.ensureKeyExists("instruction",t),r.ensureKeyExists("attributes",t),r.ensureKeyExists("text",t),r.ensureKeyExists("comment",t),r.ensureKeyExists("cdata",t),r.ensureKeyExists("doctype",t),r.ensureKeyExists("type",t),r.ensureKeyExists("name",t),r.ensureKeyExists("elements",t),r.checkFnExists("doctype",t),r.checkFnExists("instruction",t),r.checkFnExists("cdata",t),r.checkFnExists("comment",t),r.checkFnExists("text",t),r.checkFnExists("instructionName",t),r.checkFnExists("elementName",t),r.checkFnExists("attributeName",t),r.checkFnExists("attributeValue",t),r.checkFnExists("attributes",t),r.checkFnExists("fullTagEmptyElement",t),t}(i);var o=[];return e=n,t="_root_",i.compact?o.push(y(n,i,0,!0)):(n[i.declarationKey]&&o.push(a(n[i.declarationKey],i,0)),n[i.elementsKey]&&n[i.elementsKey].length&&o.push(d(n[i.elementsKey],i,0,!o.length))),o.join("")}}function Nr(){if(Er)return wr;Er=1;var e=Sr();return wr=function(t,r){t instanceof ne&&(t=t.toString());var n=null;if("string"==typeof t)try{n=JSON.parse(t)}catch(e){throw new Error("The JSON structure is invalid")}else n=t;return e(n,r)}}var Lr=function(){if(Tr)return Ar;Tr=1;var e=Rr(),t=Fr(),r=Sr(),n=Nr();return Ar={xml2js:e,xml2json:t,js2xml:r,json2xml:n}}(),kr=t(Lr);const Ir=e=>{const t=Number(e);if(!Number.isNaN(t))return t;const r=e.toLowerCase();return"true"===r||"false"!==r&&e},Ur=(e,t)=>{if(!e&&!t)return!0;if(!e||!t)return!1;const r=e.trim(),n=t.trim();if(Math.abs(r.length-n.length)>1)return!1;const i="/"===r.slice(-1)?r.slice(0,-1):r,o="/"===n.slice(-1)?n.slice(0,-1):n;return e.includes(o)||t.includes(i)},Pr=(e,t)=>{if(!e&&!t)return!0;if(!e||!t)return!1;const r=e.trim(),n=t.trim(),i="/"===r.slice(-1)?r.slice(0,-1):r,o="/"===n.slice(-1)?n.slice(0,-1):n;return e.includes(o)||t.includes(i)},jr=e=>e.reduce(((e,t)=>({...e,[M[t]]:t})),{}),Br=e=>Object.entries(e).reduce(((e,[t,r])=>r?{...e,[t]:r}:e),{}),Vr=(e,t)=>t?{[e]:t}:{},Mr=(e,t)=>e?t&&0!==t.length?Object.fromEntries(Object.entries(e).filter((([e])=>!t.includes(e)))):e:{};var $r=Object.freeze({__proto__:null,cleanupFalsy:Br,conditionalParam:Vr,excludeHeaders:Mr,getDAVAttribute:jr,urlContains:Pr,urlEquals:Ur});const Kr=V("tsdav:request"),Hr=async e=>{var t;const{url:r,init:n,convertIncoming:i=!0,parseOutgoing:o=!0,fetchOptions:a={}}=e,{headers:s={},body:c,namespace:u,method:l,attributes:h}=n,d=i?kr.js2xml({_declaration:{_attributes:{version:"1.0",encoding:"utf-8"}},...c,_attributes:h},{compact:!0,spaces:2,elementNameFn:e=>u&&!/^.+:.+/.test(e)?`${u}:${e}`:e}):c,f=await fetch(r,{headers:{"Content-Type":"text/xml;charset=UTF-8",...Br(s)},body:d,method:l,...a}),p=await f.text();if(!f.ok||!(null===(t=f.headers.get("content-type"))||void 0===t?void 0:t.includes("xml"))||!o)return[{href:f.url,ok:f.ok,status:f.status,statusText:f.statusText,raw:p}];const y=kr.xml2js(p,{compact:!0,trim:!0,textFn:(e,t)=>{try{const r=t._parent,n=Object.keys(r),i=n[n.length-1],o=r[i];if(o.length>0){o[o.length-1]=Ir(e)}else r[i]=Ir(e)}catch(e){Kr(e.stack)}},elementNameFn:e=>e.replace(/^.+:/,"").replace(/([-_]\w)/g,(e=>e[1].toUpperCase())),attributesFn:e=>{const t={...e};return delete t.xmlns,t},ignoreDeclaration:!0});return(Array.isArray(y.multistatus.response)?y.multistatus.response:[y.multistatus.response]).map((e=>{var t,r;if(!e)return{status:f.status,statusText:f.statusText,ok:f.ok};const n=/^\S+\s(?<status>\d+)\s(?<statusText>.+)$/.exec(e.status);return{raw:y,href:e.href,status:(null==n?void 0:n.groups)?Number.parseInt(null==n?void 0:n.groups.status,10):f.status,statusText:null!==(r=null===(t=null==n?void 0:n.groups)||void 0===t?void 0:t.statusText)&&void 0!==r?r:f.statusText,ok:!e.error,error:e.error,responsedescription:e.responsedescription,props:(Array.isArray(e.propstat)?e.propstat:[e.propstat]).reduce(((e,t)=>({...e,...null==t?void 0:t.prop})),{})}}))},Yr=async e=>{const{url:t,props:r,depth:n,headers:i,headersToExclude:o,fetchOptions:a={}}=e;return Hr({url:t,init:{method:"PROPFIND",headers:Mr(Br({depth:n,...i}),o),namespace:$.DAV,body:{propfind:{_attributes:jr([j.CALDAV,j.CALDAV_APPLE,j.CALENDAR_SERVER,j.CARDDAV,j.DAV]),prop:r}}},fetchOptions:a})},qr=async e=>{const{url:t,data:r,headers:n,headersToExclude:i,fetchOptions:o={}}=e;return fetch(t,{method:"PUT",body:r,headers:Mr(n,i),...o})},zr=async e=>{const{url:t,data:r,etag:n,headers:i,headersToExclude:o,fetchOptions:a={}}=e;return fetch(t,{method:"PUT",body:r,headers:Mr(Br({"If-Match":n,...i}),o),...a})},Gr=async e=>{const{url:t,headers:r,etag:n,headersToExclude:i,fetchOptions:o={}}=e;return fetch(t,{method:"DELETE",headers:Mr(Br({"If-Match":n,...r}),i),...o})};var Wr=Object.freeze({__proto__:null,createObject:qr,davRequest:Hr,deleteObject:Gr,propfind:Yr,updateObject:zr});function Qr(e,t){const r=e=>t.every((t=>e[t]));return Array.isArray(e)?e.every((e=>r(e))):r(e)}const Xr=(e,t)=>t.reduce(((t,r)=>e[r]?t:`${t.length?`${t},`:""}${r.toString()}`),""),Zr=V("tsdav:collection"),Jr=async e=>{const{url:t,body:r,depth:n,defaultNamespace:i=$.DAV,headers:o,headersToExclude:a,fetchOptions:s={}}=e,c=await Hr({url:t,init:{method:"REPORT",headers:Mr(Br({depth:n,...o}),a),namespace:i,body:r},fetchOptions:s});return 1!==c.length||c[0].raw?c:[]},en=async e=>{const{url:t,props:r,depth:n,headers:i,headersToExclude:o,fetchOptions:a={}}=e;return Hr({url:t,init:{method:"MKCOL",headers:Mr(Br({depth:n,...i}),o),namespace:$.DAV,body:r?{mkcol:{set:{prop:r}}}:void 0},fetchOptions:a})},tn=async e=>{var t,r,n,i,o;const{collection:a,headers:s,headersToExclude:c,fetchOptions:u={}}=e;return null!==(o=null===(i=null===(n=null===(r=null===(t=(await Yr({url:a.url,props:{[`${$.DAV}:supported-report-set`]:{}},depth:"0",headers:Mr(s,c),fetchOptions:u}))[0])||void 0===t?void 0:t.props)||void 0===r?void 0:r.supportedReportSet)||void 0===n?void 0:n.supportedReport)||void 0===i?void 0:i.map((e=>Object.keys(e.report)[0])))&&void 0!==o?o:[]},rn=async e=>{var t,r,n;const{collection:i,headers:o,headersToExclude:a,fetchOptions:s={}}=e,c=(await Yr({url:i.url,props:{[`${$.CALENDAR_SERVER}:getctag`]:{}},depth:"0",headers:Mr(o,a),fetchOptions:s})).filter((e=>Pr(i.url,e.href)))[0];if(!c)throw new Error("Collection does not exist on server");return{isDirty:`${i.ctag}`!=`${null===(t=c.props)||void 0===t?void 0:t.getctag}`,newCtag:null===(n=null===(r=c.props)||void 0===r?void 0:r.getctag)||void 0===n?void 0:n.toString()}},nn=e=>{const{url:t,props:r,headers:n,syncLevel:i,syncToken:o,headersToExclude:a,fetchOptions:s}=e;return Hr({url:t,init:{method:"REPORT",namespace:$.DAV,headers:Mr({...n},a),body:{"sync-collection":{_attributes:jr([j.CALDAV,j.CARDDAV,j.DAV]),"sync-level":i,"sync-token":o,[`${$.DAV}:prop`]:r}}},fetchOptions:s})},on=async e=>{var t,r,n,i,o,a,s,c,u,l,h;const{collection:d,method:f,headers:p,headersToExclude:y,account:g,detailedResult:m,fetchOptions:v={}}=e,b=["accountType","homeUrl"];if(!g||!Qr(g,b)){if(!g)throw new Error("no account for smartCollectionSync");throw new Error(`account must have ${Xr(g,b)} before smartCollectionSync`)}const w=null!=f?f:(null===(t=d.reports)||void 0===t?void 0:t.includes("syncCollection"))?"webdav":"basic";if(Zr(`smart collection sync with type ${g.accountType} and method ${w}`),"webdav"===w){const e=await nn({url:d.url,props:{[`${$.DAV}:getetag`]:{},[`${"caldav"===g.accountType?$.CALDAV:$.CARDDAV}:${"caldav"===g.accountType?"calendar-data":"address-data"}`]:{},[`${$.DAV}:displayname`]:{}},syncLevel:1,syncToken:d.syncToken,headers:Mr(p,y),fetchOptions:v}),t=e.filter((e=>{var t;const r="caldav"===g.accountType?".ics":".vcf";return(null===(t=e.href)||void 0===t?void 0:t.slice(-4))===r})),u=t.filter((e=>404!==e.status)).map((e=>e.href)),l=t.filter((e=>404===e.status)).map((e=>e.href)),h=(u.length&&null!==(n=await(null===(r=null==d?void 0:d.objectMultiGet)||void 0===r?void 0:r.call(d,{url:d.url,props:{[`${$.DAV}:getetag`]:{},[`${"caldav"===g.accountType?$.CALDAV:$.CARDDAV}:${"caldav"===g.accountType?"calendar-data":"address-data"}`]:{}},objectUrls:u,depth:"1",headers:Mr(p,y),fetchOptions:v})))&&void 0!==n?n:[]).map((e=>{var t,r,n,i,o,a,s,c,u,l;return{url:null!==(t=e.href)&&void 0!==t?t:"",etag:null===(r=e.props)||void 0===r?void 0:r.getetag,data:"caldav"===(null==g?void 0:g.accountType)?null!==(o=null===(i=null===(n=e.props)||void 0===n?void 0:n.calendarData)||void 0===i?void 0:i._cdata)&&void 0!==o?o:null===(a=e.props)||void 0===a?void 0:a.calendarData:null!==(u=null===(c=null===(s=e.props)||void 0===s?void 0:s.addressData)||void 0===c?void 0:c._cdata)&&void 0!==u?u:null===(l=e.props)||void 0===l?void 0:l.addressData}})),f=null!==(i=d.objects)&&void 0!==i?i:[],b=h.filter((e=>f.every((t=>!Pr(t.url,e.url))))),w=f.reduce(((e,t)=>{const r=h.find((e=>Pr(e.url,t.url)));return r&&r.etag&&r.etag!==t.etag?[...e,r]:e}),[]),E=l.map((e=>({url:e,etag:""}))),A=f.filter((e=>h.some((t=>Pr(e.url,t.url)&&t.etag===e.etag))));return{...d,objects:m?{created:b,updated:w,deleted:E}:[...A,...b,...w],syncToken:null!==(c=null===(s=null===(a=null===(o=e[0])||void 0===o?void 0:o.raw)||void 0===a?void 0:a.multistatus)||void 0===s?void 0:s.syncToken)&&void 0!==c?c:d.syncToken}}if("basic"===w){const{isDirty:e,newCtag:t}=await rn({collection:d,headers:Mr(p,y),fetchOptions:v}),r=null!==(u=d.objects)&&void 0!==u?u:[],n=null!==(h=await(null===(l=d.fetchObjects)||void 0===l?void 0:l.call(d,{collection:d,headers:Mr(p,y),fetchOptions:v})))&&void 0!==h?h:[],i=n.filter((e=>r.every((t=>!Pr(t.url,e.url))))),o=r.reduce(((e,t)=>{const r=n.find((e=>Pr(e.url,t.url)));return r&&r.etag&&r.etag!==t.etag?[...e,r]:e}),[]),a=r.filter((e=>n.every((t=>!Pr(t.url,e.url))))),s=r.filter((e=>n.some((t=>Pr(e.url,t.url)&&t.etag===e.etag))));if(e)return{...d,objects:m?{created:i,updated:o,deleted:a}:[...s,...i,...o],ctag:t}}return m?{...d,objects:{created:[],updated:[],deleted:[]}}:d};var an=Object.freeze({__proto__:null,collectionQuery:Jr,isCollectionDirty:rn,makeCollection:en,smartCollectionSync:on,supportedReportSet:tn,syncCollection:nn});const sn=V("tsdav:addressBook"),cn=async e=>{const{url:t,props:r,filters:n,depth:i,headers:o,headersToExclude:a,fetchOptions:s={}}=e;return Jr({url:t,body:{"addressbook-query":Br({_attributes:jr([j.CARDDAV,j.DAV]),[`${$.DAV}:prop`]:r,filter:null!=n?n:{"prop-filter":{_attributes:{name:"FN"}}}})},defaultNamespace:$.CARDDAV,depth:i,headers:Mr(o,a),fetchOptions:s})},un=async e=>{const{url:t,props:r,objectUrls:n,depth:i,headers:o,headersToExclude:a,fetchOptions:s={}}=e;return Jr({url:t,body:{"addressbook-multiget":Br({_attributes:jr([j.DAV,j.CARDDAV]),[`${$.DAV}:prop`]:r,[`${$.DAV}:href`]:n})},defaultNamespace:$.CARDDAV,depth:i,headers:Mr(o,a),fetchOptions:s})},ln=async e=>{const{account:t,headers:r,props:n,headersToExclude:i,fetchOptions:o={}}=null!=e?e:{},a=["homeUrl","rootUrl"];if(!t||!Qr(t,a)){if(!t)throw new Error("no account for fetchAddressBooks");throw new Error(`account must have ${Xr(t,a)} before fetchAddressBooks`)}const s=await Yr({url:t.homeUrl,props:null!=n?n:{[`${$.DAV}:displayname`]:{},[`${$.CALENDAR_SERVER}:getctag`]:{},[`${$.DAV}:resourcetype`]:{},[`${$.DAV}:sync-token`]:{}},depth:"1",headers:Mr(r,i),fetchOptions:o});return Promise.all(s.filter((e=>{var t,r;return Object.keys(null!==(r=null===(t=e.props)||void 0===t?void 0:t.resourcetype)&&void 0!==r?r:{}).includes("addressbook")})).map((e=>{var r,n,i,o,a,s,c,u,l;const h=null!==(i=null===(n=null===(r=e.props)||void 0===r?void 0:r.displayname)||void 0===n?void 0:n._cdata)&&void 0!==i?i:null===(o=e.props)||void 0===o?void 0:o.displayname;return sn(`Found address book named ${"string"==typeof h?h:""},\n             props: ${JSON.stringify(e.props)}`),{url:new URL(null!==(a=e.href)&&void 0!==a?a:"",null!==(s=t.rootUrl)&&void 0!==s?s:"").href,ctag:null===(c=e.props)||void 0===c?void 0:c.getctag,displayName:"string"==typeof h?h:"",resourcetype:Object.keys(null===(u=e.props)||void 0===u?void 0:u.resourcetype),syncToken:null===(l=e.props)||void 0===l?void 0:l.syncToken}})).map((async e=>({...e,reports:await tn({collection:e,headers:Mr(r,i),fetchOptions:o})}))))},hn=async e=>{const{addressBook:t,headers:r,objectUrls:n,headersToExclude:i,urlFilter:o=e=>e,useMultiGet:a=!0,fetchOptions:s={}}=e;sn(`Fetching vcards from ${null==t?void 0:t.url}`);const c=["url"];if(!t||!Qr(t,c)){if(!t)throw new Error("cannot fetchVCards for undefined addressBook");throw new Error(`addressBook must have ${Xr(t,c)} before fetchVCards`)}const u=(null!=n?n:(await cn({url:t.url,props:{[`${$.DAV}:getetag`]:{}},depth:"1",headers:Mr(r,i),fetchOptions:s})).map((e=>{var t;return e.ok&&null!==(t=e.href)&&void 0!==t?t:""}))).map((e=>e.startsWith("http")||!e?e:new URL(e,t.url).href)).filter(o).map((e=>new URL(e).pathname));let l=[];return u.length>0&&(l=a?await un({url:t.url,props:{[`${$.DAV}:getetag`]:{},[`${$.CARDDAV}:address-data`]:{}},objectUrls:u,depth:"1",headers:Mr(r,i),fetchOptions:s}):await cn({url:t.url,props:{[`${$.DAV}:getetag`]:{},[`${$.CARDDAV}:address-data`]:{}},depth:"1",headers:Mr(r,i),fetchOptions:s})),l.map((e=>{var r,n,i,o,a,s;return{url:new URL(null!==(r=e.href)&&void 0!==r?r:"",t.url).href,etag:null===(n=e.props)||void 0===n?void 0:n.getetag,data:null!==(a=null===(o=null===(i=e.props)||void 0===i?void 0:i.addressData)||void 0===o?void 0:o._cdata)&&void 0!==a?a:null===(s=e.props)||void 0===s?void 0:s.addressData}}))},dn=async e=>{const{addressBook:t,vCardString:r,filename:n,headers:i,headersToExclude:o,fetchOptions:a={}}=e;return qr({url:new URL(n,t.url).href,data:r,headers:Mr({"content-type":"text/vcard; charset=utf-8","If-None-Match":"*",...i},o),fetchOptions:a})},fn=async e=>{const{vCard:t,headers:r,headersToExclude:n,fetchOptions:i={}}=e;return zr({url:t.url,data:t.data,etag:t.etag,headers:Mr({"content-type":"text/vcard; charset=utf-8",...r},n),fetchOptions:i})},pn=async e=>{const{vCard:t,headers:r,headersToExclude:n,fetchOptions:i={}}=e;return Gr({url:t.url,etag:t.etag,headers:Mr(r,n),fetchOptions:i})};var yn=Object.freeze({__proto__:null,addressBookMultiGet:un,addressBookQuery:cn,createVCard:dn,deleteVCard:pn,fetchAddressBooks:ln,fetchVCards:hn,updateVCard:fn});const gn=V("tsdav:calendar"),mn=async e=>{var t,r,n;const{account:i,headers:o,headersToExclude:a,fetchOptions:s={}}=e,c=["principalUrl","rootUrl"];if(!Qr(i,c))throw new Error(`account must have ${Xr(i,c)} before fetchUserAddresses`);gn(`Fetch user addresses from ${i.principalUrl}`);const u=(await Yr({url:i.principalUrl,props:{[`${$.CALDAV}:calendar-user-address-set`]:{}},depth:"0",headers:Mr(o,a),fetchOptions:s})).find((e=>Pr(i.principalUrl,e.href)));if(!u||!u.ok)throw new Error("cannot find calendarUserAddresses");const l=(null===(n=null===(r=null===(t=null==u?void 0:u.props)||void 0===t?void 0:t.calendarUserAddressSet)||void 0===r?void 0:r.href)||void 0===n?void 0:n.filter(Boolean))||[];return gn(`Fetched calendar user addresses ${l}`),l},vn=async e=>{const{url:t,props:r,filters:n,timezone:i,depth:o,headers:a,headersToExclude:s,fetchOptions:c={}}=e;return Jr({url:t,body:{"calendar-query":Br({_attributes:jr([j.CALDAV,j.CALENDAR_SERVER,j.CALDAV_APPLE,j.DAV]),[`${$.DAV}:prop`]:r,filter:n,timezone:i})},defaultNamespace:$.CALDAV,depth:o,headers:Mr(a,s),fetchOptions:c})},bn=async e=>{const{url:t,props:r,objectUrls:n,filters:i,timezone:o,depth:a,headers:s,headersToExclude:c,fetchOptions:u={}}=e;return Jr({url:t,body:{"calendar-multiget":Br({_attributes:jr([j.DAV,j.CALDAV]),[`${$.DAV}:prop`]:r,[`${$.DAV}:href`]:n,filter:i,timezone:o})},defaultNamespace:$.CALDAV,depth:a,headers:Mr(s,c),fetchOptions:u})},wn=async e=>{const{url:t,props:r,depth:n,headers:i,headersToExclude:o,fetchOptions:a={}}=e;return Hr({url:t,init:{method:"MKCALENDAR",headers:Mr(Br({depth:n,...i}),o),namespace:$.DAV,body:{[`${$.CALDAV}:mkcalendar`]:{_attributes:jr([j.DAV,j.CALDAV,j.CALDAV_APPLE]),set:{prop:r}}}},fetchOptions:a})},En=async e=>{const{headers:t,account:r,props:n,projectedProps:i,headersToExclude:o,fetchOptions:a={}}=null!=e?e:{},s=["homeUrl","rootUrl"];if(!r||!Qr(r,s)){if(!r)throw new Error("no account for fetchCalendars");throw new Error(`account must have ${Xr(r,s)} before fetchCalendars`)}const c=await Yr({url:r.homeUrl,props:null!=n?n:{[`${$.CALDAV}:calendar-description`]:{},[`${$.CALDAV}:calendar-timezone`]:{},[`${$.DAV}:displayname`]:{},[`${$.CALDAV_APPLE}:calendar-color`]:{},[`${$.CALENDAR_SERVER}:getctag`]:{},[`${$.DAV}:resourcetype`]:{},[`${$.CALDAV}:supported-calendar-component-set`]:{},[`${$.DAV}:sync-token`]:{}},depth:"1",headers:Mr(t,o),fetchOptions:a});return Promise.all(c.filter((e=>{var t,r;return Object.keys(null!==(r=null===(t=e.props)||void 0===t?void 0:t.resourcetype)&&void 0!==r?r:{}).includes("calendar")})).filter((e=>{var t,r,n,i;return(Array.isArray(null===(t=e.props)||void 0===t?void 0:t.supportedCalendarComponentSet.comp)?null===(r=e.props)||void 0===r?void 0:r.supportedCalendarComponentSet.comp.map((e=>e._attributes.name)):[null===(i=null===(n=e.props)||void 0===n?void 0:n.supportedCalendarComponentSet.comp)||void 0===i?void 0:i._attributes.name]).some((e=>Object.values(K).includes(e)))})).map((e=>{var t,n,o,a,s,c,u,l,h,d,f,p,y,g,m,v;const b=null===(t=e.props)||void 0===t?void 0:t.calendarDescription,w=null===(n=e.props)||void 0===n?void 0:n.calendarTimezone;return{description:"string"==typeof b?b:"",timezone:"string"==typeof w?w:"",url:new URL(null!==(o=e.href)&&void 0!==o?o:"",null!==(a=r.rootUrl)&&void 0!==a?a:"").href,ctag:null===(s=e.props)||void 0===s?void 0:s.getctag,calendarColor:null===(c=e.props)||void 0===c?void 0:c.calendarColor,displayName:null!==(l=null===(u=e.props)||void 0===u?void 0:u.displayname._cdata)&&void 0!==l?l:null===(h=e.props)||void 0===h?void 0:h.displayname,components:Array.isArray(null===(d=e.props)||void 0===d?void 0:d.supportedCalendarComponentSet.comp)?null===(f=e.props)||void 0===f?void 0:f.supportedCalendarComponentSet.comp.map((e=>e._attributes.name)):[null===(y=null===(p=e.props)||void 0===p?void 0:p.supportedCalendarComponentSet.comp)||void 0===y?void 0:y._attributes.name],resourcetype:Object.keys(null===(g=e.props)||void 0===g?void 0:g.resourcetype),syncToken:null===(m=e.props)||void 0===m?void 0:m.syncToken,...Vr("projectedProps",Object.fromEntries(Object.entries(null!==(v=e.props)&&void 0!==v?v:{}).filter((([e])=>null==i?void 0:i[e]))))}})).map((async e=>({...e,reports:await tn({collection:e,headers:Mr(t,o),fetchOptions:a})}))))},An=async e=>{const{calendar:t,objectUrls:r,filters:n,timeRange:i,headers:o,expand:a,urlFilter:s=e=>Boolean(null==e?void 0:e.includes(".ics")),useMultiGet:c=!0,headersToExclude:u,fetchOptions:l={}}=e;if(i){const e=/^\d{4}(-\d\d(-\d\d(T\d\d:\d\d(:\d\d)?(\.\d+)?(([+-]\d\d:\d\d)|Z)?)?)?)?$/i,t=/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(\.\d+)?(([+-]\d\d:\d\d)|Z)?$/i;if(!(e.test(i.start)&&e.test(i.end)||t.test(i.start)&&t.test(i.end)))throw new Error("invalid timeRange format, not in ISO8601")}gn(`Fetching calendar objects from ${null==t?void 0:t.url}`);const h=["url"];if(!t||!Qr(t,h)){if(!t)throw new Error("cannot fetchCalendarObjects for undefined calendar");throw new Error(`calendar must have ${Xr(t,h)} before fetchCalendarObjects`)}const d=null!=n?n:[{"comp-filter":{_attributes:{name:"VCALENDAR"},"comp-filter":{_attributes:{name:"VEVENT"},...i?{"time-range":{_attributes:{start:`${new Date(i.start).toISOString().slice(0,19).replace(/[-:.]/g,"")}Z`,end:`${new Date(i.end).toISOString().slice(0,19).replace(/[-:.]/g,"")}Z`}}}:{}}}}],f=(null!=r?r:(await vn({url:t.url,props:{[`${$.DAV}:getetag`]:{...a&&i?{[`${$.CALDAV}:expand`]:{_attributes:{start:`${new Date(i.start).toISOString().slice(0,19).replace(/[-:.]/g,"")}Z`,end:`${new Date(i.end).toISOString().slice(0,19).replace(/[-:.]/g,"")}Z`}}}:{}}},filters:d,depth:"1",headers:Mr(o,u),fetchOptions:l})).map((e=>{var t;return null!==(t=e.href)&&void 0!==t?t:""}))).map((e=>e.startsWith("http")||!e?e:new URL(e,t.url).href)).filter(s).map((e=>new URL(e).pathname));let p=[];return f.length>0&&(p=!c||a?await vn({url:t.url,props:{[`${$.DAV}:getetag`]:{},[`${$.CALDAV}:calendar-data`]:{...a&&i?{[`${$.CALDAV}:expand`]:{_attributes:{start:`${new Date(i.start).toISOString().slice(0,19).replace(/[-:.]/g,"")}Z`,end:`${new Date(i.end).toISOString().slice(0,19).replace(/[-:.]/g,"")}Z`}}}:{}}},filters:d,depth:"1",headers:Mr(o,u),fetchOptions:l}):await bn({url:t.url,props:{[`${$.DAV}:getetag`]:{},[`${$.CALDAV}:calendar-data`]:{...a&&i?{[`${$.CALDAV}:expand`]:{_attributes:{start:`${new Date(i.start).toISOString().slice(0,19).replace(/[-:.]/g,"")}Z`,end:`${new Date(i.end).toISOString().slice(0,19).replace(/[-:.]/g,"")}Z`}}}:{}}},objectUrls:f,depth:"1",headers:Mr(o,u),fetchOptions:l})),p.map((e=>{var r,n,i,o,a,s;return{url:new URL(null!==(r=e.href)&&void 0!==r?r:"",t.url).href,etag:`${null===(n=e.props)||void 0===n?void 0:n.getetag}`,data:null!==(a=null===(o=null===(i=e.props)||void 0===i?void 0:i.calendarData)||void 0===o?void 0:o._cdata)&&void 0!==a?a:null===(s=e.props)||void 0===s?void 0:s.calendarData}}))},Tn=async e=>{const{calendar:t,iCalString:r,filename:n,headers:i,headersToExclude:o,fetchOptions:a={}}=e;return qr({url:new URL(n,t.url).href,data:r,headers:Mr({"content-type":"text/calendar; charset=utf-8","If-None-Match":"*",...i},o),fetchOptions:a})},_n=async e=>{const{calendarObject:t,headers:r,headersToExclude:n,fetchOptions:i={}}=e;return zr({url:t.url,data:t.data,etag:t.etag,headers:Mr({"content-type":"text/calendar; charset=utf-8",...r},n),fetchOptions:i})},Cn=async e=>{const{calendarObject:t,headers:r,headersToExclude:n,fetchOptions:i={}}=e;return Gr({url:t.url,etag:t.etag,headers:Mr(r,n),fetchOptions:i})},On=async e=>{var t;const{oldCalendars:r,account:n,detailedResult:i,headers:o,headersToExclude:a,fetchOptions:s={}}=e;if(!n)throw new Error("Must have account before syncCalendars");const c=null!==(t=null!=r?r:n.calendars)&&void 0!==t?t:[],u=await En({account:n,headers:Mr(o,a),fetchOptions:s}),l=u.filter((e=>c.every((t=>!Pr(t.url,e.url)))));gn(`new calendars: ${l.map((e=>e.displayName))}`);const h=c.reduce(((e,t)=>{const r=u.find((e=>Pr(e.url,t.url)));return r&&(r.syncToken&&`${r.syncToken}`!=`${t.syncToken}`||r.ctag&&`${r.ctag}`!=`${t.ctag}`)?[...e,r]:e}),[]);gn(`updated calendars: ${h.map((e=>e.displayName))}`);const d=await Promise.all(h.map((async e=>await on({collection:{...e,objectMultiGet:bn},method:"webdav",headers:Mr(o,a),account:n,fetchOptions:s})))),f=c.filter((e=>u.every((t=>!Pr(t.url,e.url)))));gn(`deleted calendars: ${f.map((e=>e.displayName))}`);const p=c.filter((e=>u.some((t=>Pr(t.url,e.url)&&(t.syncToken&&`${t.syncToken}`!=`${e.syncToken}`||t.ctag&&`${t.ctag}`!=`${e.ctag}`)))));return i?{created:l,updated:h,deleted:f}:[...p,...l,...d]},Dn=async e=>{const{url:t,timeRange:r,depth:n,headers:i,headersToExclude:o,fetchOptions:a={}}=e;if(!r)throw new Error("timeRange is required");{const e=/^\d{4}(-\d\d(-\d\d(T\d\d:\d\d(:\d\d)?(\.\d+)?(([+-]\d\d:\d\d)|Z)?)?)?)?$/i,t=/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(\.\d+)?(([+-]\d\d:\d\d)|Z)?$/i;if(!(e.test(r.start)&&e.test(r.end)||t.test(r.start)&&t.test(r.end)))throw new Error("invalid timeRange format, not in ISO8601")}return(await Jr({url:t,body:{"free-busy-query":Br({_attributes:jr([j.CALDAV]),[`${$.CALDAV}:time-range`]:{_attributes:{start:`${new Date(r.start).toISOString().slice(0,19).replace(/[-:.]/g,"")}Z`,end:`${new Date(r.end).toISOString().slice(0,19).replace(/[-:.]/g,"")}Z`}}})},defaultNamespace:$.CALDAV,depth:n,headers:Mr(i,o),fetchOptions:a}))[0]};var xn=Object.freeze({__proto__:null,calendarMultiGet:bn,calendarQuery:vn,createCalendarObject:Tn,deleteCalendarObject:Cn,fetchCalendarObjects:An,fetchCalendarUserAddresses:mn,fetchCalendars:En,freeBusyQuery:Dn,makeCalendar:wn,syncCalendars:On,updateCalendarObject:_n});const Rn=V("tsdav:account"),Fn=async e=>{var t,r;Rn("Service discovery...");const{account:n,headers:i,headersToExclude:o,fetchOptions:a={}}=e,s=new URL(n.serverUrl),c=new URL(`/.well-known/${n.accountType}`,s);c.protocol=null!==(t=s.protocol)&&void 0!==t?t:"http";try{const e=await fetch(c.href,{headers:Mr(i,o),method:"PROPFIND",redirect:"manual",...a});if(e.status>=300&&e.status<400){const t=e.headers.get("Location");if("string"==typeof t&&t.length){Rn(`Service discovery redirected to ${t}`);const e=new URL(t,s);return e.hostname===c.hostname&&c.port&&!e.port&&(e.port=c.port),e.protocol=null!==(r=s.protocol)&&void 0!==r?r:"http",e.href}}}catch(e){Rn(`Service discovery failed: ${e.stack}`)}return s.href},Sn=async e=>{var t,r,n,i,o;const{account:a,headers:s,headersToExclude:c,fetchOptions:u={}}=e,l=["rootUrl"];if(!Qr(a,l))throw new Error(`account must have ${Xr(a,l)} before fetchPrincipalUrl`);Rn(`Fetching principal url from path ${a.rootUrl}`);const[h]=await Yr({url:a.rootUrl,props:{[`${$.DAV}:current-user-principal`]:{}},depth:"0",headers:Mr(s,c),fetchOptions:u});if(!h.ok&&(Rn(`Fetch principal url failed: ${h.statusText}`),401===h.status))throw new Error("Invalid credentials");return Rn(`Fetched principal url ${null===(r=null===(t=h.props)||void 0===t?void 0:t.currentUserPrincipal)||void 0===r?void 0:r.href}`),new URL(null!==(o=null===(i=null===(n=h.props)||void 0===n?void 0:n.currentUserPrincipal)||void 0===i?void 0:i.href)&&void 0!==o?o:"",a.rootUrl).href},Nn=async e=>{var t,r;const{account:n,headers:i,headersToExclude:o,fetchOptions:a={}}=e,s=["principalUrl","rootUrl"];if(!Qr(n,s))throw new Error(`account must have ${Xr(n,s)} before fetchHomeUrl`);Rn(`Fetch home url from ${n.principalUrl}`);const c=(await Yr({url:n.principalUrl,props:"caldav"===n.accountType?{[`${$.CALDAV}:calendar-home-set`]:{}}:{[`${$.CARDDAV}:addressbook-home-set`]:{}},depth:"0",headers:Mr(i,o),fetchOptions:a})).find((e=>Pr(n.principalUrl,e.href)));if(!c||!c.ok)throw new Error("cannot find homeUrl");const u=new URL("caldav"===n.accountType?null===(t=null==c?void 0:c.props)||void 0===t?void 0:t.calendarHomeSet.href:null===(r=null==c?void 0:c.props)||void 0===r?void 0:r.addressbookHomeSet.href,n.rootUrl).href;return Rn(`Fetched home url ${u}`),u},Ln=async e=>{const{account:t,headers:r,loadCollections:n=!1,loadObjects:i=!1,headersToExclude:o,fetchOptions:a={}}=e,s={...t};return s.rootUrl=await Fn({account:t,headers:Mr(r,o),fetchOptions:a}),s.principalUrl=await Sn({account:s,headers:Mr(r,o),fetchOptions:a}),s.homeUrl=await Nn({account:s,headers:Mr(r,o),fetchOptions:a}),(n||i)&&("caldav"===t.accountType?s.calendars=await En({headers:Mr(r,o),account:s,fetchOptions:a}):"carddav"===t.accountType&&(s.addressBooks=await ln({headers:Mr(r,o),account:s,fetchOptions:a}))),i&&("caldav"===t.accountType&&s.calendars?s.calendars=await Promise.all(s.calendars.map((async e=>({...e,objects:await An({calendar:e,headers:Mr(r,o),fetchOptions:a})})))):"carddav"===t.accountType&&s.addressBooks&&(s.addressBooks=await Promise.all(s.addressBooks.map((async e=>({...e,objects:await hn({addressBook:e,headers:Mr(r,o),fetchOptions:a})})))))),s};var kn,In=Object.freeze({__proto__:null,createAccount:Ln,fetchHomeUrl:Nn,fetchPrincipalUrl:Sn,serviceDiscovery:Fn}),Un={exports:{}};var Pn,jn,Bn=(kn||(kn=1,Pn=Un,jn=Un.exports,function(t){var r=jn,n=Pn&&Pn.exports==r&&Pn,i="object"==typeof e&&e;i.global!==i&&i.window!==i||(t=i);var o=function(e){this.message=e};(o.prototype=new Error).name="InvalidCharacterError";var a=function(e){throw new o(e)},s="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",c=/[\t\n\f\r ]/g,u={encode:function(e){e=String(e),/[^\0-\xFF]/.test(e)&&a("The string to be encoded contains characters outside of the Latin1 range.");for(var t,r,n,i,o=e.length%3,c="",u=-1,l=e.length-o;++u<l;)t=e.charCodeAt(u)<<16,r=e.charCodeAt(++u)<<8,n=e.charCodeAt(++u),c+=s.charAt((i=t+r+n)>>18&63)+s.charAt(i>>12&63)+s.charAt(i>>6&63)+s.charAt(63&i);return 2==o?(t=e.charCodeAt(u)<<8,r=e.charCodeAt(++u),c+=s.charAt((i=t+r)>>10)+s.charAt(i>>4&63)+s.charAt(i<<2&63)+"="):1==o&&(i=e.charCodeAt(u),c+=s.charAt(i>>2)+s.charAt(i<<4&63)+"=="),c},decode:function(e){var t=(e=String(e).replace(c,"")).length;t%4==0&&(t=(e=e.replace(/==?$/,"")).length),(t%4==1||/[^+a-zA-Z0-9/]/.test(e))&&a("Invalid character: the string to be decoded is not correctly encoded.");for(var r,n,i=0,o="",u=-1;++u<t;)n=s.indexOf(e.charAt(u)),r=i%4?64*r+n:n,i++%4&&(o+=String.fromCharCode(255&r>>(-2*i&6)));return o},version:"1.0.0"};if(r&&!r.nodeType)if(n)n.exports=u;else for(var l in u)u.hasOwnProperty(l)&&(r[l]=u[l]);else t.base64=u}(Un.exports)),Un.exports);const Vn=V("tsdav:authHelper"),Mn=(e,t)=>(...r)=>e({...t,...r[0]}),$n=e=>(Vn(`Basic auth token generated: ${Bn.encode(`${e.username}:${e.password}`)}`),{authorization:`Basic ${Bn.encode(`${e.username}:${e.password}`)}`}),Kn=async(e,t)=>{const r=["authorizationCode","redirectUrl","clientId","clientSecret","tokenUrl"];if(!Qr(e,r))throw new Error(`Oauth credentials missing: ${Xr(e,r)}`);const n=new URLSearchParams({grant_type:"authorization_code",code:e.authorizationCode,redirect_uri:e.redirectUrl,client_id:e.clientId,client_secret:e.clientSecret});Vn(e.tokenUrl),Vn(n.toString());const i=await fetch(e.tokenUrl,{method:"POST",body:n.toString(),headers:{"content-length":`${n.toString().length}`,"content-type":"application/x-www-form-urlencoded"},...null!=t?t:{}});if(i.ok){return await i.json()}return Vn(`Fetch Oauth tokens failed: ${await i.text()}`),{}},Hn=async(e,t)=>{const r=["refreshToken","clientId","clientSecret","tokenUrl"];if(!Qr(e,r))throw new Error(`Oauth credentials missing: ${Xr(e,r)}`);const n=new URLSearchParams({client_id:e.clientId,client_secret:e.clientSecret,refresh_token:e.refreshToken,grant_type:"refresh_token"}),i=await fetch(e.tokenUrl,{method:"POST",body:n.toString(),headers:{"Content-Type":"application/x-www-form-urlencoded"},...null!=t?t:{}});if(i.ok){return await i.json()}return Vn(`Refresh access token failed: ${await i.text()}`),{}},Yn=async(e,t)=>{var r;Vn("Fetching oauth headers");let n={};return e.refreshToken?(e.refreshToken&&!e.accessToken||Date.now()>(null!==(r=e.expiration)&&void 0!==r?r:0))&&(n=await Hn(e,t)):n=await Kn(e,t),Vn(`Oauth tokens fetched: ${n.access_token}`),{tokens:n,headers:{authorization:`Bearer ${n.access_token}`}}};var qn=Object.freeze({__proto__:null,defaultParam:Mn,fetchOauthTokens:Kn,getBasicAuthHeaders:$n,getOauthHeaders:Yn,refreshAccessToken:Hn});const zn=async e=>{var t;const{serverUrl:r,credentials:n,authMethod:i,defaultAccountType:o,authFunction:a}=e;let s={};switch(i){case"Basic":s=$n(n);break;case"Oauth":s=(await Yn(n)).headers;break;case"Digest":s={Authorization:`Digest ${n.digestString}`};break;case"Custom":s=null!==(t=await(null==a?void 0:a(n)))&&void 0!==t?t:{};break;default:throw new Error("Invalid auth method")}const c=o?await Ln({account:{serverUrl:r,credentials:n,accountType:o},headers:s}):void 0,u=Mn(qr,{url:r,headers:s}),l=Mn(zr,{headers:s,url:r}),h=Mn(Gr,{headers:s,url:r}),d=Mn(Yr,{headers:s}),f=Mn(Jr,{headers:s}),p=Mn(en,{headers:s}),y=Mn(nn,{headers:s}),g=Mn(tn,{headers:s}),m=Mn(rn,{headers:s}),v=Mn(on,{headers:s,account:c}),b=Mn(vn,{headers:s}),w=Mn(bn,{headers:s}),E=Mn(wn,{headers:s}),A=Mn(En,{headers:s,account:c}),T=Mn(mn,{headers:s,account:c}),_=Mn(An,{headers:s}),C=Mn(Tn,{headers:s}),O=Mn(_n,{headers:s}),D=Mn(Cn,{headers:s}),x=Mn(On,{account:c,headers:s}),R=Mn(cn,{headers:s}),F=Mn(un,{headers:s});return{davRequest:async e=>{const{init:t,...r}=e,{headers:n,...i}=t;return Hr({...r,init:{...i,headers:{...s,...n}}})},propfind:d,createAccount:async e=>{const{account:t,headers:i,loadCollections:o,loadObjects:a}=e;return Ln({account:{serverUrl:r,credentials:n,...t},headers:{...s,...i},loadCollections:o,loadObjects:a})},createObject:u,updateObject:l,deleteObject:h,calendarQuery:b,addressBookQuery:R,collectionQuery:f,makeCollection:p,calendarMultiGet:w,makeCalendar:E,syncCollection:y,supportedReportSet:g,isCollectionDirty:m,smartCollectionSync:v,fetchCalendars:A,fetchCalendarUserAddresses:T,fetchCalendarObjects:_,createCalendarObject:C,updateCalendarObject:O,deleteCalendarObject:D,syncCalendars:x,fetchAddressBooks:Mn(ln,{account:c,headers:s}),addressBookMultiGet:F,fetchVCards:Mn(hn,{headers:s}),createVCard:Mn(dn,{headers:s}),updateVCard:Mn(fn,{headers:s}),deleteVCard:Mn(pn,{headers:s})}};class Gn{constructor(e){var t,r,n;this.serverUrl=e.serverUrl,this.credentials=e.credentials,this.authMethod=null!==(t=e.authMethod)&&void 0!==t?t:"Basic",this.accountType=null!==(r=e.defaultAccountType)&&void 0!==r?r:"caldav",this.authFunction=e.authFunction,this.fetchOptions=null!==(n=e.fetchOptions)&&void 0!==n?n:{}}async login(){var e;switch(this.authMethod){case"Basic":this.authHeaders=$n(this.credentials);break;case"Oauth":this.authHeaders=(await Yn(this.credentials,this.fetchOptions)).headers;break;case"Digest":this.authHeaders={Authorization:`Digest ${this.credentials.digestString}`};break;case"Custom":this.authHeaders=await(null===(e=this.authFunction)||void 0===e?void 0:e.call(this,this.credentials));break;default:throw new Error("Invalid auth method")}this.account=this.accountType?await Ln({account:{serverUrl:this.serverUrl,credentials:this.credentials,accountType:this.accountType},headers:this.authHeaders,fetchOptions:this.fetchOptions}):void 0}async davRequest(e){const{init:t,...r}=e,{headers:n,...i}=t;return Hr({...r,init:{...i,headers:{...this.authHeaders,...n}},fetchOptions:this.fetchOptions})}async createObject(...e){return Mn(qr,{url:this.serverUrl,headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async updateObject(...e){return Mn(zr,{url:this.serverUrl,headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async deleteObject(...e){return Mn(Gr,{url:this.serverUrl,headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async propfind(...e){return Mn(Yr,{headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async createAccount(e){const{account:t,headers:r,loadCollections:n,loadObjects:i,fetchOptions:o}=e;return Ln({account:{serverUrl:this.serverUrl,credentials:this.credentials,...t},headers:{...this.authHeaders,...r},loadCollections:n,loadObjects:i,fetchOptions:null!=o?o:this.fetchOptions})}async collectionQuery(...e){return Mn(Jr,{headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async makeCollection(...e){return Mn(en,{headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async syncCollection(...e){return Mn(nn,{headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async supportedReportSet(...e){return Mn(tn,{headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async isCollectionDirty(...e){return Mn(rn,{headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async smartCollectionSync(...e){return Mn(on,{headers:this.authHeaders,fetchOptions:this.fetchOptions,account:this.account})(e[0])}async calendarQuery(...e){return Mn(vn,{headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async makeCalendar(...e){return Mn(wn,{headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async calendarMultiGet(...e){return Mn(bn,{headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async fetchCalendars(...e){return Mn(En,{headers:this.authHeaders,account:this.account,fetchOptions:this.fetchOptions})(null==e?void 0:e[0])}async fetchCalendarUserAddresses(...e){return Mn(mn,{headers:this.authHeaders,account:this.account,fetchOptions:this.fetchOptions})(null==e?void 0:e[0])}async fetchCalendarObjects(...e){return Mn(An,{headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async createCalendarObject(...e){return Mn(Tn,{headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async updateCalendarObject(...e){return Mn(_n,{headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async deleteCalendarObject(...e){return Mn(Cn,{headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async syncCalendars(...e){return Mn(On,{headers:this.authHeaders,account:this.account,fetchOptions:this.fetchOptions})(e[0])}async addressBookQuery(...e){return Mn(cn,{headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async addressBookMultiGet(...e){return Mn(un,{headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async fetchAddressBooks(...e){return Mn(ln,{headers:this.authHeaders,account:this.account,fetchOptions:this.fetchOptions})(null==e?void 0:e[0])}async fetchVCards(...e){return Mn(hn,{headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async createVCard(...e){return Mn(dn,{headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async updateVCard(...e){return Mn(fn,{headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}async deleteVCard(...e){return Mn(pn,{headers:this.authHeaders,fetchOptions:this.fetchOptions})(e[0])}}var Wn={DAVNamespace:j,DAVNamespaceShort:$,DAVAttributeMap:M,...Object.freeze({__proto__:null,DAVClient:Gn,createDAVClient:zn}),...Wr,...an,...In,...yn,...xn,...qn,...$r};export{M as DAVAttributeMap,Gn as DAVClient,j as DAVNamespace,$ as DAVNamespaceShort,cn as addressBookQuery,bn as calendarMultiGet,vn as calendarQuery,Br as cleanupFalsy,Jr as collectionQuery,Ln as createAccount,Tn as createCalendarObject,zn as createDAVClient,qr as createObject,dn as createVCard,Hr as davRequest,Wn as default,Cn as deleteCalendarObject,Gr as deleteObject,pn as deleteVCard,ln as fetchAddressBooks,An as fetchCalendarObjects,mn as fetchCalendarUserAddresses,En as fetchCalendars,Kn as fetchOauthTokens,hn as fetchVCards,Dn as freeBusyQuery,$n as getBasicAuthHeaders,jr as getDAVAttribute,Yn as getOauthHeaders,rn as isCollectionDirty,wn as makeCalendar,Yr as propfind,Hn as refreshAccessToken,on as smartCollectionSync,tn as supportedReportSet,On as syncCalendars,nn as syncCollection,_n as updateCalendarObject,zr as updateObject,fn as updateVCard,Pr as urlContains,Ur as urlEquals};
diff --git a/dist/types/DAVTypes.d.ts b/dist/types/DAVTypes.d.ts
new file mode 100644
index 0000000..e0deccc
--- /dev/null
+++ b/dist/types/DAVTypes.d.ts
@@ -0,0 +1,37 @@
+export type DAVDepth = '0' | '1' | 'infinity';
+export type DAVMethods = 'COPY' | 'LOCK' | 'MKCOL' | 'MOVE' | 'PROPFIND' | 'PROPPATCH' | 'UNLOCK' | 'REPORT' | 'SEARCH' | 'MKCALENDAR';
+export type HTTPMethods = 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE' | 'PATCH';
+export type DAVResponse = {
+    raw?: any;
+    href?: string;
+    status: number;
+    statusText: string;
+    ok: boolean;
+    error?: {
+        [key: string]: any;
+    };
+    responsedescription?: string;
+    props?: {
+        [key: string]: {
+            status: number;
+            statusText: string;
+            ok: boolean;
+            value: any;
+        } | any;
+    };
+};
+export type DAVRequest = {
+    headers?: Record<string, string>;
+    method: DAVMethods | HTTPMethods;
+    body: any;
+    namespace?: string;
+    attributes?: Record<string, string>;
+};
+export type DAVTokens = {
+    access_token?: string;
+    refresh_token?: string;
+    expires_in?: number;
+    id_token?: string;
+    token_type?: string;
+    scope?: string;
+};
diff --git a/dist/types/functionsOverloads.d.ts b/dist/types/functionsOverloads.d.ts
new file mode 100644
index 0000000..3e066e8
--- /dev/null
+++ b/dist/types/functionsOverloads.d.ts
@@ -0,0 +1,45 @@
+import { DAVAccount, DAVCalendar, DAVCollection, DAVObject } from './models';
+export interface SmartCollectionSync {
+    <T extends DAVCollection>(param: {
+        collection: T;
+        method?: 'basic' | 'webdav';
+        headers?: Record<string, string>;
+        fetchOptions?: RequestInit;
+        account?: DAVAccount;
+        detailedResult: true;
+    }): Promise<Omit<T, 'objects'> & {
+        objects: {
+            created: DAVObject[];
+            updated: DAVObject[];
+            deleted: DAVObject[];
+        };
+    }>;
+    <T extends DAVCollection>(param: {
+        collection: T;
+        method?: 'basic' | 'webdav';
+        headers?: Record<string, string>;
+        fetchOptions?: RequestInit;
+        account?: DAVAccount;
+        detailedResult?: false;
+    }): Promise<T>;
+}
+export interface SyncCalendars {
+    (params: {
+        oldCalendars: DAVCalendar[];
+        headers?: Record<string, string>;
+        fetchOptions?: RequestInit;
+        account?: DAVAccount;
+        detailedResult: true;
+    }): Promise<{
+        created: DAVCalendar[];
+        updated: DAVCalendar[];
+        deleted: DAVCalendar[];
+    }>;
+    (params: {
+        oldCalendars: DAVCalendar[];
+        headers?: Record<string, string>;
+        fetchOptions?: RequestInit;
+        account?: DAVAccount;
+        detailedResult?: false;
+    }): Promise<DAVCalendar[]>;
+}
diff --git a/dist/types/models.d.ts b/dist/types/models.d.ts
new file mode 100644
index 0000000..5e3b289
--- /dev/null
+++ b/dist/types/models.d.ts
@@ -0,0 +1,70 @@
+import { ElementCompact } from 'xml-js';
+import { DAVDepth, DAVResponse } from './DAVTypes';
+export type DAVCollection = {
+    objects?: DAVObject[];
+    ctag?: string;
+    description?: string;
+    displayName?: string | Record<string, unknown>;
+    reports?: any;
+    resourcetype?: any;
+    syncToken?: string;
+    url: string;
+    fetchOptions?: RequestInit;
+    fetchObjects?: ((params?: {
+        collection: DAVCalendar;
+        headers?: Record<string, string>;
+        fetchOptions?: RequestInit;
+    }) => Promise<DAVCalendarObject[]>) | ((params?: {
+        collection: DAVAddressBook;
+        headers?: Record<string, string>;
+        fetchOptions?: RequestInit;
+    }) => Promise<DAVVCard[]>);
+    objectMultiGet?: (params: {
+        url: string;
+        props: ElementCompact;
+        objectUrls: string[];
+        filters?: ElementCompact;
+        timezone?: string;
+        depth: DAVDepth;
+        fetchOptions?: RequestInit;
+        headers?: Record<string, string>;
+    }) => Promise<DAVResponse[]>;
+};
+export type DAVObject = {
+    data?: any;
+    etag?: string;
+    url: string;
+};
+export type DAVCredentials = {
+    username?: string;
+    password?: string;
+    clientId?: string;
+    clientSecret?: string;
+    authorizationCode?: string;
+    redirectUrl?: string;
+    tokenUrl?: string;
+    accessToken?: string;
+    refreshToken?: string;
+    expiration?: number;
+    digestString?: string;
+    customData?: Record<string, unknown>;
+};
+export type DAVAccount = {
+    accountType: 'caldav' | 'carddav';
+    serverUrl: string;
+    credentials?: DAVCredentials;
+    rootUrl?: string;
+    principalUrl?: string;
+    homeUrl?: string;
+    calendars?: DAVCalendar[];
+    addressBooks?: DAVAddressBook[];
+};
+export type DAVVCard = DAVObject;
+export type DAVCalendarObject = DAVObject;
+export type DAVAddressBook = DAVCollection;
+export type DAVCalendar = {
+    components?: string[];
+    timezone?: string;
+    projectedProps?: Record<string, unknown>;
+    calendarColor?: string;
+} & DAVCollection;
diff --git a/dist/util/authHelpers.d.ts b/dist/util/authHelpers.d.ts
new file mode 100644
index 0000000..2a925e1
--- /dev/null
+++ b/dist/util/authHelpers.d.ts
@@ -0,0 +1,24 @@
+import 'cross-fetch/polyfill';
+import { DAVTokens } from '../types/DAVTypes';
+import { DAVCredentials } from '../types/models';
+/**
+ * Provide given params as default params to given function with optional params.
+ *
+ * suitable only for one param functions
+ * params are shallow merged
+ */
+export declare const defaultParam: <F extends (...args: any[]) => any>(fn: F, params: Partial<Parameters<F>[0]>) => (...args: Parameters<F>) => ReturnType<F>;
+export declare const getBasicAuthHeaders: (credentials: DAVCredentials) => {
+    authorization?: string;
+};
+export declare const fetchOauthTokens: (credentials: DAVCredentials, fetchOptions?: RequestInit) => Promise<DAVTokens>;
+export declare const refreshAccessToken: (credentials: DAVCredentials, fetchOptions?: RequestInit) => Promise<{
+    access_token?: string;
+    expires_in?: number;
+}>;
+export declare const getOauthHeaders: (credentials: DAVCredentials, fetchOptions?: RequestInit) => Promise<{
+    tokens: DAVTokens;
+    headers: {
+        authorization?: string;
+    };
+}>;
diff --git a/dist/util/camelCase.d.ts b/dist/util/camelCase.d.ts
new file mode 100644
index 0000000..d6d6502
--- /dev/null
+++ b/dist/util/camelCase.d.ts
@@ -0,0 +1 @@
+export declare const camelCase: (str: string) => string;
diff --git a/dist/util/nativeType.d.ts b/dist/util/nativeType.d.ts
new file mode 100644
index 0000000..325f2b6
--- /dev/null
+++ b/dist/util/nativeType.d.ts
@@ -0,0 +1 @@
+export declare const nativeType: (value: string) => unknown;
diff --git a/dist/util/requestHelpers.d.ts b/dist/util/requestHelpers.d.ts
new file mode 100644
index 0000000..bf248f8
--- /dev/null
+++ b/dist/util/requestHelpers.d.ts
@@ -0,0 +1,12 @@
+import { DAVNamespace } from '../consts';
+import type { NoUndefinedField } from './typeHelpers';
+export declare const urlEquals: (urlA?: string, urlB?: string) => boolean;
+export declare const urlContains: (urlA?: string, urlB?: string) => boolean;
+export declare const getDAVAttribute: (nsArr: DAVNamespace[]) => {
+    [key: string]: DAVNamespace;
+};
+export declare const cleanupFalsy: <T extends object = object>(obj: T) => NoUndefinedField<T>;
+export declare const conditionalParam: <T>(key: string, param: T) => {
+    [key: string]: T;
+};
+export declare const excludeHeaders: (headers: Record<string, string> | undefined, headersToExclude: string[] | undefined) => Record<string, string>;
diff --git a/dist/util/typeHelpers.d.ts b/dist/util/typeHelpers.d.ts
new file mode 100644
index 0000000..5340969
--- /dev/null
+++ b/dist/util/typeHelpers.d.ts
@@ -0,0 +1,16 @@
+export type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
+export type NoUndefinedField<T> = {
+    [P in keyof T]-?: NoUndefinedField<NonNullable<T[P]>>;
+};
+export type Await<T> = T extends PromiseLike<infer U> ? U : T;
+export type ValueOf<T> = T[keyof T];
+export type RequiredAndNotNull<T> = {
+    [P in keyof T]-?: Exclude<T[P], null | undefined>;
+};
+export type RequireAndNotNullSome<T, K extends keyof T> = RequiredAndNotNull<Pick<T, K>> & Omit<T, K>;
+export type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
+    [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
+}[Keys];
+export declare function hasFields<T, K extends keyof T>(obj: Array<T | RequireAndNotNullSome<T, K>>, fields: K[]): obj is Array<RequireAndNotNullSome<T, K>>;
+export declare function hasFields<T, K extends keyof T>(obj: T | RequireAndNotNullSome<T, K>, fields: K[]): obj is RequireAndNotNullSome<T, K>;
+export declare const findMissingFieldNames: <T>(obj: T, fields: Array<keyof T>) => string;
diff --git a/rollup.config.mjs b/rollup.config.mjs
index ce7352e..d97b709 100644
--- a/rollup.config.mjs
+++ b/rollup.config.mjs
@@ -41,7 +41,7 @@ export default [
       ts({
         tsconfig: './tsconfig.build.json',
         declaration: true,
-        declarationDir: './ts',
+        declarationDir: 'dist/',
       }),
       cjs(),
       resolve({
@@ -75,7 +75,7 @@ export default [
     ],
   },
   {
-    input: './dist/ts/index.d.ts',
+    input: './dist/index.d.ts',
     output: [{ file: 'dist/tsdav.d.ts', format: 'es' }],
     plugins: [dts()],
   },