diff --git a/.gitignore b/.gitignore index 6b1787bc5..7aa2daec0 100644 --- a/.gitignore +++ b/.gitignore @@ -6,7 +6,6 @@ _pkginfo.txt /bld/ /bin/ /BundleArtifacts/ -/dist/ /archives/*.zim* /archives/*wikivoyage*.zim /archives/*medicine*.zim diff --git a/dist/CHANGELOG.md b/dist/CHANGELOG.md new file mode 100644 index 000000000..7bc99a93a --- /dev/null +++ b/dist/CHANGELOG.md @@ -0,0 +1,1122 @@ +# Changelog + +## Interim release 3.4.8 + +* ENHANCEMENT: App now prompts user to switch to OPFS on Android and Firefox Desktop +* ENHANCEMENT: App now uses OPFS Persistent Storage on Firefox for greatly increased Storage quota +* ENHANCEMENT: Add option in Configuration to disable accidental reload protection +* ENHANCEMENT: Prominent "Download now" button in library if OPFS is enabled +* FIX: PWA can now update without user having to exit the app (with user gesture or automatically in Electron) +* FIX: If user hasn't dismissed the splashscreen then it is shown again after a refresh +* REGRESSION: Fix build of Win7 32bit app with wrong Electron version and block autoupdate +* DEV: Reset options are now in separate module to avoid circular dependencies + +## Release 3.4.5 / 3.4.6 + +* ENHANCEMENT: Prevent accidental app reload if an archive is loaded +* FIX: Failure to display Wikimedia URLs ending in a question mark +* FIX: Failure to display articles from links clicked in popovers +* FIX: Remove title description from popovers in new Wikimedia ZIMs +* FIX: Remove unused scripts from Wikimedia ZIMs scraped with mobile-html API +* BUILD: Switched to new eSigner code-signing certificate +* BUILD: Disabled signing of nightly binaries due to cost +* INFO: Added info in release templates regarding SmartScreen popups on Windows +* INFO: Added info to README regarding the fact that nightly builds are unsigned +* DEV: Update Express server and dependencies + +## Release 3.4.0 / 3.4.1 + +* ENHANCEMENT: Faster and more reliable initiation of image lazy loading in Wikimedia ZIMs +* REGRESSION: Fixed failure to return to Home page or display random pages in dynamic ZIMs +* REGRESSION: Fixed misdirection of article to non-existent container in Zimit ZIMs +* UPDATE: Adjust style processing to handle ZIMs scraped from new mobile html endpoint +* UPDATE: Ensure transformation to desktop style is working with mobile html endpoint +* UPDATE: Title tip info about Origin Private File System +* UPDATE: Wikivoyage release template +* FIX: Incorrect processing of empty link as external +* FIX: Avoid redundant transformation of ZIM style mobile to mobile or desktop to desktop +* FIX: Fatal CORS error with extrernal links & custom protocols cuased by `wm_mobile_override_script.js` in new Wikimedia ZIMs +* FIX: Remove incompatible webPHandler in Wikimedia ZIMs (we supplo our own) +* FIX: Race conditions which prevented unhiding of article window with slow browsers and some new windows/tabs +* FIX: Detection of correct window or tab when user clicks on an unmanaged ZIM hyperlink + +## Release 3.3.7 / 3.3.8 + +* FIX: Critical error on startup of Electron app if Express port is already in use +* FIX: Incorrect close popover icon colour +* FIX: Stutter effect when invoking popover +* FIX: UWP positioning of popovers +* FIX: Restore erroneously deleted WikiMed file +* FIX: Erroneous divOffsetHeight calculation in Electron apps +* FIX: Horizontal line cutting into infoboxes with locally cached Wikipedia styles +* FIX: Horizontal line cutting into some images with locally cached Wikipedia styles +* FIX: Handling of custom protocols and URI schemata in ServiceWorker mode +* FIX: Ensure popover is always at top of z-index +* FIX: Issues selecting and remembering the UI language in multi-lingual TED ZIMs +* UPDATE: Title tip info about Origin Private File System +* WORKAROUND: Patch rogue HTML entities appearing in dirEntry titles + +## Release 3.3.1 / 3.3.2 + +* FEATURE: Add Wikipedia/Wikivoyage previews when hovering over, tabbing into or long-pressing a ZIM link +* ENHANCEMENT: Support building separate Windows 7 32bit Electron packages +* ENHANCEMENT: Standard NWJS packages (not XP) are now 64bit +* INFO: Windows 7/8/8.1 Electron apps no longer autoupdate, because they will update to a version not supported on Win 7+ +* UPDATE: Reworked Wikivoyage custom landing page +* FIX: Popovers now support all dark themes +* FIX: Bug which would reload the current ZIM archive if user accidentally initiated drag-drop +* FIX: No source verification for archives included in package +* FIX: Bug with placement of popovers which didn't take into account the font zoom factor +* FIX: Critical error detecting window.electronAPI on some platforms +* FIX: In the Electron app, do not show GitHub updates if PWA update is needed +* FIX: Bug with synchronization of tri-state checkboxes when unselecting dark themes +* DEV: Avoid incorrect and redundant uploads to Kiwix download server +* DEV: Fix build scripts +* DEV: Update publishing templates +* DEPENDENCIES: Bump Electron to 29.3.1 for 64bit builds +* DEPENDENCIES: Bump ejs to 3.1.10 + +## Release 3.2.3 / 3.2.4 + +* FEATURE: Add security dialogue on opening a ZIM for the first time in ServiceWorker mode +* UPDATE: Rename JQuery mode to Restricted mode +* DOCUMENTATION: Add information about ZIM security to About +* DOCUMENTATION: Add information about Persistent Permissions to About +* FIX: Cached last page sometimes overwrites new ZIM landing page when switching from Restricted mode +* FIX: Display of open/close marker with h5 and h6 headings in Wikimedia ZIMs +* FIX: Inability to print HTML books in Gutenberg ZIMs +* FIX: Bug which forced all images to manual display in some non-Wikimedia ZIMs in Restricted mode +* FIX: Inability to read stylesheets correctly when accessing some Zimit archives in Restricted mode +* FIX: Go straight to article view on launch if persistent permissions are granted +* FIX: Removed redundant workaround patching the style of thumbinner image containers in MDWiki ZIMs +* FIX: Catch uncaught file verification exception +* FIX: Remove legacy "Scanning for archives" block +* REGRESSION: Fix inability to reload packaged archive in WikiMed and Wikivoyage apps +* WORKAROUND: Fix for HTML URLs with percent-encoded querystring separators in zimit2 +* DEPENDENCIES: Bump Vite to v4.5.3 + +## Release 3.1.0 / 3.1.1 + +* UPDATE: On Android, full-text search now on by default (but may be too slow to load without OPFS) +* FIX: Broken "unclicking" of config and about buttons and return-to-article link +* FIX: Reduce flash of incorrect style with Zimit-style ZIMs displayed with darkReader +* FIX: Ensure legacy archive warning and other content warnings remain displayed until dismissed +* FIX: (partial) Untransformed relative Zimit2 URLs for browsers that do not support Wombat +* FIX: Issue with Create-DraftRelease script +* FIX: Issue preventing app from detecting new updates on GitHub in some circumstances +* INFO: Mention ARM architecture in in-app user info +* REGRESSION: Fix YouTube video playback with legacy Zimit reading system (SW mode) +* REGRESSION: Incompatibility with IE11 and Edge Mobile that prevented running on WM10 +* WORKAROUND: Remove erroneously scraped ovid iframes in MDWiki ZIMs +* DEV: Updates to buid script +* DEV: Deprecate 32bit deb packages for packaged apps +* DEV: Remove jQuery from app.js +* DEPENDENCIES: Bump Electron Builder to v24.13.3 +* DEPENDENCIES: Bump Electron Updater to v6.2.1 + +## Release 3.0.0 / 3.0.1 + +* FEATURE: Preliminary support for Zimit v2.0 archive types +* FEATURE: Enable use of DarkReader with zimit2 archives +* ENHANCEMENT: Support most Zimit (1/2) archives in jQuery mode if they have largely static content +* ENHANCEMENT: Dark mode tri-state switch now turns on before turning to auto (should be less confusing) +* WORKAROUND: Provide alternative link handling for browsers that do not support wombat.js +* KNOWN ISSUE: DarkReader interferes with CIA World Factbook home page (workaround: switch to light mode) +* KNOWN ISSUE: Video is not currently supported in UWP app with zimit2 archives (due to incompaitibility with wombat.js) +* KNOWN ISSUE: Turning DarkReader on or off may not take effect until the NEXT article is loaded +* BUILD: Support Windows on ARM and Linux on ARM for the Electron app +* FIX: Use of standard dark and invert styles with any archive (but usually DarkReader is best for Zimit) +* FIX: Blank iframe article after opening article in new window or tab +* FIX: Finding path of packaged archive with new Electron app architecture +* FIX: Opening article in new window or tab for non-Zimit archives +* FIX: (partial) Zimit articles only open in new tab even if new window was requested +* FIX: Detection of apps installed from the Microsoft Store +* FIX: Failure of UWP app to reload picked folder automatically on app launch +* FIX: Loading of PDFs and external links in zimit2 archives +* FIX: Add preview link for all archives that can be displayed in library.kiwix.org +* FIX: Failure to re-enable DarkReader after printing +* FIX: (partial) Switching themes no longer attempt to jump back to the article immediately +* REGRESSION: Failure to open new windows in UWP app (desktop) +* DEV: Add a way to detect zimit2 archive types +* DEV: Fix incrementation of Microsoft Store apps at build time +* DEV: Warn instead of throwing if the ZIM `minorVersion` is greater than 2 +* DEV: Laumch wingetcreate correctly from PowerShell +* DEPENDENCIES: Electron-builder updated to v24.9.1 +* DEPENDENCIES: ViteJS updated to v4.5.2 + +## Release 2.9.2 + +* UPDATE: Removed sample archive from app package - please download the archive of your choice in-app +* FEATURE: High-fidelity support for Zimit-based archives based on the Replay Web Archive reader +* FEATURE: Experimental dark-theme support for Zimit-based archives using the Replay system and DarkReader +* FEATURE: Legacy methods for reading Zimit ZIMs provided as fallback +* FEATURE: Greatly improved Zimit-archive reading in JQuery mode (static content only) +* FEATURE: The Electron app can now act as a local server for other browsers +* FEATURE: Printing articles from Zimit-based archives supported in PWA (not available in Firefox) +* ENHANCEMENT: Added ability to set the localhost server port in the UI of the Electron app +* ENHANCEMENT: Option to download viewed assets when searching by URL (e.g. C/.*interesting_asset.js) +* INFO: Provide info to user about how to change behaviour of opening external links in tab or window +* FIX: Critical bug that prevented scrolling of search results +* FIX: Critical bug causing a boot loop when the app is in JQuery mode and SW cannot be registered +* FIX: Critical reload loop and video replay in legacy Zimit reading +* FIX: Critical failure to load PDFs in Nautilus ZIMs and Android +* FIX: Pinch-to-zoom now works in the Electron app +* FIX: Remove WordPress link tracker code in some Zimit ZIMs preventing access to ZIM contents +* FIX: Incorrect sizing of article area in UWP app +* FIX: Remove unhandled port in some Zimit redirects, allowing resource to be located in archive +* FIX: Failure to resize Configuration in rare circumstances +* FIX: Accidental disabling of assetsCache when user loads a non-Zimit-based archive +* DEV: Various updates to demos and readme +* DEV: Fix quote detection in rollup build chain +* DEV: Changed favicon from white to black with white border +* DEV: New, more robust, way to wake up and initialize the Service Worker when needed +* DEV: Developer options now provided to use libzim for reading archive contents +* DEV: Updated, standard method for bundling JQuery +* DEPENDENCIES: RollupJS updated to v3.5.0 +* DEPENDENCIES: Updated WebpHero to v0.0.2 +* DEPENDENCIES: Updated DarkReader to v4.9.73 +* DEPENDENCIES: Javascript-libzim updated to v0.6 + +## Release 2.7.8 + +* FEATURE: Support multiple instances of the PWA or browser tabs/windows with different ZIMs loaded in each +* FEATURE: File handling (opening ZIM from system file explorer) will open each ZIM in its own separate instance +* ENHANCEMENT: On non-scrollable pages, remove navbars with Ctrl/Cmd + UpArrow/DownArrow, long swipe or mousewheel +* ENHANCEMENT: Auto-dismiss (fade out) Zimit and active content warnings on scroll +* ENHANCEMENT: Add indicative colourization to archive list when using OPFS +* ENHANCEMENT: Show a spinner when adding and direct-downloading files to OPFS +* ENHANCEMENT: After failure to import or download to OPFS, delete file stub(s) +* INFO: Inform user that OPFS files are preserved on app reset +* INFO: More informative message about import/download error in Safari +* INFO: Added new demo of OPFS features to Repository documentation +* FIX: Tested and fixed support for new dynamic UI in ZIMs produced by Kolibri scraper +* FIX: When using locally cached CSS, the details/summary tags are restored where missing from ZIM +* FIX: Display of open-close markers for headers is now as expected in mobile css (suppressed in desktop css) +* FIX: Dropdowns for languages and subjects in some download library directories +* FIX: Ensure archive list is displayed on open in browsers supporting the webkitdirectory property +* FIX: Empty archive list when OPFS is deactivated +* FIX: Make sure spinner doesn't block the UI +* FIX: Ensure some HTML and entities do not appear in constructed article titles +* FIX: Don't show spinner on click in cases of anchor or javascript links +* FIX: Cancel OPFS delete if export selected and vice versa +* FIX: Better handling of empty directory entries or empty content +* FIX: Better handling of missing ZIM assets +* FIX: Exception displaying plain text when a dirEntry does not have any HTML content +* FIX: Add some sanity checks to prevent runaway searches +* DEV: App no longer forces the Service Worker to stay alive: instead, SW resumes when needed +* DEV: Name of repository changed to kiwix-js-pwa, permalinks changed +* DEV: Provide facility for adding ZIM metadata to the ZIMArchive object + +## Release 2.7.2 + +* FEATURE: Rework file system access and support Origin Private File System (OPFS) +* ENHANCEMENT: Autoload and display of all archives in OPFS on app launch, no permission prompts! +* ENHANCEMENT: Last selected archive (and optionally article) auto-loaded on app launch if in OPFS +* ENHANCEMENT: Import existing archives from anywhere on device into the OPFS easily with file picker +* ENHANCEMENT: New file management facility for deleting, and (in some contexts) exporting OPFS archives +* ENHANCEMENT: Option to download archives directly into the OPFS, without downloading first to user-visible FS +* ENHANCEMENT: Option to download archives direclty into any folder pickable with the File System Access API +* ENHANCEMENT: Full-text search enabled by default on Android for archives in OPFS +* ENHANCEMENT: Pick multiple archives at once and switch easily between them, even on legacy systems +* ENHANCEMENT: New Operations Panel to show download progress in PWA and Electron apps +* ENHANCEMENT: Avoid double loading of WebP Polyfill when present in ZIM +* FIX: Exception preventing display of legacy archive content in jQuery mode +* FIX: Failure to display ZIM Archive Index when typing space in some circumstances +* FIX: Avoid duplication of title in wider range of ZIMs +* FIX: Partially fixed broken "unclick" of Configure button on touchscreen devices +* REGRESSION: Fixed failure to refresh full-screen state when clicking in-app in SW mode +* REGRESSION: Fixed rogue error message when using File Handling API +* UPDATE: Sample archive updated to `wikipedia_en_100_mini_2023-10` +* UPDATE: Electron version bumped to 22.3.25 + +## Release 2.6.4 + +* FEATURE: Full-text search enabled by default on iOS 15+ +* REGRESSION: Fixed loss of ability to pick ZIM archives in latest Chromium on Android +* REGRESSION: Fixed loss of ability to access custom ZIMs from download library +* REGRESSION: Work around missing titles in all WikiMedia scrapes since 2023-07 +* FIX: Avoid hyperlinking math fallback images to high-res Wikimedia versions +* FIX: Conflict between manual image display and hyperlinking images to high-res Wikimedia versions +* FIX: More broken Linux icons +* DEV: Appx package is now uploaded to Kiwix releases +* DEV: Added clear documentation to the Create-DraftRelease.ps1 script +* DEV: Remove more unnecessary JQuery from the app +* DEV: Disable appCache by default if developing with the Vite server + +## Release 2.5.6 + +* FEATURE: Ability to pick a folder of ZIM archives in nearly all apps and frameworks supporting the Webkitdirectory API +* FEATURE: New Electron-based appx version of Kiwix JS now served from the Microsoft Store and from GitHub Releases +* FEATURE: Electron app can now handle ZIM files, including the `.zimaa` part of a split ZIM fileset +* FEATURE: Improved file and folder picking experience for Firefox and older browsers lacking the File System Access API +* ENHANCEMENT: Fast re-opening of previously picked archives or directories in these browsers (number of clicks minimized) +* ENHANCEMENT: Dragged and dropped files, including split files, can now be re-opened automatically in Electron and NWJS apps +* ENHANCEMENT: Microsoft Store app now supports full-text search for users with 64bit Windows +* ENHANCEMENT: Provide more gradual screen width transition with max page width auto setting +* ENHANCEMENT: Restored the ability not to display images in ServiceWorker Mode in non-Zimit ZIMs +* ENHANCEMENT: Restored lazy-loading of images on most landing pages (improves Android experience with image-heavy landing pages) +* ENHANCEMENT: The Kiwix PWA can now be added as a Side Panel app in Edge (NB folder picking does not work in this configuration) +* ENHANCEMENT: Top toolbar now resized correctly with Window Controls Overlay in installed PWA on macOS and Windows +* ENHANCEMENT: When using Window Controls Overlay, app now has a draggable area (left of Kiwix icon) +* UPDATE: Sample archive changed to `wikipedia_en_100_mini_2023-07` +* UPDATE: Troubleshooting instructions for installing on Debian on the Releases page +* BUILD: Allow producing signed or unsigned versions of appx, and compile to appxbundle +* BUILD: Option to build artefacts only for testing +* FIX: Broken Kiwix icon for Linux app packages +* FIX: Fidelity of layout for translation tables in cached Wiktionary mobile and desktop styles +* FIX: Broken file handling in legacy UWP app +* FIX: Miscellaneous small bugfixes and typos +* DEV: A lot of normalization of coding style using ESLint + +## Release 2.5.0 + +* FEATURE: PWA app is now smaller and loads faster due to minification with modern build process +* ENHANCEMENT: New modular system and bundler ensures smaller and more stable memory management +* ENHANCEMENT: Add a Promise queue to prevent overlapping alert dialogue boxes +* ENHANCEMENT: Major enhancement to the fidelity of rendering Zimit-based ZIM archives +* ENHANCEMENT: Ability to open new browsable windows and tabs in Zimit ZIMs +* UPDATE: Renamed breakout link feature to "Download or open current article" +* UPDATE: Reduce image fade-in transition time +* UPDATE: Add a limit to the number of dialogue boxes that can be queued up +* UPDATE: Make one-time hidden content warning less intrusive +* DEV: Removed RequireJS and migrated app to ES6 native modules +* DEV: Provide clearer colouring when appCache is disabled for development +* DEV: Use rollup.js and Babel to build compatible versions of the app for all supported browsers +* DEV: Provide minified and unminified versions of the bundled app +* DEV: Added ability to publish a distribution of the app to GitHub Pages for development +* DEV: Add a basic Vite.js server configuration +* DEV: Re-enable use of wingetcreate with v2.6.0 when publishing to winget repository +* WORKAROUND: Prevent hackish Zimit script from causing reload loop in new tabs or windows +* FIX: Make upgrade notification persistent in Electron app +* FIX: Several UI issues with toolbars and downloads +* FIX: Bug which prevented UWP / Edge Legacy app from reading articles with certain options deselected +* FIX: Missing commit ID in Windows nightly builds +* FIX: Downloading of PDFs in Nautilus-based ZIMs and elsewhere +* FIX: Add secondary URL corrector to increase fidelity of Zimit rendering +* FIX: Add a better algorithm for Kiwix asset detection +* FIX: Make all Zimit links relative +* FIX: Add workarounds for sandboxed iframe: load all https: and pdf content in a new window or tab +* FIX: More robust click and download handling for Zimit ZIMs +* FIX: Add BOM to production bundle when building UWP app (store requirement) +* FIX: Better support for handling external links in iOS +* FIX: Bug that showed irrelevant dialogue box when opening Zimit archives on iOS +* FIX: Bug that loaded a blank screen when asking user whether to open external links +* DEPENDENCY: Update jQuery to 3.7.0, while removing its use in a number of places +* REGRESSION: Fix regression with (former) breakout link feature +* REGRESSION: Restore dialogue box animations that were removed with removal of jQuery +* REGRESSION: Restore Table of Contents functionality disabled with removal of jQuery +* REGRESSION: Restore ability to close several in-page alerts after removal of jQuery +* REGRESSION: Restore automatic updating of appCache + +## Release 2.4.4 + +* ENHANCEMENT: Provide fuzzy search for case-insensitive links in Zimit archives +* ENHANCEMENT: Include broader pseudo-case-insensitive search in title search +* SECURITY: Add iframe referrer policy 'no-referrer' +* SECURITY: Strengthen Content Security Policy via response headers and meta http-equiv +* UPDATE: Sample archive changed to `wikipedia_en_100_mini_2023-04` +* UPDATE: Streamline the splashscreen display and make it dynamic +* UPDATE: Add more complete language support to the Download Library languages dropdown +* FIX: Stack Exchange ZIM detection +* FIX: Display of external icons in Stack Exchange articles +* FIX: Dark mode style tweaks for Wiktionary +* FIX: Missing full-text search cancellation which caused race condition in search + +## Release 2.4.0 + +* FEATURE: Support Full Screen (all browsers) and rotation lock (primarily intended for mobile) +* FEATURE: Significant speed-up of access to Wikimedia archives with option to ignore unneeded JS files +* SECURITY: Added sandbox attribute to iframe to block top-level navigation and attempts by scripts to "phone home" +* UPDATE: Sample archive changed to `wikipedia_en_100_mini_2023-03` +* UPDATE: Mobile styles for Wiktionary archives +* ENHANCEMENT: Provide indication of archive download progress in Electron app +* ENHANCEMENT: Avoid opening blank window when downloading archive in Electron/NWJS +* ENHANCEMENT: Provide troubleshooting option to disable drag-and-drop +* ENHANCEMENT: Use screen width more efficiently in SW mode (with Remove max page width option) +* FIX: Return to article links were missing in ServiceWorker mode +* FIX: Removed orientation key that prevented proper setting of orientation in some contexts +* FIX: Improved detection of Wikimedia ZIMs for seleciton of printing stylesheet +* FIX: Fix for rogue JS in Wiktionary archives (if default option to use locally cached styles is on) + +## Release 2.3.6 + +* ENHANCEMENT: Tidier Configuration layout with collapsible options +* ENHANCEMENT: Streamline access to legacy file picker when File System Access API unavailable +* ENHANCEMENT: The PWA now works on iOS devices (iPhone/iPad) in Safari and can be added to home screen +* ENHANCEMENT: App now intelligently sets the initial window opening mode (tab or window) +* UPDATE: Neater display of file picking instructions, hiding them when no longer needed +* UPDATE: Sample archive changed to `wikipedia_en_100_mini_2023-01` +* FIX: Several issues affecting printing (Zimit archives in Chromium, failure to detect selected options in Safari, etc.) +* FIX: Logic for checking GitHub update server +* FIX: Legacy file picker is now able to pick ZIM archives on iOS devices +* FIX: Block a wider range of analytics in Zimit archives +* FIX: Processing of data-srcset blocks in Zimit archives + +## Release 2.3.0 + +* ENHANCEMENT: Check for update to PWA and notify user shortly after startup of the app +* ENHANCEMENT: New "auto" setting for display of hidden navboxes and tables in Wikimedia ZIMs +* ENHANCEMENT: Detect historical ZIM types and add advice on using jQuery mode to read them +* ENHANCEMENT: Refresh and Reset buttons provided near the top of Configuration in case of app freeze +* DEV: Added developer option to force use of libzim W/ASM decoding of full-text index +* UPDATE: Sample archive changed to `wikipedia_en_100_mini_2022-12` +* FIX: Libzim loading error in Electron app with large ZIM archives due to race condition +* FIX: Prevent race condition between reactivation of Service Worker and loading of NODEFS +* FIX: Add BOM to new JS files to conform to Microsoft Store requirements +* FIX: Exception caused by site.js script included in Wikimedia archives +* FIX: Failure to load last-visited article in Electron app +* FIX: Electron file and folder picking methods +* FIX: In UWP app, request to launch PWA is now shown after upgrade splash screen +* FIX: Allow URL-based search to complete before launching full-text search +* FIX: Critical bug preventing display of legacy file picker +* BUILD: Build 64bit and 32bit packages separately to avoid race condition in electron-builder +* BUILD: All Electron apps other than 32bit Linux are now built with latest Electron + +## Release 2.2.8 + +* ENHANCEMENT: Experimental use of libzim WASM port to read Full-Text index (PWA and Electron only) +* ENHANCEMENT: Information added to API panel to show status of Full Text index +* ENHANCEMENT: Run full-text and title search in parallel for faster return of results +* ENHANCEMENT: Building Electron app on GitHub actions now downloads the latest packaged archive before cloud-building +* UPDATE: Sample archive changed to `wikipedia_en_100_mini_2022-11` +* CLEANUP: Removal of several JQuery functions, replaced with native DOM methods +* CLEANUP: Remove some unused functions +* FIX: Critical startup bug which prevented opening of some packaged archives +* FIX: Bug which prevented reload of last visited page on re-launch of app +* FIX: When dark mode is set to auto, do not use darkReader for Wikimedia ZIMs + +## Release 2.2.5 + +* UPDATE: Sample archive changed to `wikipedia_en_100_mini_2022-10` +* ENHANCEMENT: Experimental option to use DarkReader plugin (SW mode only) +* ENHANCEMENT: Added support for Open Document download types (.odt) +* ENHANCEMENT: UWP app size reduced from 13MB to 5.4MB! +* FIX: A number of glitches with standard and inverted dark themes +* FIX: Crash in UWP app when switching between modes if there are too many archives in a loaded directory +* FIX: Deal with Zimit links correctly when link handling is disabled +* FIX: Test both the encoded and decoded path for Zimit hyperlinks, due to inconsistencies in format +* FIX: Infinite loop when hyperlinks are not being captured by window opener +* FIX: Recognize more file types as assets, to avoid accidentally loading them as articles +* FIX: Failure to display active content warning in some instances + +## Release 2.2.0 + +* UPDATE: Sample archive updated to `wikipedia_en_climate_change_mini_2022-10.zim` +* ENHANCEMENT: Enable ServiceWorker mode as the default (and deprecate JQuery mode) +* ENHANCEMENT: Display media download alert only when the medium is fetched from the ZIM +* FIX: Regression preventing UWP app from remaining in ServiceWorker mode +* FIX: Failure to confirm with user before launching SW mode in UWP app + +## Release 2.1.9 + +* ENHANCEMENT: Better suggestions for mirrors when Library server does not provide mirror info +* ENHANCEMENT: A self-contained portable Windows executable is now available for Electron +* UPDATE: Streamline polling of spinner and messaging +* FIX: Selection of languages in Library +* FIX: Display of some irregularly formatted filenames in Library +* FIX: Ensure spinner never shows for more than 3 seconds +* FIX: Display of landing pages of YouTube-based archives (e.g. TED Talks) +* FIX: Ensure dynamic element is scrolled into view when clicked in collection archives +* FIX: Regression preventing load of some relative assets in Zimit archives + +## Release 2.1.8 + +* FEATURE: Enable playback of most offline **embedded** YouTube video in Zimit ZIMs (SW mode) +* ENHANCEMENT: YouTube video **links** can be played offline if video available (JQuery and SW modes) +* ENHANCEMENT: Clearer signposting of Archive Index vs URL Index +* ENHANCEMENT: Show an alert to user if main page is not an article +* UPDATE: Sample archive updated to `wikipedia_en_climate_change_mini_2022-09` +* WORKAROUND: Assets with erroneous MIME types were misrecognized as articles (blocking reload of some articles) +* FIX: Downloading of non-mirrored content in the Library +* FIX: Recognize XHTML documents and applications in Zimit ZIMs and treat as HTML +* FIX: Wikivoyage package and install icons +* FIX: Bug preventing loading of Nautilus-based ZIM assets +* FIX: Detect more ZIMs for active content warning +* FIX: Provide instructions for showing URL Index in active content warning +* FIX: Download of files with very long filenames +* FIX: Bug causing incomplete loading of images on image-heavy landing pages +* FIX: Display of blue placeholders for manual image extraction in SW mode + +## Release 2.1.4 + +* ENHANCEMENT: Basic Zimit file reading in IE11 +* UPDATE: Sample archive updated to `wikipedia_en_climate_change_mini_2022-08` +* UPDATE: Provide more complete documentation on GitHub +* FIX: Correct location of relative links on Zimit landing pages +* FIX: Add more asset types to Type 1 C-namespace Zimit support + +## Release 2.1.0 + +* UPDATE: Sample archive updated to `wikipedia_en_climate_change_mini_2022-07` +* UPDATE: Packages are now signed with new Kiwix coding certificate +* UPDATE: BitTorrent files are now displayed before magnet links in the download library +* FIX: Support reading of Zimit archives using new Type 1 C-namespace ZIM format +* FIX: Searching for namespaces with Type 1 Zimit ZIMs +* FIX: Hyperlink transformations for Type 1 Zimit ZIMs +* FIX: Package and install icons for WikiMed and Wikivoyage +* FIX: Bug which caused app to hang when encountering URLs larger than 2KB in length + +## Release 2.0.9 + +* ENHANCEMENT: System back button in UWP app no longer exits the app +* ENHANCEMENT: Hyperlink the currently loaded archive so that user can re-open it easily with a click +* ENHANCEMENT: Make archive links combo box scrollable +* ENHANCEMENT: Make buttons more visible in dark mode +* FIX: Do not redirect to landing page if requested article is not found +* FIX: Prevent app entering an anomalous state if launch of Service Worker mode fails +* FIX: File handling API (works with latest Chrome, and with Edge Beta) +* FIX: Distinguish between Electron and NWJS when reporting app type to UI +* FIX: Dark style for new Stackexchange ZIMs + +## Release 2.0.8 + +* FEATURE: Optionally check for app updates and inform user of availability +* ENHANCEMENT: Radical improvement in CSS rendering in Zimit ZIMs +* ENHANCEMENT: Option to warn before opening external links +* ENHANCEMENT: Provide magnet torrent links in Archive Library +* ENHANCEMENT: Provide link to preview of live ZIM archive on library.kiwix.org +* ENHANCEMENT: Reduce delay between image loads when lazy-loading images (Wikimedia ZIMs) +* ENHANCEMENT: Speed up regex processing of Zimit transforms +* ENHANCEMENT: Intelligently auto-switch image manipulation setting if supported by ZIM type +* ENHANCEMENT: Intelligently turn off dark theme if ZIM does not support it +* ENHANCEMENT: Improve MathML detection +* UPDATE: KaTeX library updated to 0.16 +* FIX: Skipping forwards and backwards in videos inside Chromium frameworks +* FIX: Derive redirect information from Zimit Headers if the response is mising from the archive +* FIX: Searching for assets in url index now properly shows the url instead of title +* FIX: System alert dialogue box now handles keyboard events +* FIX: Add some failsafe code to hide spinner if it runs too long (does not handle app crashes) +* FIX: More robust insertion of Contet Security Policy into article +* FIX: Failure to interpret MathML in some circumstances +* FIX: Process correctly the `srcset` property in image sets for Zimit ZIMs +* FIX: Disable lazy image loading in Zimit ZIMs +* FIX: Add some failsafe code to hide spinner if it runs too long (does not handle app crashes) +* FIX: Dark theme for new Stackexchange ZIMs +* FIX: Interoperability between JQuery and Service Worker modes with Zimit archives +* FIX: Max page width manipulation in IE11 + +## Release 2.0.0 + +* FEATURE: Search for any asset in any ZIM by prefixing namespace +* ENHANCEMENT: Filter out undesired files more effectively (Zimit ZIMs) +* ENHANCEMENT: Process URLs in JavaScript files (Zimit ZIMs) +* ENHANCEMENT: Ensure user clears the cache when switching to SW mode while a Zimit ZIM is loaded +* ENHANCEMENT: Prevent expensive RegExp processing for irrelevant ZIM types +* ENHANCEMENT: Driect download certain recognized content types for Zimit archives +* ENHANCEMENT: Made PWA manifest compatible with Chromium installability criteria +* UPDATE: Refresh Kiwix icons +* UPDATE: Remove landing page override for mdwiki at request of maintainer +* UPDATE: Hyperlinking of images to high-res versions is now off by default +* FIX: Bug that caused repeating images when hyperlinking images to online high-res versions +* FIX: Erroneous link handling for Zimit files +* FIX: Add any missing file extension to downloadable files and construct MIME types if missing +* FIX: Exception when reloading the last selected archive on certain platforms +* FIX: Remove lazy image loading system if detected +* FIX: Errors with parsing and display of archive links in download library +* FIX: Adjustment to max page width restrictions is now applied on resize +* FIX: Remove more analytics spy scripts from Zimit ZIMs +* FIX: Incorrect meta tag encoding for some Zimit archives + +## Release 1.9.9 + +* UPDATE: Sample archive updated to `wikipedia_en_climate_change_mini_2022-04` +* FEATURE: Experimental support for reading Zimit ZIM archives +* FIX: Support for reading background and bullet images in Zimit CSS in Service Worker mode +* FIX: Style of thumbinner Wikipedia images adjusted so that images are back in their original position +* FIX: MDwiki thumbinner images now have an MDwiki-specific override to prevent text bleeding to left of image +* FIX: Links to PDF data are now recognized by MIME type and downloaded as if they were files +* FIX: Support image links that have querystrings in Zimit archives +* FIX: Support percent-encoded ZIM URLs in Zimit archives +* FIX: Transition away from testing file extensions for caching strategy +* REGRESSION: Fix display of book thumbnails in Gutenberg ZIMs +* BUILD: Nightly builds of main app are now uploaded to a new server (with sftp instead of ssh) +* BUILD: Deploy PWA image on a k8s cluster +* BUILD: PWA images are now uploaded to ghcr.io instead of Docker Hub + +## Release 1.9.6 + +* UPDATE: Sample archive updated to `wikipedia_en_climate_change_mini_2022-03` +* FEATURE: Option to hyperlink images in Wikimedia ZIMs to the online File for the image +* ENHANCEMENT: Electron app now uses File System Access API except for initial loading of packaged archive +* DEV: Provided instructions on how to split a ZIM archive using WSL +* DEV: The NWJS app is now built via CI (including nightly) +* FIX: App now (optionally) remembers the last viewed article for split ZIM archives +* FIX: Electron and UWP apps now auto-load split ZIM archives +* FIX: Failure to recognize landing page when retrieved from history or cache + +## Release 1.9.3 + +* UPDATE: New sample archive: `wikipedia_en_climate_change_mini_2022-02` +* FEATURE: Electron apps now auto-update (Windows exe and Linux AppImage versions only) +* ENHANCEMENT: App now recognizes `mdwiki` ZIMs as WikiMed variants, and shows custom landing page +* REGRESSION: The NWJS has reverted to using JQuery mode by default while investigating an app crash with some articles in SW mode +* DEV: Automatic building of Electron app now enabled via GitHub Actions +* FIX: Improvement to independent browsing of windows in UWP app in SW mode +* FIX: Patch some CSS errors in `mdwiki` ZIMs +* FIX: Stabilize page loading when assets are missing (in SW mode) +* FIX: Styling of image-based landing pages + +## Release 1.9.0 + +* ENHANCEMENT: Service Worker mode is now the default in contexts or frameworks that natively support it with good performance +* ENHANCEMENT: Option to reset app to defaults in Expert settings +* ENHANCEMENT: Better feedback to user during slow ZIM archive loading +* ENHANCEMENT: Included favicons at various resolutions +* ENHANCEMENT: App now uses Bootstrap asynchronous dialogue boxes for modal alert and confirm +* DEV: Developer option to bypass appCache +* DEV: Window location information now shown in API panel +* FIX: Bug that would sometimes cause a blank screen in Service Worker mode on slow devices +* FIX: Set headers properly when caching Fetch responses in JQuery mode +* FIX: Loading of articles that have question marks or hashes in the title +* FIX: Incorrect attempt to register Service Worker in XP version of NWJS app causing fatal crash on startup +* FIX: Random button now warns user if archive is not loaded +* FIX: Race condition loading deocmpressors which caused failure in some rare contexts with the file:// protocol +* FIX: Bug preventing proper loading of landing page in Khan Academy and TED Talks ZIMs + +## Release 1.8.6 + +* UPDATE: Sample archive updated to `wikipedia_en_100_nopic_2021-12` +* ENHANCEMENT: Assets cache and app cache are now separated, so assets persist after update +* ENHANCEMENT: New persistent caching of ZIM assets that are not provided in file system singinficantly improves performance +* ENHANCEMENT: Automatically choose best available caching technology: Cache API, IndexedDB, Local Storage or memory +* ENHANCEMENT: New Cache API info panel in Configuration, and option to stop using and empty the cache +* FIX: Regression whereby blue image placeholders were not shown in jQuery mode when user turns off image display +* FIX: Bug whereby upgrade alert was triggered by caches from other apps on the same domain + +## Release 1.8.5 + +* FIX: Stylesheet errors with sistersite boxes +* FIX: Regression with Electron file handling causing previously picked archive to be forgotten +* FIX: Fatal Electron error on startup if packaged archive cannot be found +* FIX: NWJS file handling with legacy file picker (for XP and Vista builds) + +## Release 1.8.2 + +* UPDATE: Sample archive updated to `wikipedia_en_100_nopic_2021-11` +* UPDATE: App can now use the latest Electron release and APIs +* ENHANCEMENT: Electron version can now read contents of a picked archive directory +* ENHANCEMENT: Scrollbars are now styled (with darker colours) in dark mode (in Chromium frameworks) +* ENHANCEMENT: More app files are precached in the PWA for better offline experience +* ENHANCEMENT: Hardware back and forward buttons on mouse now work with UWP app (natively supported in other contexts) +* FIX: Prevent most app crashes when switching to SW mode in UWP app +* FIX: More intelligent relocation of hatnote and noexcerpt blocks +* FIX: UI bug when using the UWP app with a secondary display (via Config option) +* META: Release of UWP/PWA and Electron/NWJS versions of the app are now unified + +## Release 1.7.8 + +* UPDATE: Sample archive updated to `wikipedia_en_100_nopic_2021-10` +* EXPERIMENTAL: Added option to display hidden block elements, prinicipally for Wikimedia ZIMs +* ENHANCEMENT: With display hidden elements opetion, force display of zero-width images also +* ENHANCEMENT: Allow more time between clicks to register a double-right-click +* FIX REGRESSION: Prevent incorrect parsing of map markers when image manipulation is on in SW mode +* FIX REGRESSION: Closing all sections (by deselecting "Open all sections") now works again in jQuery mode +* BACKEND: Use a safer way of determining the ZIM name and type + +## Release 1.7.6 + +* UPDATE: Sample archive updated to `wikipedia_en_100_nopic_2021-09` +* ENHANCEMENT: The app should now show dynamic content on landing pages in YouTube-based ZIMs (SW mode) +* ENHANCEMENT: Option for map pins to open OpenStreetMap instead of Windows Maps App (mostly for Wikivoyage) +* ENHANCEMENT: Select map type automatically: Maps App for Windows, OSM for Linux or other +* ENHANCEMENT: Use smaller pins for Wikipedia pages vs Wikivoyage pages +* DEPRECATED: Disabled *indpenedent* resizing of content in iframe with touch: too slow, and worked only in Chromium +* FIX: Video playback controls are now shown in Khan Acadeny ZIMs (and others based on YouTube) +* FIX: Bug relocating hatnotes which moved extraneous text blocks +* FIX: Image rendering bug with substitute landing pages +* FIX: Fatal error loading the PWA in some circumstances +* FIX: Data URIs with WebP images can now be rendered in old browsers +* FIX: Style issues and rendering of map pins in German Wikimedia ZIMs +* FIX: Error with offline Cache that prevented PWA from working fully offline +* FIX: Prevented the NWJS app for Windows XP from attempting to switch to SW mode (which doesn't work) + +## Release 1.7.3 + +* ENNHNCEMENT: Added more diagnostic APIs to the API panel in Configuration +* ENHANCEMENT: Added refresh button for picked folder in Configuration (UWP or File System Access API) +* ENHANCEMENT: Added some extra directories of useful ZIM archives to Donwload library +* ENHANCEMENT: Provide option to allow image manipulation (saving to disk or opening in new tab) +* ENHANCEMENT: Provide contextual warnings for features that do not work well with dynamic content +* ENHANCEMENT: Added help section in About concerning link handling, dynamic content, new windows, etc. +* ENHANCEMENT: Verbose tooltips provided for several options in Configuration +* ENHANCEMENT: Usage instructions more clearly highlighted on first run +* UPDATE: Sample ZIM changed to `wikipedia_en_100_nopic_2021-08.zim` in order to reduce app size +* UPDATE: New option to change right click to double right click for opening new window or tab +* FIX: Issue preventing correct parsing of ZIM archive path in some contexts in SW mode +* FIX: Some app crashes when switching the UWP app to SW mode +* FIX: Printing in SW mode (load all images correctly before printing) +* FIX: Restoring DOM after printing in SW mode +* FIX: Issues with toolbars getting stuck on after searching for text in article +* FIX: Better replication of infobox mobile and desktop styles +* FIX: Typo in code causing some pages to load assets incorrectly in jQuery mode +* FIX: Updated style locations for custom WikiMed landing page (fixes display issue) + +## Release 1.6.0 + +* FEATURE: New dropdown in Download Library allows filtering the list of archives by subject (for some ZIM types) +* ENHANCEMENT: Sorting the Download Library list by clicking on the Size / Last modified / Name headers +* ENHANCEMENT: The app can now take advantage of native Promises (faster than Q) +* ENHANCEMENT: Decompressors now loaded as fast binary WASM modules if the brower supports WebAssembly +* UPDATE: Sample ZIM updated to `wikipedia_en_100_maxi_2021-07.zim` +* EXPERIMENTAL: Intalled PWA can now be opened offline when double-clicking ZIM archive (depends on File Handling API) +* FIX: More displaced hatnotes corrected +* FIX: Style injection code that would (rarely) cause an exception on some ZIM types + +## Release 1.5.0 + +* FEATURE: Search with wildcards `.*`, `.+` or regex syntax `(?:my_regular_expression)` +* FEATURE: (Experimental) PWA is paritcipating in File Handling API origin trial +* ENHANCEMENT: Significant speed-up by using native Promise API, or modern polyfill where needed +* ENHANCEMENT: Added full usage/syntax notes for title search and Alphabetical Title Index +* ENHANCEMENT: Include `h4` headings in Table of Contents +* ENHANCEMENT: Report number of titles scanned for long title searches +* UPDATE: Sample ZIM updated to `wikipedia_en_100_maxi_2021-06.zim` +* FIX: Display of ZIM Archive Index +* FIX: Bug which failed to detect images correctly in a new tab +* FIX: Touch-zoom of contents of iframe no longer blanks part of the display +* FIX: Broken zoom of contents of iframe (with UI buttons) in Internet Explorer +* FIX: Bug setting up backlinks which caused some pages not to load +* FIX: Unhandled exception when cite ref was not found + +## Release 1.4.2 + +* ENHANCEMENT: Improve zooming and re-flowing the article contents in browsers that support the `zoom` style property +* ENHANCEMENT: Add a Content Security Policy preventing contents of a page from connecting to online resources +* FIX: Crash in UWP app after updating a ZIM archive +* FIX: Improve handover from local code to PWA code to prevent rogue error message +* FIX: Improve page composition timing for non-MS browsers + +## Release 1.4.1 + +* FIX: Critical bug where article is not unhidden in time on slow systems in jQuery mode +* FIX: Issues with dark mode in Gutenberg ZIMs using SW mode +* FIX: Missing images from book lists in Gutenberg ZIMs + +## Release 1.4.0 + +* ENHANCEMENT: Pre-calculate position and size of article namespace in legacy ZIMs (speeds up binary search) +* ENHANCEMENT: New option to move navigation buttons to the top toolbar +* UPDATE: Sample ZIM updated to `wikipedia_en_100_maxi_2021-05.zim` +* UPDATE: System dark/light mode now used for "auto" setting in modern browsers (as well as UWP) +* UPDATE: KaTeX to v0.13.11 +* FIX: Double-clicking on archive failed to launch it in UWP app running in SW mode +* FIX: Hover and active colours on buttons +* FIX: Hide jump in page position during article load in Service Worker mode +* FIX: Adjusted timing of hiding and showing the article during page composition +* FIX: Intermittent failure to compose page in UWP app on mobile +* FIX: Reposition multiple displaced hatnotes +* FIX: Click on document reloads article when open new window feature is off +* FIX: Bug which prevented auto launch of packaged file on first install +* FIX: Issue preventing the article window from receiving focus for keyboard input + +## Release 1.3.2 + +* FEATURE: Open a new browsable tab or window with right-click, long-press, ctrl-click, middle-click +* UPDATE: Sample archive updated to `wikipedia_en_100_maxi_2021-04` +* UPDATE: Release Linux AppImage packages for Electron-based build +* ENHANCEMENT: Alt-left or Ctrl-left (and same for right key) can now be used for navigation +* FIX: Prevent flash between page loads by adapting empty screen to the selected theme color +* FIX: Crash on upgrade of ZIM archive in some contexts +* FIX: Subtitle dislplay on videos +* FIX: Download of media and subtitles +* FIX: Display of list-based home pages +* FIX: Failure to apply dark theme to articles with no CSS +* FIX: Bug affecting middle-click when opening a new window or tab +* FIX: Bug which hid the file selectors when the app could not get a handle on a file or directory +* FIX: Bug preventing touch navigation + +## Release 1.2.5 + +* ENHANCEMENT: PWA now adapts if it was launched from a basic packaged app +* UPDATE: Location of cached styles tweaked to reflect latest location in ZIM archives +* UPDATE: Cached main pages for WikiMed and Wikivoyage updated and used by vanilla app +* FIX: Properly define width of infoboxes in Wikimedia Destop style + +## Release 1.2.4 + +* UPDATE: Packaged archive updated to `wikipedia_en_100_maxi_2021-03` +* ENHANCEMENT: Support v1 article index in no-namespace ZIM archives +* ENHANECMENT: Detect and correct erroneous hard-coded sytling of navboxes in recent ZIMs +* FIX: Correct width of infoboxes in Wikipedia Desktop style +* FIX: Failure to recognize mouse click on title index entry +* FIX: Issue preventing proper relocation of infobox when transforming to desktop style + +## Release 1.2.3 + +* UPDATE: Better messaging around 'failure' to load SW mode (not a real failure) +* FIX: Calculation of appRoot directory + +## Release 1.2.2 + +* ENHANCEMENT: Use a list of customized start pages even if the app is generic +* FIX: Map markers not showing in Service Worker mode +* FIX: Implement internal app:// links for app-based assets +* FIX: Race condition in handover to PWA code +* FIX: Faulty permalinks + +## Release 1.2.1 + +* UPDATE: Minor update to improve handover between local and PWA code +* ENHANCEMENT: If app is running as a PWA, its identity is changed to Kiwix JS PWA +* FIX: Display of masonry tiles in JQuery mode with latest ZIMs + +## Release 1.2.0 + +* ENHANCEMENT: Enable Service Worker mode in UWP app +* ENHANCEMENT: New domain pwa.kiwix.org for the PWA/UWP app +* UPDATE: Preliminary support for ZIM archives with no namespace +* UPDATE: Revised Privacy Policy to reflect PWA usage + +## Release 1.1.4 + +* UPDATE: Included ZIM updated to `wikipedia_en_100_maxi_2021-01.zim` +* UPDATE: More consistent install prompt display in Configuration (for PWA) +* ENHANCEMENT: Provide more robust upgrade process for PWAs, including notification banner +* FIX: Disable HTTP cache when pre-caching upgraded app files +* FIX: Switching to jQuery mode in the PWA app no longer prevents the app working offline +* FIX: Display of masonry-style landing pages in SW mode +* FIX: Inconsistent use of Settings Store during app initialization +* FIX: Delete accidentally created Indexed Databases with wrong filename on startup (where possible) +* FIX: Provide explicit Content Security Policy headers to reduce or eliminate CORS errors in SW mode +* FIX: Broken manual display of images in SW mode +* FIX: Broken "Open all headings" option in SW mode +* FIX: Printing in SW mode +* FIX: Bugs with reload of last visited article +* META: Create-DraftRelease PowerShell script supports automatic creation of GitHub releases for more versions of the app + +## Release 1.1.3 + +* UPDATE: Included ZIM updated to `wikipedia_en_100_maxi_2020-12.zim` +* UPDATE: Support new location of mobile and desktop styles in Wikimedia ZIMs +* UPDATE: Upgrade Settings store to use localStorage over cookies where available +* ENHANCEMENT: Enable use of Native File System with NWJS +* FIX: Styling of index-based landing pages +* FIX: Bugs with file picking in Native FS + +## Release 1.1.2 + +* UPDATE: Included ZIM updated to `wikipedia_en_100_maxi_2020-11.zim` +* UPDATE: WebP support (via polyfill) for older browsers including Windows Mobile +* ENHANCEMENT: Improved block cache and faster conversion of file slice to blob +* REGRESSION: Manual extraction of images reverted to one-by-one to prevent errors with WebP batch decoding +* FIX: Critical error on some new Wikipedia articles containing equations +* FIX: Prevent erroneous display of Active Content Warning with ZSTD archives +* FIX: Reduce some cross-origin errors + +## Release 1.0.0 + +* UPDATE: Included ZIM updated to `wikipedia_en_100_maxi_2020-09.zim` +* UPDATE: App now supports newest archives encoded with ZSTD compression +* ENHANCEMENT: Decompression speed gains with ZSTD +* ENHANCEMENT: Allow use of keyboard to select archive from archive list +* ENHANCEMENT: Option to display articles with all sections open or closed +* FIX: Prevent archive list from jumping to wrong archive on click +* FIX: Critical error on load if packaged archive name has changed +* FIX: Download links are no longer erroneously cached by the Service Worker +* DEPRECATED: Scrolling information for new users + +## Release 0.9.9.992 (beta) + +* UPDATE: Included ZIM updated to `wikipedia_en_100_maxi_2020-08.zim` +* UPDATE: Some new Kiwix icons +* FIX: Prevent extraneous titles appearing in search +* FIX: Broken drag-and-drop +* FIX: Bug with construction of backlinks preventing load of some Wikipedia articles +* FIX: Calculate path of breakout icon correctly in SW mode +* ENHANCEMENT: Use Native File System API in PWA version +* ENHANCEMENT: Fix printing in the Electron app +* ENHANCEMENT: Support launching Electron app from shortcut +* ENHANCEMENT: Better error reporting in console log + +## Release 0.9.9.991 (beta) + +* FIX: Bug preventing all Kiwix apps accessing latest ZIMs (incorrect method of reading MIME type list) +* ENHANCEMENT: Included ZIM changed to wikipedia_en_100_maxi_2020-06.zim +* FIX: Several bugfixes to allow better running of Electron app in SW mode + +## Release 0.9.9.99 (beta) + +* ENHANCEMENT: Major upgrade to the title-search algorithm: search is now near-case-insensitive +* UPDATE: Included sample ZIM updated to wikipedia_en_ray_charles_maxi_2020-05.zim + +## Release 0.9.9.98 (beta) + +* ENHANCEMENT: Make app compatible with Electron / NWJS as a packaged app +* ENHANCEMENT: Better user experience for PWA version +* ENHANCEMENT: Attempt to make app a little more usable on Android browsers +* FIX: Incorrect layout when transforming WikiMed articles to desktop style +* FIX: Failure to load landing page when backing into it from history.back +* FIX: Incorrect hiding of toolbars after using in-page search +* UPDATE: Update Q Promise support to v1.5.1 + +## Release 0.9.9.97 (beta) + +* ENHANCEMENT: Intuitive toolbar hiding/showing on scroll down/up +* ENHANCEMENT: Added block cache to speed up search considerably +* ENHANCEMENT: Provide option to set number of results to find when searching +* ENHANCEMENT: Provide app install experience for PWA +* FIX: Search results can now be scrolled by touch on Windows 10 tablets +* FIX: Corrected height of search results window so content is not hidden under footer +* FIX: Prevent ugly jumping of iframe on new article load +* FIX: Allow use of special characters in article search +* FIX: Remove broken links to deprecated portable versions of archives +* UPDATE: Added missing stylesheets for cache +* UPDATE: Added some more initial files to load for PWA + +## Release 0.9.9.96 (beta) + +* FIX: Broken display of Kiwix download library +* FIX: Broken display of MathML when there are no images in the document +* FIX: Search bar always remains on-screen if selected (in non-mobile contexts) +* FIX: All images above the fold are now loaded (async timing of image scanning was premature) +* FIX: Math typeset by KaTeX is rendered better when there are mbox statements (fbox is used instead) +* FIX: Display-style maths SVGs are now correctly inverted in dark mode +* FIX: Standard dark-mode SVGs in infoboxes and elsewhere are now displayed correctly without inversion +* FIX: Truncated display of search box +* UPDATE: Updated KaTeX library to v0.11.1 +* ENHANCEMENT: Include more files in PWA payload to allow better offline functionality in PWA scenarios +* ENHANCEMENT: Appxbundle is now signed with Kiwix certificate for a better sideloading experience +* KNOWN ISSUE: In mobile contexts, top bar always gets hidden by Bootstrap on scroll + +## Release 0.9.9.95 (beta) + +* UPDATE: Improved support for stylesheets in latest Wikipedia ZIMs +* UPDATE: Updated the Privacy Policy +* ENHANCEMENT: The base app (not UWP) can now be installed as a PWA (visit to try) +* ENHANCEMENT: Assets are now cached in Service Worker mode +* ENHANCEMENT: Support MathML in latest Wikimedia ZIMs +* FIX: Fixed broken drag-and-drop +* FIX: Enable page extraction in Service Worker mode +* FIX: Rare condition where a missing ZIM causes the app to crash on load +* FIX: Fixed broken display of active content warning + +## Release 0.9.9.94 (beta) + +* ENHANCEMENT: Provide an alert if a packaged or picked file cannot be found +* ENHANCEMENT: App can now be compiled with Electron or NWJS to support Win XP/7/8.1 (see [releases](https://github.com/kiwix/kiwix-js-windows/releases)) +* ENHANCEMENT: CORS errors are now detected and a message provided to the user to help resolve +* ENHANCEMENT: Fallback to localStorage if cookies are not supported (e.g. running Chromium from file:///) +* FIX: Bug with equations containing apostrophes +* FIX: ZIMs running in quirks mode are now patched to run in standards mode +* FIX: Better algorithm for adding missing notes backlinks +* FIX: Better process for hiding navbar (though Bootstrap still ignores on mobile) +* FIX: All blocks are now opened for details-summary tags +* FIX: Bugs with the timing of display blanking between page loads +* FIX: Missing target attribute for hyperlinks to some external files +* FIX: Race condition preventing jQuery `alert.hide()` statements from running +* FIX: Enable dark theme and style transformations in Service Worker mode +* FIX: Enable printing in Service Worker mode +* FIX: Critical page reload loop when switching styles in print dialogue +* FIX: Update printing filters to support deatils-summary ZIMs +* FIX: Rare condition where a missing ZIM causes the app to crash on load +* FIX: Article is now re-loaded on change of content injection mode +* FIX: Scripts no longer run in Quirks mode (for clients supporting Service Worker) +* UPDATE: August 2019 update of Ray Charles ZIM + +## Release 0.9.9.91 (beta) + +* FIX: Remembered last page is now properly blanked on new archive load +* FIX: The article content div is now hidden until the HTML for the requested article is injected +* FIX: Number of stylesheets retrieved from ZIM was not being counted properly, causing some pages to load twice +* FIX: New MediaWiki ZIMs with details-summary tags are now supported +* FIX: Low-level ZIM reader now conforms to libzim logic in deriving title from url +* FIX: Low-level ZIM reader now reads the MIME type list from the ZIM +* FIX: A system alert utility is now provided, to avoid using synchronous alert() +* FIX: Bug causing localStorage to fill up has been fixed +* FIX: A workaround has been added for improperly coded hyperlinks in subdirectories in WikiMedia ZIM files +* FIX: Various tweaks to cached and trasnformed styles +* FIX: Many more equations now rendered correctly due to change of engine +* FIX: Service Worker mode now works in browser context (not app context) +* FIX: MathTex now rendered in Service Worker mode +* UPDATE: Removed dependency on base tag, simplifying handling of hyperlinks +* ENHANCEMENT: Links in clickable image maps (e.g. in Wikivoyage) are now supported +* ENHANCEMENT: App code supports developer setting a custom start page for a packaged ZIM +* ENHANCEMENT: A ZIM archive can be loaded through drag-and-drop of the file into the app +* ENHANCEMENT: A ZIM archive can be loaded by double-clicking the file in Explorer +* ENHANCEMENT: Article search results can now be selected with physical keyboard (down, up, enter keys) +* ENHANCEMENT: Better lazy image loading, and enable lazy loading for Service Worker mode +* ENHANCEMENT: Subtle fade-in effect for lazy-loaded images +* ENHANCEMENT: Allow breakout link to work in Service Worker mode +* ENHANCEMENT: Change MathTex rendering engine from MathJax to KaTeX (much faster) + +## Release 0.9.9.90 (beta) + +* FIX: Remembered last page is now properly blanked on new archive load +* FIX: Number of stylesheets retrieved from ZIM was not being counted properly, causing some pages to load twice +* FIX: The article content div is now hidden until the HTML for the requested article is injected + +## Release 0.9.9.89 (beta) + +* FIX: Fixed regression preventing use of download library +* FIX: Fixed problems searching for dirEntries with empty titles in new ZIMs +* FIX: Correctly handle anchor links with a single # +* ENHANCEMENT: Improved styling of checkboxes in light and dark modes + +## Release 0.9.9.88 (beta) + +* ENHANCEMENT: Article can now be sent to device's browser for reading, side-by-side viewing, printing +* ENHANCEMENT: A breakout icon can optionally be shown on each page to enable sending page to browser (see Settings) +* ENHANCEMENT: A new "auto" setting for dark mode and dark theme follows the system default for UWP apps +* ENHANCEMENT: Checkbox and radio buttons are now styled and coloured for better visibility (also larger) +* ENHANCEMENT: Packaged apps now default to showing the most appropriate ZIM archive types from Library +* ENHANCEMENT: Streamlined the process for adding other languages of packaged app ZIM files +* ENHANCEMENT: Language and date selectors in Library are now responsive to each other +* ENHANCEMENT: Download link more clearly signalled +* UPDATE: Deal with re-organized stylesheets in mwoffliner ZIMs +* FIX: Fixed regression caused by removal of timeout for find in article function +* FIX: App detects a language that is predominantly ASCII and uses left-side word searching in that case (Chinese open-type search should be unaffected) +* FIX: Prevent crash if changing language selector on "wrong" screen +* FIX: Prevent timeout-related crashes on slower +* FIX: Prevent unusable app state after clicking non-Roman alphabet button in Archive Index + +## Release 0.9.9.87 (beta) + +* FIX: Removed timeout preventing fast typing for find in article function (Ctrl-F / Alt-F) +* FIX: Allow searching in article for languages that do not use spaces (such as Chinese) + +## Release 0.9.9.85 (beta) + +* ENHANCEMENT: Support for playing media (video/audio) in the ZIM if the device has the required codec +* ENHANCEMENT: Support for "downloading" media (e.g. videos+subtitles) from the ZIM +* ENHANCEMENT: Media are launched via appropriate app selection menu after download (mobile) +* ENHANCEMENT: Preliminary support for TED and dirtybiology ZIMs +* ENHANCEMENT: Preliminary support for Project Gutenberg ZIMs +* ENHANCEMENT: Support for "downloading" epub ebooks from Gutenberg ZIMs +* ENHANCEMENT: Epubs are launched in Edge's built-in epub reader, or via app selection menu +* ENHANCEMENT: Typing a space in search box now displays an Archive Index +* ENHANCEMENT: Option to support non-Roman alphabets for Archive Index +* ENHANCEMENT: If active content is detected in the ZIM, information is given about accessing the Index instead +* FIX: Add startup bootloop crash prevention +* FIX: Exceptions produced by unsupported JS in ZIM articles are now caught +* FIX: Prevent app crash with malformed anchor references +* FIX: Rogue ampersands in MathJax output are now correctly escaped +* FIX: Correct logic in binary search so it doesn't stall if assets in A namespace have no title +* FIX: Missing footnote reference numbers in desktop ZIMs transformed to mobile style +* FIX: Assets with unescaped characters in URL should now be retrieved correctly +* FIX: Individual extraction of images when images are disabled in Configuration + +## Release 0.9.9.8 (beta) + +* UPDATE: Ray Charles ZIM to October 2018 version +* ENHANCEMENT: Add a modern CSS spinner and rework status messages +* ENHANCEMENT: Neater presentation of article search results +* FIX: Crash when previously picked archive has been moved or deleted +* FIX: Support changed format of anchor references in latest English Wikipedia +* FIX: Correctly apply mobile styles when one of the defaults is missing +* FIX: Incorrect utf8 characters in mobile styles + +## Release 0.9.9.7 (beta) + +* ENHANCEMENT: Optimization of decompression process +* WORKAROUND: Prevent periodic hang in Service Worker mode +* FIX: Crash in RegExp engine caused by malformed backreferences in some articles + +## Release 0.9.9.6 (beta) + +* UPDATE: Mobile styles +* ENHANCEMENT: New compile of decoding engine provides significant performance improvement +* ENHANCEMENT: Better memory management to prevent app crashes +* ENHANCEMENT: Reduced dependency on jQuery for further performance gains +* ENHANCEMENT: Tweaks to dark theme +* ENHANCEMENT: Improvements to show-hide sections toggle function with footnote/endnote references +* FIX: Headers that open or close sections are no longer accidentally selected on tap or click +* FIX: Descriptive text for UI controls is now non-selectable for cleaner app experience +* FIX: Whitespace at the end of the page is now preserved when hiding reference section +* FIX: Tapping headers now only opens and closes sections on narrow screens as intended by WikiMedia + +## Release 0.9.9.5 (beta) + +* ENHANCEMENT: Headings in article can be toggled open or closed with tap or click +* ENHANCEMENT: Current page is cached in localStorage for very fast restart and reloading +* ENHANCEMENT: Automatically switch to desktop style for better printing result +* FIX: Bug which prevented switching the printing device (caused app crash) +* FIX: Bug in download links preventing display of language codes that are substrings of other language codes + +## Release 0.9.9.4 (beta) + +* ENHANCEMENT: Experimental support for printing articles +* ENHANCEMENT: Print zoom capability +* ENHANCEMENT: Prevent printing of location pins +* ENHANCEMENT: Set maximum page width to 100% before printing +* ENHANCEMENT: Better presentation of About and Changelog information +* WORKAROUND: MW-Offliner bug which places extraneous tags in some HTML id attributes + +## Release 0.9.9.3 (beta) + +* FIX: Article now reloads correctly when switching styles +* FIX: Unhandled exception after using in-article word search +* FIX: Browser history now remembered for first page load +* ENHANCEMENT: Filter ZIM archives by date in download links +* ENHANCEMENT: Option to remove maximum page width restriction for Wikipedia articles +* ENHANCEMENT: Setting or clearing dark themes no longer require page reload +* ENHANCEMENT: Wider range of infoboxes, and "homonymie" hatnotes supported +* ENHANCEMENT: Better algorithm for moving first paragraph when there are stacked infoboxes + +## Release 0.9.9.2 (beta) + +* FIX: Added more padding for content hidden under the bottom bar +* FIX: New mode of injecting HTML into iframe fixes baseUrl issues +* ENHANCEMENT: Some code redundancy removed +* ENHANCEMENT: Faster typesetting of TeX equations +* ENHANCEMENT: Experimental support for equations in mathoverflow and related stackechange ZIMs +* ENHANCEMENT: Dark theme support for stackexchange ZIMs +* ENHANCEMENT: Uncluttered the UI for file selection + +## Release 0.9.9 (beta) + +* FIX: Reduced memory usage for decompressing multiple SVG images/equations to prevent crash on devices with 1GB RAM +* FIX: Display bug causing Settings tab to remain selected after article load +* FIX: Corrected dark-style backgrounds in some infoboxes on WikiMed +* FIX: Loads landing page when an article is not found (instead of throwing a silent error) +* WORKAROUND for misplaced hatnotes in mobile-style ZIMs +* WORKAROUND for hidden IPA pronunciation information on some articles +* ENHANCEMENT: 'Unclicking' a tab (Settings or About) now returns the user to the article +* ENHANCEMENT: Activating dark theme for UI now activates article dark theme by default +* ENHANCEMENT: Improved handling and display of file selectors +* ENHANCEMENT: Clearer navigation signposting from About tab +* ENHANCEMENT: Dedicated icon for WikiMed archives + +## Release 0.9.7 (beta) + +* UPDATE: January 2018 update of Wikivoyage ZIM archive to wikivoyage_en_all_novid_2018-01.zim +* ENHANCEMENT: The Wikivoyage app now hides the file selectors by default in the Config menu to avoid confusion and to encourage use of Kiwix JS for anything not related to Wikivoyage +* FIX: Added icon indicating that a link is to an external web site +* ENHANCEMENT: Inject footnote backlinks if the ZIM doesn't have any +* ENHANCEMENT: Support ZIMs that have subdirectories (Stackexchange family ZIMs) +* FIX: Bugs in mobile to desktop style transformation +* FIX: Issue with infoboxes and images not stacking correctly on mobile displays +* FIX: Support new-style infoboxes in German Wikivoyage +* FIX: Last-visited page was not being remembered when user picked the file as a single archive +* FIX: Bug which prevented the dark mode by simple inversion from functioning +* FIX: Issue with toolbar icons being misaligned on small screens + +## Release 0.9.6 (beta) + +* FIX: Prevent bottom toolbar from wrapping across two lines on small screens +* ENHANCEMENT: Enabled autoloading of last-read page on app start (and privacy option to turn this off) +* ENHANCEMENT: Geo-location co-ordinates in English and German Wikivoyage are represented with a location marker that links to the Maps app (opens map to show the precise location) +* ENHANCEMENT: Telephone numbers marked with tel: links will attempt to open a relevant app for dialling (e.g., Skype or the People app) when selected +* FIX: Links in Stackexchange ZIMs are now recognized and can be used to open the content +* WORKAROUND: Some Wikivoyage entries have HTML showing in the header, and this is now (temporarily) suppressed (the HTML is interpreted) until the ZIMs are fixed +* ENHANCEMENT: The toolbar icon now switches to a Wikivoyage logo if a Wikivoyage ZIM is loaded + +## Release 0.9.3 (beta) + +* WORKAROUND: Mis-aligned toolbar icons on smaller screens +* FIX: Rogue HTML showing in some pages from recent ZIM archives +* ENHANCEMENT: Better experience when scanning local storage for archives + +## Release 0.9.0 (beta) + +* ENHANCEMENT: Auto-loading of ZIM archives on device storage +* ENHANCEMENT: In-page search / highlighting with Ctrl-F / Alt-F or tap on search button +* ENHANCEMENT: Uses UWP APIs for sotrage: Future Access List so that users do not need to pick their ZIM file every time +* ENHANCEMENT: Dark-themed User Interface +* ENHANCEMENT: Experimental Wikipedia Dark Theme +* ENHANCEMENT: Font scaling for articles and for the UI +* ENHANCEMENT: Cleaner, minimalistic UI (eliminated hamburger menu due to poor navigability) +* FIX: Display of SVG files is handled by careful queuing of images to send to the decompressor (fixes hang in articles with many equations) +* ENHANCEMENT: If the TeX string of an equation is available, it will be typeset using MathJax (huge speed improvement) +* ENHANCEMENT: Transform the layout of Wikipedia articles from desktop to mobile style and vice versa (experimental) +* ENHANCEMENT: Disable the display of images, and extract them one-by-one as needed (for slow devices) +* ENHANCEMENT: Only send images in current viewport to the decompressor, and prefetch configurable (by developer) number of images from above and below the viewport diff --git a/dist/KiwixWebApp-github.jsproj b/dist/KiwixWebApp-github.jsproj new file mode 100644 index 000000000..610bb0511 --- /dev/null +++ b/dist/KiwixWebApp-github.jsproj @@ -0,0 +1,336 @@ + + + + + + + Debug + AnyCPU + + + Debug + ARM + + + Debug + x64 + + + Debug + x86 + + + Release + AnyCPU + + + Release + ARM + true + + + Release + x64 + true + + + Release + x86 + true + + + + a1a5e0b9-13d4-41fb-810d-518949f03df4 + + + Latest + true + + + true + + + + 14.0 + + + + + UAP + 10.0.18362.0 + 10.0.10240.0 + $(VersionNumberMajor).$(VersionNumberMinor) + en-GB + False + False + Always + neutral + 82B88B62A6F87FBA62B2C933D747E52EDBF0F7F6 + False + 1 + OnApplicationRun + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Designer + + + + + + + + + + + diff --git a/dist/KiwixWebApp.jsproj b/dist/KiwixWebApp.jsproj new file mode 100644 index 000000000..80440c5d0 --- /dev/null +++ b/dist/KiwixWebApp.jsproj @@ -0,0 +1,337 @@ + + + + + + + Debug + AnyCPU + + + Debug + ARM + + + Debug + x64 + + + Debug + x86 + + + Release + AnyCPU + + + Release + ARM + true + + + Release + x64 + true + + + Release + x86 + true + + + + a1a5e0b9-13d4-41fb-810d-518949f03df4 + + + Latest + true + + + true + + + + 14.0 + + + + + UAP + 10.0.18362.0 + 10.0.10240.0 + $(VersionNumberMajor).$(VersionNumberMinor) + en-GB + False + False + Always + neutral + 30911494F6E4F0983DB567937C8D9A7B869FA8D7 + False + 1 + OnApplicationRun + KiwixWebApp_StoreKey.pfx + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Designer + + + + + + + + + + + diff --git a/dist/LICENSE b/dist/LICENSE new file mode 100644 index 000000000..9cecc1d46 --- /dev/null +++ b/dist/LICENSE @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + {one line to give the program's name and a brief idea of what it does.} + Copyright (C) {year} {name of author} + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + {project} Copyright (C) {year} {fullname} + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. diff --git a/dist/Package.StoreAssociation.xml b/dist/Package.StoreAssociation.xml new file mode 100644 index 000000000..9d1b5e21e --- /dev/null +++ b/dist/Package.StoreAssociation.xml @@ -0,0 +1,404 @@ + + + CN=0A5438F5-EEA6-4300-9B77-E45BBD148885 + Kiwix + AAD + http://www.w3.org/2001/04/xmlenc#sha256 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Kiwix.KiwixJS + + Kiwix JS + Kiwix JS Beta + + + + Kiwix.KiwixDesktop + Kiwix.WikiMed + Kiwix.WikivoyagebyKiwix + + + + + 0.0.0.0 + Neutral + 2.1.0.0 + + + 0.0.0.0 + Neutral + 2.1.0.0 + + + 0.0.0.0 + Neutral + 2.1.0.0 + + + 0.0.0.0 + Neutral + 2.1.0.0 + + + 0.0.0.0 + Neutral + 2.1.0.0 + + + + \ No newline at end of file diff --git a/dist/README.md b/dist/README.md new file mode 100644 index 000000000..9dbfda231 --- /dev/null +++ b/dist/README.md @@ -0,0 +1,232 @@ +# Kiwix JS for PWA, Windows and Linux (Electron, NWJS, UWP) + +Demos: [ [Instal PWA on Desktop](screenshots/Install-PWA.md) ] [ [Install and use: Android](screenshots/Demo-OPFS_Chrome_Android.md) ] [ [Install and use: Firefox Android](screenshots/Install-PWA_Firefox_Android.md) ] [ [Picking a folder of archives](screenshots/Folder-Picking.md) ] [ [File handling (desktop)](screenshots/Demo-FileHandling.md) ] [ [Demo all OPFS features](screenshots/Demo-OPFS_all_features.md) ] [ [Adding app to Edge sidebar](screenshots/Add-KiwixPWA-to-Edge-sidebar.md) ] + +![Kiwix JS Seven Wonders Montage trans](https://user-images.githubusercontent.com/4304337/218268736-2820050c-289f-4d4b-aef9-7e9f4f33c658.png) + +**Kiwix is an offline browser for Wikipedia, Project Gutenberg, TED Talks, Wikivoyage, Stackexchange, and many other sites and resources. +It makes knowledge available, in many different languages, to people with limited or no Internet access. The software and the content are +free for anyone to use. Get the app and download your choice of offline content (ZIM archives, which can be downloaded free in-app). +There are hundreds of multilingual archives to choose from, on many different topics and subjects. Build a whole digital library of +offline knowledge!** + +Part of the [Kiwix family](https://kiwix.org/), this app is available either as an offline-capable, [installable Progressive Web App](#universal-progressive-web-app) +(PWA), for almost all modern browsers and devices, or else as app packages for various Windows and Linux operating systems: see +**[Kiwix JS for Windows and Linux](https://kiwix.github.io/kiwix-js-pwa/app)**. For **Mac and iOS**, use the offline PWA. + +We also have packaged apps of **[WikiMed by Kiwix](https://kiwix.github.io/kiwix-js-pwa/wikimed)** (a complete medical +encyclopaedia), and **[Wikivoyage by Kiwix](https://kiwix.github.io/kiwix-js-pwa/wikivoyage)** (a complete travel guide) in +English -- no extra download needed! (You can, however, download other languages in these apps.) + +If you are using **Windows 10 or 11**, then all three apps are conveniently available in the Microsoft Store: +**[Kiwix JS UWP](https://apps.microsoft.com/detail/9P8SLZ4J979J)**, +**[WikiMed by Kiwix](https://apps.microsoft.com/detail/9PHJSNP1CZ8J)**, +and **[Wikivoyage by Kiwix](https://apps.microsoft.com/detail/9N5SB90Q4JBJ)**. They will automatically update when a new package is +available. If you are using **Linux**, then the +[Electron AppImage package](http://kiwix.github.io/kiwix-js-pwa/app) of Kiwix JS also (optionally) self-updates, +as does the installable [Windows Electron package](http://kiwix.github.io/kiwix-js-pwa/app). Other apps will notify you when an update +is available. + +## Universal Progressive Web App + +*Don't like stores or packages?* We've got you covered! Launch this app instantly by opening the installable, offline-capable PWA +(Progressive Web App) in your browser right now at **[pwa.kiwix.org](https://pwa.kiwix.org/)**. This works in any browser that +supports Service Workers: modern Chrome, Edge, Firefox and Safari (note that on iOS devices, you must use Safari because Apple +bans the use of Service Workers in any other browser on i-devices). + +Get a free ZIM archive to use with the PWA from the [Configuration page](https://pwa.kiwix.org/www/index.html#downloads) of the app, +or you can preview a ZIM at [library.kiwix.org](https://library.kiwix.org) before you download one. +Once installed, bookmarked or added to your home screen, the PWA works even when your device is fully offline! +**[Take a look at our demo](screenshots/Install-PWA.md) that shows how quick and easy it is to install the PWA.** + + + +## How do I get all of Wikipedia offline? + +If you want it with images, then please be aware that it's a big download: the English version is around 97 Gigabytes! We recommend you +try it out first with one of the themed, much smaller, archives, like Astronomy, Chemistry, Maths, Physics, etc. In-app, you'll find a +handy dropdown that allows you to choose your language and your theme, and then download it. The archive will download in your browser. + +If you really want full English Wikipedia with images, then we strongly recommend you use the open-source app +[qBittorrent](https://www.qbittorrent.org/) to download it on a PC with plenty of disk space. First install qBittorrent. Then, when you +select a large archive for download in the app, it will provide you with a torrent link. Click the link and allow your browser to +download and open the torrent file. This small file will open in qBittorrent and you'll be asked where you want to save the archive you +want to download. It's much easier than it sounds! + +## What about Zimit (Web Archive) format? + +Zimit is a service that allows any Web site to be archived as a ZIM, although there are lots of exciting pre-crawled Zimit-based ZIMs for +you to use (see below). If you want to make your own, try it out at https://youzim.it/. The Kiwix JS PWA and Electron apps have full support for +Zimit-based archives as of v.2.8.5 using the open-source [Replay Web Archive reader](https://replayweb.page/docs/index.html), and already support +the forthcoming Zimit v2 format. Please note that most Zimit archives will require ServiceWorker mode, due to their highly dynamic content. + +The Kiwix download library (available in-app) publishes a number of fantastically useful refernce sites in the Zimit file format, such as +the **Ready.Gov disaster preparedness site**, the fascinating **Low-Tech magazine**, the **CIA World Factbook**, the **Harmony Project** +library of sheet music, and the **Internet Encyclopaedia of Philosophy** -- amongst many others. Just open the Zimit directory in the +in-app library. + +![Kiwix_better_zimit_montage](https://github.com/kiwix/kiwix-js-pwa/assets/4304337/9462d1ee-d7e4-45db-866d-a1839c0f6b19) + +## Browser support + +We pride ourselves in maintaining support for old browsers and platforms, given that an important target audience for this app consists of +users in the developing world who may only have access to old devices with outdated software. We test the app frequently on older browsers +and operating systems. The app will usually detect which features don't work on a given browser, and disable them or work around them. However, +in some cases (e.g. Firefox <= 59), the app will set itself to Service Worker mode, but this mode will silently fail. If affected, please +try switching the app to Restricted mode (see Content injection mode in Configuration). + +### Officially supported + +* As a [Progressive Web App](https://pwa.kiwix.org) (PWA) on Linux, Windows, Android, iOS, macOS: + + + Google Chrome / Chromium >= 59 (and many browsers based on Chromium, e.g. Opera, Samsung Internet) + + Microsoft Edge (Chromium) >= 79 + + Mozilla Firefox >= 68 (but see note about Android`*`) + + Apple Safari >= 11.3 for iOS and macOS (full-text search only works on iOS 15+) + + Microsoft Edge Legacy 18 (Windows only) + +* As an application implemented with the following frameworks: + + + Electron >= 1.8.0 (Ubuntu, Debian, Fedora, OpenSUSE, AppImage, Windows): [GitHub release](https://kiwix.github.io/kiwix-js-pwa/app) + + Universal Windows Platform (UWP) >=10.0.10240: [Microsoft Store app](https://apps.microsoft.com/detail/9P8SLZ4J979J) or [GitHub release](https://kiwix.github.io/kiwix-js-pwa/app) - Windows 10/11 (Electron), Windows on ARM, Xbox, Windows 10 Mobile + + NWJS >= 0.23.0 (Windows 7/8/10/11): [GitHub release](https://kiwix.github.io/kiwix-js-pwa/app/nwjs.html) + + NWJS 0.14.7 (Windows XP/Vista only): [GitHub release](https://kiwix.github.io/kiwix-js-pwa/app/nwjs.html) + +`*` With **Firefox on Android**, the app is only useable with files stored in the Origin Private File System. There is a Firefox bug whereby the browser +attempts to read the entire ZIM archive into memory if opening it from the user-visible file system. + +### Deprecated + +Although deprecated, we will keep support for as long as is practical: + +* Internet Explorer 11 (Restricted mode only, no offline use of PWA) +* Edge Legacy <= 17 (Restricted mode only, no offline use of PWA) +* Firefox 45-67 (some versions require the user to switch manually to Restricted mode, and some are unable to display WebP images) +* Chromium 49-58 (some versions only run in Restricted mode) + +## Reporting bugs and technical support + +Please use this repository's [issue tracker](https://github.com/kiwix/kiwix-js-pwa/issues) to report any bugs you have found with the +software. Open a new ticket (after checking that the issue you identified doesn't have a ticket already). Please state clearly +the version number you are using (at the top of the Configuration page in the app), and which browser or platform you are using. + +If you are having difficulties with the software, or would like to see a new feature, please also open a ticket. Alternatively, see the +Feedback section on the About page in the app for other ways of getting technical support for your issue. Feel free to get in contact +(see About page of app) if you would just like to provide feedback, or leave a review if you obtained the app from a Store. If you like +the app, please star this Repostiory (see top)! + +## Technical information + +This repository is for development of the Kiwix JS app for PWA, Electron, NWJS and Windows 10/11 Universal Windows Platform (UWP). +The latest code is usually on the main branch, but this is used for active development and may be several commits ahead of releases. +Installable and portable versions for Windows (XP/Vista/7/8/10/11) and Linux (32bit and 64bit) are available from +[releases](https://github.com/kiwix/kiwix-js-pwa/releases/). Unstable [nightly builds](https://download.kiwix.org/nightly/) of the +Electron and NWJS apps are available together with a [development deployment](https://kiwix.github.io/kiwix-js-pwa/), but code may be +buggy and change rapidly. Additionally, nightly Windows binaries are **unsigned**. + +The code is based on [Kiwix JS](https://github.com/kiwix/kiwix-js), a lightweight HTML/JavaScript port of the [Kiwix Offline reader](https://kiwix.org/). +Significant development has gone into packaging this app for various frameworks, and to add some features which are often backported +upstream. The PWA can be installed as a fully integrated system app if opened in a modern Chromium browser, and it uses the File +System Access API and the File Handling API for a native-like experience in browsers supporting those APIs. For more info about these +APIs, see the bottom of this page: +[File System Access API and File Handling](screenshots/Install-PWA.md#file-system-access-api-and-file-handling). + +The apps are also available in the WinGet Package Manager. You can sideload the UWP version (in Windows 10/11) by opening a Command +Prompt or PowerShell terminal and typing `winget install kiwix.kiwixjs` (this version will not auto-update, but it will let you know when +a new update is ready to install). Alternative sideloading instructions are available in the +[release notes](https://kiwix.github.io/kiwix-js-pwa/app). The Electron version can be installed with +`winget install kiwix.kiwixjs.electron`, or else by downloading a package from +[Releases](https://github.com/kiwix/kiwix-js-pwa/releases/). For testing, the Store, Electron and NWJS versions come packaged with a +mini archive of the top 100 Wikipedia articles (without images and with only the lede paragraph). + +Some ZIM archives are very large indeed, so the underlyin limits of the File System can be a consideration. For most storage types +(including microSD cards) that are formatted as exFAT or NTFS, you can store even these very large files in the storage with no problem. +However, if you plan to store your ZIM file on an SD card formatted as **FAT32**, and you wish to use an archive larger than 4GB, then +you will need to split the ZIM: see +[file splitting instructions](https://github.com/kiwix/kiwix-js-pwa/tree/main/AppPackages#download-a-zim-archive-all-platforms). + +A lot of development for this app happens upstream in the [Kiwix JS repository](https://kiwix.github.io/kiwix-js/) to which I ontribute +actively. Without Kiwix JS, this app would be impossible, and huge thanks goes to the original developers of first the Evopedia app and +then Kiwix HTML5, which eventually became Kiwix JS. The port and further development of Kiwix JS PWA and other apps is by Geoffrey +Kantaris. I can be contacted by email: egk10 at cam ac uk. + +## Contributing code + +If you have coding experience and are interested in contributing to this project, we suggest you start by contributing to the upstream +[Kiwix JS repository](https://kiwix.github.io/kiwix-js/), as much of the code contributed there is subsequently ported to this repository. +Please see [CONTRIBUTING.md](https://github.com/kiwix/kiwix-js/blob/main/CONTRIBUTING.md) for details. If you wish to contribute to a specific +Kiwix JS PWA feature, then please open an issue on this repository explaining the feature or other code you aim to contribute and how you propose +this should be done. You should be comfortable creating PRs and have good knowledge of JavaScript. Follow the same +[contributing guidelines](https://github.com/kiwix/kiwix-js/blob/main/CONTRIBUTING.md) as for Kiwix JS. + +We have now transitioned this app to ES6 code, which is transpiled by [rollup.js](https://rollupjs.org/) and [Babel](https://babeljs.io/) to code +that is compatible with older browsers. Brief instructions: + +* Clone this repo and run `npm install` to get the Node dependencies; +* To serve the app with [Vite.js](https://vitejs.dev/), which includes Hot Module Replacement, run `npm run serve`; +* You MUST turn on the option to Bypass the app cache in Configuration under Troubleshooting and development. If the app loads in a disordered way, +you should still be able to access this setting so long as the app is in ServiceWorker mode (if it isn't turn it on under Content injection mode). +Refresh the app with Ctrl-R; +* Vite will watch for changes and will refresh the app when you make any and save them; +* To preview the bundled version of the app, run `npm run preview`, and Vite will build the app and open a browser window to view the bundled version; +* To fully build the app, run `npm run build`. The built app will be saved to a directory called `dist` in your cloned repo; +* To run the app in the Electron framework, you can use `npm start`. This will run the unbundled app in the Electron version specified in `package.json`. See various +scripts to build the bundled version of the app for Electron in `package.json` (you can only build it for the OS you are currently on, though the Linux app can be built +on Windows with WSL). + +## Other contributions / donations + +If you like this project and would like to contribute financially towards keeping it running, you can make one-off or regular donations on the Kiwix +[Support page](https://www.kiwix.org/en/support/). Donations help pay for servers, coding certificates, maintenance, etc. If you would like to contribute +time and expertise rather than money, and you have good knowledge of a foreign language, you can help with [translations of Kiwix projects](https://translatewiki.net/wiki/Special:SearchTranslations?query=kiwix&language=en). +Alternatively, you can help improve Wikimedia projects by [making edits or corrections](https://en.wikipedia.org/wiki/Wikipedia:Contributing_to_Wikipedia) +to Wikipedia or Wikivoyage articles. + +![ContactSheet-Kiwix-5x6_sphere@0 5x_masked](https://user-images.githubusercontent.com/4304337/204076458-d95cf440-294a-4655-bc59-2529b123708c.png) + +## Privacy Policy + +This Privacy Policy applies to the Kiwix JS Progressive Web App and versions of it packaged for the Electron, NWJS and UWP frameworks that +are published on Kiwix servers, and by official Kiwix accounts on GitHub and other third-party vendor stores ("app stores"). + +When installed, this application is capable of working entirely offline. It does not collect or record any of your personal data, though +if you installed it from a Store, the Store operator may collect anonymous usage data (see below). The app only remembers your browsing +history for the duration of a session (for the purpose of returning to previously viewed pages). This history is lost on exiting the +app with the optional exception of the last-visited page. + +If you access this application from a secure web server (e.g. the PWA server), it will only work offline if your browser +is capable of installing a Service Worker. If you install or bookmark the PWA version in Service Worker mode, then it +will work offline, but note that **by design** any PWA will periodically check the PWA server (in this case, +https://pwa.kiwix.org/), if it is available, to check for an updated Service Worker. + +Versions of the app that are not installed via a Store or that are not PWAs, will offer to check the GitHub Releases API +for updates on startup, but this functionality is optional and can be kept off. Some Electron apps will also optionally +self-update (via the same API), if you allow them to check for updates. This applies to the installer (setup) version for +Windows, and to the AppImage version for Linux. The Store version and the PWA also self-update, but this is not +controllable within the app. + +By default, this application will remember your last-visited page between sessions using local stoarage or a cookie +that is accessible only on this device. If you are accessing sensitive information that you do not wish to be displayed +next time you open this app, we recommend that you turn this option off in the Configuration options. + +This application only reads the archive files that you explicitly select on your device and files included in its own +package: it is not capable of reading any other files. It will only access the Kiwix archive download server if +you specifically request it to access the download library for ZIM archives on the Configuration page. If you run the +app as a PWA, it will cache its own code from the secure PWA server and then can be used offline. Some ZIM archives +contain active content (scripts) which may, in rare circumstances, attempt to contact external servers for incidental files +such as fonts. We block these with a Content Security Policy injected into articles, but in some cases, if the article already +has a CSP, ours may be overwritten. Note that scripts only run if you enable Service Worker mode in Configuration. + +**If you believe your Internet access is insecure, or is being observed or censored, we recommend that you completely shut +down your Internet access (Data or WiFi) before using the application.** + +Additionally, if you obtained this app from a vendor store (including extensions), then the Store operator may track your +usage of the app (e.g. download, install, uninstall, date and number/duration of sessions) for the purpose of providing +anonymous, aggregate usage statistics to developers. If this concerns you, you should check the relevant Store Privacy Policy +for further information. + +**Builds of this app are available that do not use a Store or an online Service Worker.** Please see: + +* [Releases](https://github.com/kiwix/kiwix-js-pwa/releases/) +* [NWJS version](https://kiwix.github.io/kiwix-js-pwa/app/nwjs.html) - this version is completely standalone + and will never access servers unless you allow it to. diff --git a/dist/archives/README.md b/dist/archives/README.md new file mode 100644 index 000000000..92bb151de --- /dev/null +++ b/dist/archives/README.md @@ -0,0 +1,24 @@ +## If you are viewing this folder on GitHub or a cloned repository… + +Due to GitHub filesize restrictions, it is not possible to upload ZIMs that are larger than 100Mb to this directory. If you wish to build the source code yourself, +you will need to add the appropriate packaged ZIM file to your local repository before building, or else commit a +[split ZIM archive](https://github.com/kiwix/kiwix-js-pwa/tree/main/AppPackages#download-a-zim-archive-all-platforms) in chunks ideally below 50MB each chunk. + +## How to change the packaged archive + +If you have a distribution of this app and want to delete the packaged archive to save space, or change the default archive, simply delete the ZIM file here or add your own file and change some values in the `www/js/init.js`. The values to change are these: + +``` +params['packagedFile'] = "name_of_your_file.zim"; +params['fileVersion'] = "descriptive_name_of_your_file (Jan-2020)"; // These values will show in the app +params['cachedStartPages'] = false; +params['kiwixDownloadLink'] = "https://download.kiwix.org/zim/"; //Include final slash +``` + +You can have more than one ZIM archive in `archives`, but only one will launch on app startup as the packaged file. If you do have more than one, then be sure to set `params['showFileSelectors'] = true;` to aid in discoverability of the other archive, otherwise your users will not easily realize it is there. Keeping that parameter as `false` dedicates the app to the packaged archive, but users can still override and pick a different ZIM by changing the value in Expert Settings (Config). + +## Building the app + +If you are building a custom packaged version of the app, then remember that ZIMs will not appear in your online GitHub repo, so add a text file to `archives` to show the intended filename, like the `*.zim.txt` file in this directory, e.g. `wikivoyage_en_all_novid_2019-07.zim.txt`. The text file can be empty (0 bytes). You should also set the fields listed above in `www/js/init.js` to match, and additionally decide whether to set `params['showFileSelectors'] = false;` (if you want to simplify the interface in Config). + +Advanced: If you wish to restrict the files that users can search for on the server, e.g. to ensure your app remains dedicated to WikiMed archives, and to aid discoverability of only those archives, then look in `kiwixServe.js` and search for `DEV:` (first comment labelled `DEV:`) for more info. Also, ensure `params['kiwixDownloadLink'] = "https://download.kiwix.org/zim/";` is set appropriately so that the download library opens in the directory where multilingual or updated versions of your packaged ZIM can be found. diff --git a/dist/images/2000px-Kiwix_logo_v3.svg.png b/dist/images/2000px-Kiwix_logo_v3.svg.png new file mode 100644 index 000000000..e572fd6bb Binary files /dev/null and b/dist/images/2000px-Kiwix_logo_v3.svg.png differ diff --git a/dist/images/2000px-Kiwix_logo_v3_with_border.png b/dist/images/2000px-Kiwix_logo_v3_with_border.png new file mode 100644 index 000000000..09ee6f588 Binary files /dev/null and b/dist/images/2000px-Kiwix_logo_v3_with_border.png differ diff --git a/dist/images/2000px-Kiwix_logo_v3_with_border_trans.png b/dist/images/2000px-Kiwix_logo_v3_with_border_trans.png new file mode 100644 index 000000000..ff4ea725d Binary files /dev/null and b/dist/images/2000px-Kiwix_logo_v3_with_border_trans.png differ diff --git a/dist/images/BadgeLogo.scale-100.png b/dist/images/BadgeLogo.scale-100.png new file mode 100644 index 000000000..9d7725560 Binary files /dev/null and b/dist/images/BadgeLogo.scale-100.png differ diff --git a/dist/images/BadgeLogo.scale-125.png b/dist/images/BadgeLogo.scale-125.png new file mode 100644 index 000000000..4c4fef3d8 Binary files /dev/null and b/dist/images/BadgeLogo.scale-125.png differ diff --git a/dist/images/BadgeLogo.scale-150.png b/dist/images/BadgeLogo.scale-150.png new file mode 100644 index 000000000..dc8146b88 Binary files /dev/null and b/dist/images/BadgeLogo.scale-150.png differ diff --git a/dist/images/BadgeLogo.scale-200.png b/dist/images/BadgeLogo.scale-200.png new file mode 100644 index 000000000..a8b817376 Binary files /dev/null and b/dist/images/BadgeLogo.scale-200.png differ diff --git a/dist/images/BadgeLogo.scale-400.png b/dist/images/BadgeLogo.scale-400.png new file mode 100644 index 000000000..6b268bef2 Binary files /dev/null and b/dist/images/BadgeLogo.scale-400.png differ diff --git a/dist/images/EdgeChromium.png b/dist/images/EdgeChromium.png new file mode 100644 index 000000000..a82fe8465 Binary files /dev/null and b/dist/images/EdgeChromium.png differ diff --git a/dist/images/KiwixLogoVerticalHero_v3.png b/dist/images/KiwixLogoVerticalHero_v3.png new file mode 100644 index 000000000..f9051f7c7 Binary files /dev/null and b/dist/images/KiwixLogoVerticalHero_v3.png differ diff --git a/dist/images/KiwixLogoVertical_v2.svg b/dist/images/KiwixLogoVertical_v2.svg new file mode 100644 index 000000000..6fd421607 --- /dev/null +++ b/dist/images/KiwixLogoVertical_v2.svg @@ -0,0 +1,591 @@ + + + + + + + + + + +]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + eJzcfediArmu8PcCvAMECB1m6C10hhISCBBKGnUoobct98d99s/29GEaZe+ee3fPyQLjkWxZkiVZ +ss2GWsOVHm+GpMvnxvQ6szm7JwfHzT6qR7/qS8vl6XDcw5+sdZseD7kx0ChdCvfohi1yf5hv1lG9 +FwBw+8FDAr5tbYxmy8GUPJJ7p75xJCeDtf7LOtqsAazRkRx/2Wx6qw20bs6PSxK0fy61Sx1XpVqo +9jDcvR1PbExnAPTc4Aja4LgH/BvRe6PekL72Ap8P1n8MDof5f8GnQV/YB37LbE7r8Xw9zWz+iuox +vR8L6fFIOAD++LzgcXFeJw/CNm5/KOT1+cLhYAgPhwLwFbc3GMH9AW8g5AvD1/3ukA/zev1BLIJ+ +8OHucNjnDfkCEV8gCMDmNqPTilwfa/vNiDwcspvlZn+I6rN/g3G/ADqsjwN9l1wuN3/qM8vBaKED +NAz0iPmSBORaDY563Acpmy7h3l7mNF+OX0+rIQkIGQhH4M++HgL5fgCwAFj4Gf4c6pVW4JcGeTyC +4QCEcHbqhQy/G5AK8F/rZ52cztFkApJ+22iw+812NdgvDvchBATZJFfbJZgxRN1IBHcH9KEg5o7g +4Yg/4MO9Ackf6XcBRdB7YNzuIOYLeSNefxgL6MMRzI2Fgl4s4vcG/GBOwSNBA9zvj/BbUPC4eSH/ +mJN/RvWvmzVJET+9PzYozvH7MYz6Sz2pn5bk/n09PwKioDFFKOq/bMbkErRn3ycAix8Y+uLcX6pB +c7AHAgDYbbM8HZGMhBkMYHYrg79JyCI4haC6JdfNTQv10QVmQe+NhHxuP0czzO0NBPxhPxYIgCnC +vbgeDwT9ehwDffcGEd5wWO/3sb3Bub8UUogCImAwAxKZa4B7qvv5dL6O+rx6rxfjoaQYrLCfjzn+ +Cnn1YeoPGqgbjAj+g+MRQHdvROsvEfRPKIgHwrjfq+UXikqA4McjuaapBmQl+8Ljfcz90gBjyq/H +2c0KzvoB6gPA9GsgD8vNlHrGfkZPwOunLUUf9L0HGKS2n68hTN0rehLu1ZYn8Kiw35y2pfVko7NS +yrEyX5N66pkePQQ6Df022B//3OwX4GtpTA44KXcP5lubIsjGgjyOZmKg9K/Xg22RI6CrAbeP9dXh +L/gCYUDNoW8CfQyGCr6zbdTBgWnYMyMHb6KvzH/V386RE9Bt7nXq1/z6D3K52fLAUu3U4dWWg/Vg +zxKLmZs/wJMBmEgOIGxIHjsaIAL52AJyIBjCqVBtwHukYbr/Xg03y/lhxULm/1IDEz4fLcnG34cj +qYEQjRGUjr0+sz8dZvrmZrPkwAoesRShf0a/wvb/GThq6IV1dQ0+zKQw0Q3EmIBGpt75D8XFviOF +Bzz834IjO1gu59P9YDubj6TQSDxn8fGfXTZNYERLcj0+sGiorxxoKPLUb5qnXZ8fz4HSkxFyxTaN +PwdAJ1fmQ0VssN+T+XoMxKJxmh9Jjkab1RZaofrGbLAlkbAzLRsswEAPrFf8FcnlUluqqOUOdYPS +9MyIqXl4AapyCjpT3QNENuVnesXZ9oC/J7AonT/22PRuqjNwteV35c5DkuNDnVWua+ARtFu8yG5C +/4f/eimb6a7djlBPoJF5/HtJHnSe5/XmzzX6oo/qrJ9gdRuclsdvm97zOliReqfO05gDw5lkmmD6 +qg7jWXO4vjMAP9R1mDvkj4S8uD8I/uuPBKFtGAxFcGD3hqBNCIxE9AsGngWBLRyOBILQ6opgwJIP +4REsgPuCOE6D7qR1jO0KvvwNvpTBh1/w05+AQPoX/ec3ph+Dnzt1HerEWOeh1tWYTu8BowD/ReMF +BOJGq0qy2mAJDDcSjbA2vPOYxK4OomDnv3RnLlBtpKtl2M4yfbpkYisAHH82z2iBGlzDQThGPaIs +Agjm/9E/A0CiH2WA031lnCDgRg905p6H+Q6YDH6bjyA1Bvu/qe+dl8orcHQkH8b01r9WyzV47ALK +cT8fno4kUMhO2DS93w80gLgDfF6r0Qz4yntyTbXx6j0lMCz2Kfxz/BuqV/jUuiKPgzGgAR4EQgf8 +uxF43ABY1lPhK38MlifmnflYue0ayC7VFPQKNnbeh0z/uymtnb778SQ6GG5OxwvIzHvnP4faNxLU +p0zQOXTWPIc/pg7QQDt1jUfyL0hZNZI6lbqGK3ZNGji/E+NRdIL8VO1T7PwP5u3Z8biNejzb037p +3uynnvEI/G81hy0AKebLJXKsL5OAPXnYnPYjlbfOhIB7Tbsc/JPTTDW/2yT/BwwIRqcvG9E/1p3R +KNpG0Z//iN5A9qvniP8bIv24PvT+GOwPMRlVyR84/P2gQaUyDe+0Qv2L1BnO0WYJroE4gIgN8viK +yKBOIX7rf1oZqIxxvVnLdZk/vuVmtCDHWsbGtPwfNVD+MWkHMzUfDJekFsb/PyXo0T80izps+i9z +MRze6HQ4blb/rib75/gwehjAGAn0ZIHq0MqO/7hcgL78B3Xl/4KUHiZ//gevxv+yGByW89H/dl2M +B7x+dxD3496wzxfEw3pPnRws5cc8I+fTmRYpY1v+u8oYJUt4A95IBAt5vcGg2vj+nI+PMy3Doxv+ +u6MTp4aoDO5vLQP7+98e1FkCjMqo/tKkeP7tUQFlk9lsFIYx3ByBxVAhJ0cqE0TLqM7f+Q+wDpBa +bKCICMrw+tfNA7CI/dtdYGLedwobRG7sjnFM7z1oYTJeYySeNO50Ccf17B4GSuDRVwbr6Qnms9Q2 +W7g9i5B9vpDj+Wml51Kwvs/JIAWNTjMi9/ranjyQRz3no+IBjFEL6VJE/0IeZvr64HAk9/P/QrtK +PGzUGz5M8Eb1dNyejirvMEOF2XnpPTlIo3yScxtFpEdCXoyvw7z6EObF3AFfAOizEMzrojpS28zX +RzhdVpTpxpdgBnFuftguB3+/DGDACREzvT8ON4P9WB84pyGPPMxQa+m6jFIVJw3y+lQnl81NneoP +6l9tc5jDAaKnOG9h5WchSq5FGuB5RfqxdGDG2CCXJMxSlW1Ab/e9nosN0wJNklCE4ewPGCqOYEIh +S3MKPmJFhuf1i/VmtNgAVplSGQeiphH9drAFHHqYr07LAcc6wQCYb1mMely/Z8YFDDBvWL6lVz9k +5Va16XRPkmvF4cwBhw+OJABKonCScOmCQI/7wfqwHQBdM/obAJyP9TCzV+OoLugrSwBVoLxR4YJR +IbWw/4PUN8m/jihBZDCcL+dHZsZhLjILmFEuVLZygx2TWHpZwg2Wc3rV9NNAQIfEzLIaHBairh22 +G1pVhhi6jrdzN62GWAt0Oxhzgal0SZ8+HTesPmLsO9b44eWzwVTQHlzzicGITK+nS7oxEOVgiEYo +bl6HtniBoyOnPiVbVreDEUtGTAlmhp1w/jRKNq0zE26lktR5a88iXSJOyyUzRXQ2O3h6zsuYfsIu +C0AslzDRk9pe09LycNxvFowxxG8c5DUerI9zPZj9wUGaQ4RGFNBSxcERdL2yGQ2WUBcdeFpHpi2g +Erkv5fgt+Y+bMIQAsTJrl9xsZcnlkmNlr/y0FmFO6WZd5DllXpnJavKcQyW8WWDcHdXYCdmmIm6S +bkksN5t9dTI5kKpAqaZ8qJD5ZIYDe8Cynjfoxf0KDfkiEo6EcYWmHOeH8YjXjXsDkVAwEPQG9GG/ +H3eHsIg/5KV+EC33YmiN44BdDdVFGQ2eHZA/EA7JDQi15I1IFSo3JJhipNZrwO2Mrg9jbiq7HPPi +AUWdlf/reGZJitvBnH9JwLii0uKD9odlmQfm3gOlA0yr42A9UlW0CLRI08KMNdYI5quZPVLfrj9Q +Drd+OFhyGHAZzTRazrdgpYPh1L/AmjgFjCCjdoCCYFOIwBNP/q/tZn+EmiJ9AEJzeCZZEXMFGGtX +fv6AVTaAX9DMtwbr+WEGyMJjQkW9j5K4W/PDnFpwIQvLSEMocpk0cOCbmy2vO7dKGQc3g7xmPmhg +pDOgYWmHHuC6HLYUDUORAAs5gMOKDR8evAQylBnUaahxtQgPz5corcfkXw1ytFnTyiLs97G9CfmA +eXZpbzgaXtsdYr4/qLyCGFKev+ReYyn1j3AlC/2+TMmCPePJUAhnIfuxyOU8CUFLsaScItoyxvTm +D3K/hQmMtB6y0jFUPBLw8Wy2RquAytYym7/aXCzUige8OF29JN2Yb4JYGfWuZz6I3oHKGrzT6TI2 +Ehj0aLMfk+NzFan3vG6OgseCKAHu1QMru7AfjOfQERqsx3TYQClQQL2Eqolg1j58Cfka4peEmHB9 +vta4GBX1ljouxsiugMWG8XNLOZprAvzoDIRHeRQeqqxIn+EvSWrUo0F5uCCi53czdCPeGCyXjJ92 +sGlqLpRecas9CbjuQG5Q0jvFG+cBDvFLTA+AxzolleED1215pkLEjQ6L+XYICLQQx9HOxgQz9Dmk +MdYfhQnZ5c0QVh3oOftdhdBy3RnOj6sBFEshq0m03k5XCzcwBMjxZjJxnw4kMBQy8Cs9N6zTefYS +KjqFL1GhZJGNLo+D31yqR6OVm1Eoo9XfC3m68xpujjNm8mVArgAz0EIQCUh2crt383ZmpGcQMMzB +TW3Q06z27m649W1yqM9uAJOM9V/WRrta+7Lp//AqcyHq/WYyZyxDQUGB0nuAHUnEE4Kg3dmYD8el +e0xBRHKkUTjga9vtGJJrudaMYDuWnyZIWAHJ1DtANWehhv1euRnjbxVKsjdoQ3eSbhSWA4UydN1L +sPZpJxRFWI5OYQxXBs9n/kAopNx4z1vuAHMA9T7WD//W5/Zgod4r9w4C4U2fyqCPm62C+I4QoTc8 +/1q+GU+CFBqJYCko/wOlyTQ05YuSuv7naONVAjqkd6FkVdAS8PZmDabjCGN3Ki05HSTXgjWghvCM +AeVRj8nDfLoenK/uAqD7sXtLx8wVUINWE+BNzjb7/1KaPNBss5+6Z0yMUg7WZg+tl4E60sNouxyJ +wztSKP/guc/SrQ4wqMC0k8QHWQ+FqNXwgUlYDrbumXLfj8BRYKLgqrD+kFdRVOdHa7Fzc7aCHmA1 +kkobcg29ekYbu73SSx1sCbQijGvyBFaVuDNN4oWgUxpcs0iidwBT0+naikMc7TcK+oCzNVTaQENs +DowtVcXHW2E0WDf7i1qzileDmcWtTBoAc401QOb1WUNrts9SzDxZH93jpbKio2YR7tAMB3sFlbk9 +uNfkdMBtnEo1gggPp+FByQY4AHsYWtDKUMbL7X6yWSspcQAJxtuA0XngPDHpdkvglSg4LggSWLTW +anTa8+od2SFKTNHBDf3xNeiZIlKw7ArbhaRWjb+2bkEE0ietGSC82QC4Xcy2CPJlpaBNxa6ID5Np +uRe3lGlHr7qC/RvJecDhjA0UGgFgcNsG7dqwCl2KjyBWsEgqQtpsRxtlCLS1gHaTVECNT/ImCmhw +OG0RK/45mx9JJZ2IgB0UsCG3ZnJaj1SaCFYXST6kINGRIYbHVJQ/emewXjN7n1LDBQ== + + + 3hI0tdlQlLbUEBERBLkpPLc7zbTiOd7CTXAYDqnSG4FNluW4vACmiSj+JdwmhDu1cH8wLeA0mZHw +sltQIEkpo4WHBbXNwo2BLL0xUOdvDOBno7qkLUOBhvxWKGwmMcizLkqC4tGTaiQOJ6qSiuqnAq34 +US6EQyHIhcl1WsABXDrHesMFQPXzNdqagaa3GNzZdths82dxPhbP5lmz9eA8iQSY4GzqU23+F7kE +b03Ikbh78N32DFhjuf3gz/NZYR+/bP4AT3tAX87EXCBucyCn6ISmM0I0Bn+QL8DfngOWSgsDfSrR +LOsn77Q6/X3DIXAOazkC7piux6BHCpYU5CPYFIXBKqwhJQPVD5syQTN5/cngb+4H261KQ4QdHViW +YQ0kGeyoKSsn6k2pMc3XCr4l05QAktEmhzCOTotfcwakSQ9PjjrOSD0dVtEf6PO79H/OyLX+MIDc +oR+s+ScP6qEjoB8c4M/00Sw5gs0scuvfDwgk+CsE9vfmpN8CidRv1nog+fAJQk2Bmw6AkM0FiJx6 +gIx9dQ3Gqj9uIIgRqZ8joRzol4O/YVIWmIblfERl7x3gYSOge6V1DjnVHBgK2xqwyAn0bjPh0M8P ++tN6AY8EcStzKDPzAPRoP98KLBsV5qsrB7c4VqFsUiBt6tMKdDxMClRyggV9yKhFdwWtm0p2CNMS +nllX4rtesi2b+/mK11slwabSMmF2DDrEEc4R1Ai1DZjlv9VpyCSE8ZgpT3FcdrClcsPmzDolbbwy +kF42681ott+syBxgDqrcSbwRI2l1X5QRIEsHeuyl9QgMBOWGqBJANd1J0itktQ8K5hFgwGnqeLuM +SoCfebGwH/yd5dypt9OAS8CT8Tg0598q4ZWaoOc5s9Mt7cMItLL8vMq8qpx55oUptMoY4amaXLKW +lMvJ1wWAJIJkRpU5kKSCIos3gMMNphw4sHVIfi3DgIiEo1BaJcGCgEzzpjDGJr9WUeRt8hJQNYwd +zsfgSDZnp9VwPZgvOW7XyrMcwWR6p5QcqKgiqZ0FqPuaSqeyyGvC7GY95od9ZWKBYk3b5u+xa8NH +H8n0N2eAaXwRrIhAwQ60G2+8F7TqdZHA8jhcAQ96KYs8dbEKvUwVctajX1GtQJXEdRKdP5Iebpi4 +Fy9FQKwMNZQvXO4qi6QKJoEgP4qbJFWFJSkjyqpVqIo0KnRt+XDXCU5pDEyJ+WTO7JxeNvWabTch +tQSroNcrYydIEEzMNH5NK6D0PGmwk9Kj/WY4OFJHEV9DH9ZSVB6kSH7Fo7xoZs+MQzYYBNpQLJ5l +3UnaY83MGW813ciWSuFAjoTI4EN/svr46Yi3nyyxQcdZ9j1WXZnUvrCaRadrQ5kwOK2W7HzgPpiC +78V80BhNvRcSL/5ktPJleUntT6MQkfe+hM2432/EsEPuNzd1YqZU7MdtT8Wd20Pq8Oz16MypWMWw +ZxqVj5lp8a2SivvJRnb+lBjl3G7L9AxVZdwF+EI5whwNfRSOud/vjP/D5UyvNpUDcNCPM0ciaDwR +Ob+pnfldWto6c26ClYeSwEyhyCTUevv8Sjez7pY8Un676HcqviC+U9GDe+XIOc0nwloYT3RmRCyi +D6YjN/luhzLL1LITnWRmx+ws9IELyNF/zI3wyi4VT1raFBzQ5UP2Z/qzAZ8ed7nSuGTIuMK/pnTD +ZVxTfegMxiedOfJrdYzyo8CbNTvz92LxtNn36Mi8OvuOVNbyTmTJkz3RKhtnsdFosICf5o78pDKj +MOOYZxDaz0396PynPM4szUmLa+/4OqUrjccd7L8tFSvPfDpzMNb6TqXXI8vK8fQS84RWX0/zUMhz +mPjS+1EJdyyiOAtxlCsfWoBsIQsZavuwcXSe9QzA/OIvT1aXk8wsQ7UVNYJuxZzKluLGdt4ZCRzA +vJQ+g8ZEKLv5ccRb48+od2j8RmATazMYUCJoN8Ip+Qy2g29rSKdEZmELumjWbI0rGP5tfMl5BvFH +wuD42EMsQfjgB0FBTXRmbPhQ8qPPjgQRpz/F2/lnqnnWme9TwLxdbwmwbgdzJBJ5pzeXnD7RcNpP +8dj49/UHzSTbYQCvmgnQWECjTJntwDfXAdz6VIeNSD/6LWDI5HqI1GC9T/qDH8HfUbqZ+3XkJp7n +XX4wsJgyweH7W6Rm7rynq9lMLTdpzHep3Xd0qjNn/N1mjyLmR3D8ke/hjlbG30lXidxvu5ed/wY9 +scnKPCWyEzsOCJjoh0L18YbDF27sVs/pasX+TORs42eKNgyhKd4Hs3/cut8cydZgRw0oEQwPUrHm +8SHdLB9P50MTUZZHB2YiOnsDA6oBJKeaPerM+Y+xeertx5M5jPhK+RALxPtxIge4w+50ZDaRH/Fc +CSnLn1hmIijOSc4OJ0QlMBY+ncqVQrpXxhHHxB3bWJ+wTp7daSze/PDaTD9xqiNCcgRP9QhJWB+3 +tuwsWF/kHRU3wXEqEIDuBmqYRn4MOTQFhGr1CIZmtGWns/whFBu919OhD29bPAe14rIlgP1QyLuc +w4jUlEQW5HNWZ043X8YOoGESkVym0l1I9Ra15LUrdEMTIDR5L+Yt+F/OOedYI2y1ZYzIBT68jkSh +79KZuXGBUY0mRD4XCGWCrmoLKRw3Xmw5EdKcp7+1Z36P41VmuW5t0s1ZxwRAPDtYANu8c/PqJR5d +oc90fTKzgNe+HzNBR2VGaUtbbmIpBkFvNzNKC+ZbnSKjwgGC5++mj0hNnzpQwfdzQ/+snX43jw7C +do/pevNzGf5duuJIo3ELAcDCPd+UsXhmYd3OiXgBt/J0+0fdPuDTBKwlPGWNY8NT3vq0a3Mrjegp +4GTrMTQF3SMbZ8/DfUesdJgAjT0yBjL4afmZbvTLWfppJN1PxYtZN2jSbwEtUHnM4B+nXrpxavq5 +p6gx0GPgh1VqP4o+UrPFl09PN56sZteh+mRqxYc/72nfo8GUhzydxQvZSgp+SmDlAv6EkcNoEnda +s0n2twT3hs7MtUS/wq8ZqAqz6EX0NdioeN/g0yfqbQZBFv6WoYCl4y4iFHDl6t7exzYPm8RRY/g1 +pzOz3cvARq8cHAoLxCcEkWI7n2DfiKEmsDc11CV2uGnUEZ0ZDZMaMOxUqFZ8acLfYggYhwWBEJOI +6bIYKfrKwmvQWNi30Tsx+BwNI8mREjVH3aOouJ7G3lgSNBA9WSxx0dSB2RdOlMTUXjERommgsVDv +QGJxsNEwEJ2E5HhCo+K+ImAs5oJEH1KSY0moTwnVZfSJhUghFX6l2AJofjnGkGUL2LjCjopjFUli +oQeAk8+J9USNFUkOQ44nbsywcVWKqCJJZQn4RFFMNExEk6gQRFLYmyyLmeJpEVLUmJM6wMncbAlm +NcFxLWoOKZGWEJUY28MaqzwoJkUPaNlHYC8ntTK/IJIjKiLINI9JKUA0NFY0L2NDakpYGaK0Jepj +PRjGbVX0iSI/HAbqPPzzITT97Olm63lNpCxkE1j6Ey9/wYik12CtnFaI/ks3ShjsbrCKwXGFmdXe +ZQKWS26Rahvfp9n5Ty+VHy12j9RSxjMnAseavDvDNzscbeTOAF9M6NCgjuamLluSMv1qJdsXt8YJ +vC3MmGpZrJHs7FT/yD0/7zL8AWV6ZLq+zlVTjZ/9EFiwy9QKF2JxIN8h+oote3FXn9iIn3oebJ/A +CW1t8yNn05MJOr0unt+IZ4bTHGnPFznbClpK5VOEIwxthX2FqzzXjW9EANcU+raRJbGZUObZGYCO +H7zm2nhe6l9p2C9gKQFrPfBxi3OiwTWBltKNzokG14S2+lgOdcGhUS6zwPf9WXAeSnjp3hfpOXg3 +L2j7qFPOIDOWoxMH6v+WZ4EcacafKn7lnjNBC0BgG2beUp/2zJv5+4jMYagqQhJ04vsiiO0TwWd3 +rvQbGnBkA54FJBxN/vS6GGotK8109f0ZsDuQToo5uY7IORUUPRPBoJ0VgEJmGZx+IutfZ+bs//OO +ktVcYWEmgXi9xWFQYwQ+OY+F7cMwEnHE/K9CsBUZJyVuoTRMId1Yphzg7ekOH9WTVW/q3RChPdWm +nQTEWvhVnH7vx8KYnX0ZoqDDvR4z+99uMFw3kP3M4sUBHJHaxM8KSBQ6Bj+ZhffJwD1gmR2LjldL +DE5TWeAjBzNEPP/lZqGEiJ9vu5HIr09AKr3myCpMcZbT5PkMh0aVcuatlgKrRXf1Snf01DWn314b +LehrMw/avz6axptHLLQ4DWtYZeteFg5Vci/CTEulCPe9MevMLEsSqf1+9u6PvrSTCEEMS8b60LvL +YpNItsSDXd1mihn/KYPhzveDQTAHnz/pSOzZxT5o+nfueRr5Ynlnav9QLhJ2m9MP1FUb+DfO8Rqs +TnWC6NkMMzhSXyo+/Fmn2m+Ox+jM0ZiDxS/yi/icp53PAhhFV668t/cpHjvnGEM+QbVk5VcATJv0 +eoPpR7QCwjiMmvz6uKCjsvTyOgKlF7iCm0l2fpgHYVTB9VnHyvldVgRRg5fPA/tmACs3I70+YL48 +L1GTKB42AJufsHVrx/RzFx9T0/j0/DrOjVcRJ8N81gfgpyexXLZopBYj18aQcFOBACp61n4KRMn+ +I0nTqVjzZJbuOg6ANtbI7NCZKYyv7+HvfO/H/Ak6PzWkdpkfK7tizVi+A1o3aDIDSkRKcM2Z5oee +j7nQhkEa+xP57vR6XZkCSynUftk2hGs31TIU9+XJ/E912AO2SQwqnIktP3JgX2m/NfIG1F87TNkC +NHqfMRVPvj/mSqv5ZybQ6rjTb/baNF1vOoBnUTAXvkOZBT7e800VakF58uRKnxU7NDbqqAnQzvGG +VOfDzUdTg+gZH7u5CaBXZhk2OXNlq82KjBtW9pElMTUvAE9EHmITU2MmgdQPFtH6Ie+wByf85Q3O +1baX+Um1TMcji7kCpnhqCB4rRB1wcqDpdgkeWQxY6bMQp0Gw6yuK0L78TibRueXtBZh0zjSR6xbt +UkMTtAs4dObY9+bzS6lRyx56HcWqoiYx8se2QHG06Os0Ns87Nx840IwBPN0IEN+F1dFuge1+GQ1z +xkXGA1hLXmaUIZMMdgrZ12wrKeINevdib/gEZvOuDiY5teNZhzQozA3I297qzGgDRGIO3EA+n4PB +J2JXjOeWlQBnBNOT+GM05CaN/iY7fzAFAGP7q+l1orSR4iE4L5DpqpvRNvIy8eDpajT/nIpltnzL +m+5Z3JrauyInqJNT6dD3+DU3ifQ9+Q/y+CiiZ+R3b2mCdf+nm97MqnZAMSGzsOYS+vrFdR50Klni +cUniKeiTYpDIIp1vpkOROjIbe7nJ2wGsyJSqoHtbNBLZ9PeUyKam9aLpCS+lI55FWrpJ2v6bajVL +AyKeO/J6AzSx8SEVbZPTVHi776G45DkW4NDZ0VwBLqrNtI6UMvOEUOKF5cvKkQgVimB92X3EuuxE ++YCizB9gmP4NcMfvY6o1aZ54sBPB8innro9dqejr74JnnIM/zeADsc7SWy+suO7S0A== + + + e82swOonIL9l6ZmRP32G1KSfT45i9ZQr/hwOOeeQyMdtJvM74MXuLrOqJgLn/PL2AJavxQe0lGK4 +Feg5vxmYak1PbtLcA2cPm6x4Elg6fPcLZsLwnNobf465yWbvlmDYCFg1pza4t9MhspOkjxMf2n+B +xkEIBmIpE4swdX7nmDewmOUKCTMJTIxIkIrBjlofBxZsjLCWxm3oXH5BHdHJkfEf6CqcHJwDyOzy ++OxWWziwj7WBVVT4TVfxjA+42clFKp7YGvmyyJhB4NPYw6MidnB+BBPv/nw64Hp+g4oCP8eCGqGO +/hDepuSa9EBU1vlRYA0wu9w2CWJZ0qHGCwHmoFtLb9ITqzQWQPnnsBwIK7CesGn0xeEDK2nz0aBJ +UgVsT82LHOOzwXfsCIS4uU5j3iTxBpiqj+VH3X0glypud0xj5wYadEGKkQrd1BJtHNLWheOp/FHm +UQesOt+ZZShlQq4EvZEZhJsLIfsJ6ot61DWJ79mR8kMQL0Ubllkut32RA8/xGG/ZHuaHWNzCt+Bp +iEHqQXo5IOGuhBFu1mDp+qZyzDmruzFjKS1ObK/56wvC8pgfPQS/gSdj2BP5cL0oNjZ2xXoFOcqx +yerxEbjtv0HOFpKwAF6Axs670WQDLAo2Raydd1QtDkDAH5dSu8QLEMNnE8BMuKUw68ws7nYqviRs +fBtcDKwhL3dQhHfZ13ykjxYUR+LwEeGUI9CWcEhP1jdbF3oor565MRqnDVqmEdFbeoJARwaXqVBn +mk+HC4cj3Pp2Edayq5XF31eHGBl9XIEx1218zIndClmRUCcnR6RQW57S4eF2ylsSkML9eBsUga23 +wWKTE7kXq96NPefhvcFuDCOm0ZmDOzzSAPZ2gyBSU8DkjVNzrM6/QeT0IjpAP+AFsE/bC+yR+Eu6 +4UyBeZna13wsiDnzo9NDLx12uR+gQRgUsRdYjtZkxr8Yj4Ot9+9WOJTMFrOzz/ED9LAeUvE330/u ++Tn+wG4Wi18D9hgxeMynYt/vwOwMvTkwr3M3Alr+YwHW3Mk2XV8G2gIlPOikDrbOQ+657ANsb8xs +pRQqs2tf+wg1e6e1zgxaZp9y00DwIe48fc2DiZ09D7wg+46IEyOaG1n9xKomRifReuxAOxW1R8dT +KvSQQ7kDoCPf2VBjvIkDa3xr+nFxwc3oeDxqRr0Dey2zdOHNQuejswbzcsxw0TyqyevP8ET0v08z +mG1hQb6Ra+1s+tFE8Ccbg/cSUrMx8bjaYOLfren1cHpgdZsA4o93hdZAXo6FAGwLGK8/J0DArhmo +tbcT95TisXa6+R5qcrSLLFK/FTDyVVsQsoRU7rfBErXFDmks/rrlxUQRsTKWeDNnn3tGcWf3OZMO +O0sQ3uMcjAXJKmsQyVGemRzawssDYyozSlefi3C7dNqFdPAKuvT2ABYH8jM2aG9+gffqyf+aiXxk +M8//dGbvQOG4uhLN+8H36ucvrWEqxJcsbMJ2jG3yo6AtkHmx2eahdenNAT1xcTT6Daz7L4QFsLPp +I+/qhqcZf9vn4s3+/Mc5TTdzB3tw9zxIPgHf2AqcqzguxMdCsT8BeRlGF0+573nXyGM0Fg5y68Ga +s5ID4XvLzlJjV660zLZFSz7mffsyEtbnTBjMS+3DueGNXxAHD7KaYQ79z0B+2MwHOM0owPwBDYfi +GAWsmQjJRwTFVKCP7MPGwphLND/o/zrT66ShRvSt314oDF+5smGCcd1jYPd+YqVqsR6Mdt6HYCwk +QZuIgNVobVHGpmD2gZlnAwi++LH6YNT4rSm1KBDpOfIvjgiQOocTyFDzkB8ligDU++PWFHnPf5oi +0zbwkUHPijAu7/5JN2ejI+zjfyfYEkgvPHNIX0VVKQd9Dp0zjgoUQsJKOX4rLoXbyhXzUOlzsIZ/ +QzUT1zDyIUjULrLlZfBwyLMy3EarALPNqbzzIz8lnH67VUBdQWeobgcj0dke4HF+PdqMJSrfWoXa +dHLeejUkx1Ra7TmmJrnacidC8UHBg3ifyf1asvPwkNfzfFb6IZfkzcfUGWzPkcDqQ+rGb2EaOXiU +a+bOoIOJGc3Py9XBE3S7bfP8mgGZEr70cik8Vjt2XsHH3SQsvLIWZnNSV9nC3jPPdCjLk/+LZJ6l +IxHohxzJ1tCDeRwvLkdydvTBT15//C3qYx+8sZ/Qg5gv2TxmgNVYWBSN9acBdPcS7FOv46kenBls +vuKTweWx1HVmgyOxiBtsrx8Rg3M2B4/6E7fBcYo2DM6XTs7gwl68mOepa0XoA4as7c1/8B6AsRLI +LfzJaj/hy4R9YaCaVh8o1ol0CPcUK/bIrM683yeehmnn9rWceo4cEuFivO0mNh/+Vn7/9YHlPohu +k3hKP41wYFWuaSw+02VDgx4FGtx+7zc4Wz8lgyvsChscI3cDjioMf8sbnL1xwGCbL5YG2zEzh0Oz +8Yfmd9Yxj79RZzFTA6fH0jcvdWbYckvPxlPXT5E1szm8Up/oFysH0I0cQNBZhMRNYDf3X4NPv9tX +CZ8ciYLhkSOq23MIF3Rm76nbH4IfCkts/NjN8cHGDp39ty33Ajsq6B4gNXjX8eF/8Ebt4DUckbLK +Q/r9DgxqFqnOLEIbePMt9nJI+/vv3fFdBml2GKwPXF4ppGD2D+E2LjfWoj9iTi+kkcYfHg8W02Yr +hXR/6rtN1qGp/oWQUvPCQ4sRWDIugzRoNIVjk4g0Un/3CyOamTcppDrz4YHYRs3V+UtdaqxYwbip +yCK1lCv+Fznyvu+/Rt4yRAo9vTMCP7R95sDRAl70b85mNWpK0EhrFotoTv3NUGGJkALhGuY5pFAq +Y4fv/XdriHjedo402gu8j6ceSaQ/ruarLNKQZ9KwIKQ6swgtmFUgooeo4yCNtBb68XdmFacU0oMl +0cWlkOrMAG1gZrNkyILUWOGsdjEigr1KIn0gpiFTfeWtSiHFiO9vAiGFOlk81qDRvFi/ZOWQDrCC +s9+SRlrA0hbSGuqKkNJ6bH80OpP0WLsuq0hokq/+py8Kaf5rQQiQfsSxSsiFQ6T2M6RFcoMkVWcG +aENb8Vgrnx8DGaRBY2gxJn7kkOawF/t3RIQUYKHQlnbR1O/+tS6JtBGz+GSRPpMNHyaD9NOFNXq2 +B4BFcqzPRfL188NmlUTasqynskgbszda+3JIIRYabQFrPW/j0kgrPvM7kYo/SSPdlh9kkbZ6hYcj +Wvclx1rF2snnnDTSl0S+9/P2/S2J9Lu6KImQIiw02t9uYEzIIP0KY9+HpUsa6evvdlWNhH2SSHsl +F9DJsmPdmxsOgwzS7juWn6/KkkjDr64HQ+rblQdIozuEFKxinFY69UI9GunQZxMJje2jMrAjpF5L +wloUjrSC9e3RNETqPFtper87nfkRL/eaAO3TXqwKD5vHJxrpMekQjdQAFnobhTTTxUtCRejcH94T +BojUjZCi6hpOK5VczFizRxFSR6z4EKSQJvFnlwBpYObc+l/7CKnPFM0+C5GaoOYfDNcQLSYe6z5N +bhj+LRvE+jfwG83QSKNvbhF5HzZkv0ktb+SgFxRZF4Hi++PPJso9Fz3tvuGrltzTGbS9TlJPac0P +VG/uUeZtMAePjqyZfvpLhkRPg2G8x/T7sAiLn65nDx2dWfZ5qFaKfsk+DXvt9b7809ngx8I9FVEs +aEx7Hz9Gsm9XHOukV/7psDqJST1FFAsaqw+jYVHm7XDxsRh/P1BPJ5ZdRAT73TGP/dJP8Yeo+Omw +3FgzFJN43so5GCtT4mnbPPQY5J9+5aJP3NMzivXNPyGT7Nu/x9q2KPt00fJm3qSe0hRbLYjEj9zb +YLhvsYDs07LXn+jIPh2th42KPMUeDY+lL7vs03z6ZUjKPi17kw+4PMXSBq/JFpV5O1DE8k92ZsxR +a0z01NF8OyTpp1l3XCyVxWa/YE9LPUcyazclGXNY6mnyI1XlPwWuGc8zzLrsWWjDWD6znHPGd82I +XkDBNfMeTdDzzRpc5UgXeL6/TfjHDX8jDM5cPQv/tIGqi5igNU47g5SGofEN6hlGb+4fvJanmote +DXAzf4VIGH1QxMsrytkBrhlPmjwv4bUFuJGdE9TJwN0BGCdxFp/RM38a2oBue8hDd8clUNZ8pI64 +d/omgzRoNL5vl5/8dZ9DC5fbD1mkYAn6xWWRYsTktSGFlJYXuGCOpMYKkY75SP0NEw9p+DXT4CEd +Pz4aOaQH44ys89Z9n4jAiZ1p9ckgLSwFSG1dWaSAvE9eKaS0NY58B3asPhGBoe/wI4O0+y0/0gfi +4Bes+8KxIt9BFin0HWbSSOMGtxRS5IshtBWLLIGRRSKLFNojTcGckhEGPfpEzz4wtrIf45VyS6rd +z2m1Vm0XNO5+8p0qX8PItAzMaL6j9UUGjPkr7eBFpDjB7VtXwmgPUP/EaY+UCyBLI0XrZO5FuE/p +5P4kttZxk3b1UbwKEDWxtcW3vPgRBJCIFE2/qA+JSOEzB9TWIA8x+xiPj9eBRN5M/3G+bGgEyIBm +EHC9AUN72lJNBJEypPQynhmZM7N/6kLPgg55VdnmOYilwB9uv5xkuvxeA18foTN3sjPUoWx+UaDu +DfnIjzwSiiiPlQNmM/oDWbKt1qVFpCTVJZ2Z7lTvZAGs++L0WpJYiYvYiAKViOje71PmmSO6NMnh +H7rr/g0VUxKPEMYADBrGh/6ozl8DeK/qM2hkx2eXHR80fN9l5w964tpmEM7fRsShqsSiQUHr4hwY +bs/8EmrAtDB7zMWu+zdzVuFrp0x3nXbKA9Po40rJEco+IJY38xEpX0ksoeqxcaqHXvdBf37ywqn1 +XTsb+a/Snk9AAI/xxAWs+4iUjwztfvIseWV648w7qT807ZhI7znXdl1CqeSrbWmpRLE8yaF1RVLJ +zsYlQ/MlW80XZULDeSk8P8J+12W6knNoGRVZcz/Ss3/G7HmEpbW5eUDQFezw+sAKoVDD9G2PoHud +nMw0Obf4wGQpqnGgDFkgFpowmCxhPLON44nhHZaTUUBImsa4CBQbh9EGTCh39vMlf0BISR2KKF4q +d4OHzklxJo248x13wj+f9Fjo3YYzxgCa0Zp/lp1QZjrhHzCdXBD7nDcGBMAi0oJ8YNU3tlO8noGx +HAuS/UoUhgepQaK85EMKI4/vnjMrTGFKHOdTMi7IrnE6s6zykebpRfggaxDIWozsWimYX2DNfB4V +Fybx/MrNbgFSpCi0YEULk2braVwQ6mnxsqSjWJdbeBU6dUyWZbpUrdO9kekSP3ZBdUrepGOnTtP8 +RUwim//MsFC2+QXzt1Y26Kj5g6cDaJjBQm11CzPwVmQIrLG+F2cJlhNKj90ArKvsxFxGMRW77jKK +9fZ3oxhfo11Bsa0gESG0P3NcjwmxEuKvYpdYx8VLXMG6jB7LdGYGrY6NtFQekw93k8pMZ2fS4ChT +Nn/dwdvNlaBOEn+uaKWOVG90Zm+m+/B4I3USB3ZZltXJnE0hbRoW1ZWCSkcgFtAV7Q== + + + Lp58RxS0gM6slSZC2/KyjlDWRVFd7EWeoUNm1ZwWYej6U8QqnC8m5RtSm5pckLvOQfR+H4ZuXjgb +fCpBjs8rRkjECKhUgzPaAUtQS1CDpzygeNCZKsK5LCHD4wJ/WL5LRjV/X7MC+D6aVeIsPB5TVgCl +SxSAeHwCfx+M0HI50aVJLrAUJNcXEdfK2fK/Jbgh2NYwPp1ZdQZzRzz/fShoj2ec++S0xwe4f+a7 +G7HOBFwydqGJWBIiLssMiJMFxBKKuM8UWXiEIl4Wi7ikkyaILslESADXPtwaSyhzIVluz0LYH81O +xaostN9lIySCoKzc0Cy3DI3S/GWY1fCi6g8rhTeSePkkXJZ9wrVSNcCBugz4YOe9ckA8Ti6frapX +xH1WZbgx3BWRRWIVUyWMWqxPpAqAPy9tW0LqBDVQh6cKBJEGoSmdOlH5Y3xjGvCBlmCiuin9zJnS +cvKigXbRN7Nyb7hlkIlbyi2EvuR7yKLOESrLICUvz+KF8Kqh2WSHpjNr1ErPZ47yBXzOcfL2Wbzy +XTUgg3DJk431KSqA5Ls5cLkCEGRB04TpicP0V9mygDbsQqfIydpsWbhZZeFnb8BRgd9sIo/vWrnL +gt64tUS8GY9PetSdhngL8rrVDlnjANi94q0Q1LnoXaqTodBo2KQQcaowO52ZN9lFTyvHIyicG8lk +d1wJR0ICpaBQFqwCnBt2KjgowN+/eOWTBSbcH5S1LjTtVMByAqdVaG9mUYqrrOTQu6Ia415ZlLp6 ++XIj6VdCYF73hXt8sqT8Je0wDiNDTJltbkWNdljYzjTaYeHQqazdWjUaIExqpzIv6tZc5/0WjSaK +wANgd9No75xGu95SgnFprRpNUfbBvN1Bo6HZF4bGroWjrNF02uHcvveK4CjsBzkzVnYfxyMpOcIJ +E3nQaB+ZtynE2zqUtlLoRC8mCxF4PGexcfibcAP26pwruAmuSQlBywxa49ImaxbIeVVZM2pWsoDH +8l8tw81WPdOv7oP83qtGp7HTutKXFs4LnDdRWtM1SgFCERj2/IjiZXAUUyBEUOQyVRCcc5f6mt5E +rR+KO7yKJrkYmFIgSyp/TGk1BONziFdD8JtLWXJ02lfDwUNdMkXgIo+v076PfU+BEq6FsjymZTVs +a3WtdWYlFvnaXW7fn+k7MGs68+2rIYSjvBZqW8UQHI32vdIqhuDcbN9DKFJrIevvX7Yafu2UxPBs +LaQiV4qrYe98pxj+dkkSIJwX2dUwatWYh8WlYUiPHmWp9fYKU8InpYwtwJehjpRsC31k7dLducjS +peZFVro7mqRbVW3TFNMk4urOJZhJt5SUy2Wpydg1gJ4tjzaOUI/0ok5p5Ahp4RIuSzBLLet2nS1M +Wbd8ly9y0ryZDryLS25h0pK5JuyX/C4A9PguEC+UgXK/bFsITH33RsveDQSlM/tMsefKHZg46w5p +iifL7Q0I57KnxdKnQMn6yF3F5FsBR2jqkle0J35h4isluNx6lgi8rCU9C1b2Ub3cYWpwrd961CEq +rrTvB1bO5bXW0LHTKVlBh04JuEMNnXIFnc58nxq6M6SCCjpKW95eQ6dcQQerBe9RQ0fJmlwFHe1Z +3FxDp1xBR1cL3lxDJ4mUraCTqha8poZOuYKOObvj1ho65Qo6rvbttho65Qo6qMfuUUMnVlHCfGjp +/crLa+jOlzJ+OjKKkMhVAtUshJoHzffZ5OuAIBblZBdBpxS6pJQ/paNNQ00VU8RBMelJPsQk3knM +ie1fVTrJWb+fOW6tZ3IVrqSTKMR0nt5OUUmnXoYXswsYViLP7GloVS4FQ3t8sAzvl2zdh5+k8rDE +/otGPoi5Lhofb//lvNhNGLmSI7p6lzyinZFriE53SS1ypdQp2aI5BoR6yRziMXWGzYvzqi+O+iFP +3HnUmgyinAoiGzQWR3o1hI3zl6eCSNSKdl3Gm4vdJDIhryt2uyQVRLYm0bm9JVTF1qd5FGz+Cwgj +nwrCc0N0GnyjvGyFlkafZivMIujj53s2Q+9Ojc+16eQBcbnbKz2dQ59kAiUTUbyoyHTw8CKuOlQO +nKHZl/PtAbEU9rI1BM6YsCGzIicW4a0oTALefr9TOQx1kp6c2aVWByaqApM1uq6o4zuprUgX1PEN +letfjIKglXxp2oNCDryG4ygEXZoZ5bqU4tVYaSpoUsmBvyCLYFwQRjAlzEHN87fnIpiytuUFwNR8 +jDw6p1cbMLUSGaV+CXdFITA1R0P7ILnw6h0oplwmeiHF1I5CUKGYqHom0+m6hKlORdnqGa22LFOb +AKO+GoVdco1XrpZjT6JQAbF4UOlD3/uDwz99Kdnm5Y0X7+bsTYvCwK7UWTessycLQk09nAEQaZhp +UflwFP5MX1AoJ64ZUZ+hHqbV45GTfVjipjXIIEdPKRdOzq+UJ4daaazUnoyEzQ8GpCrngmiAQip/ +FJ0pXBfVWOWOl7iZ8pU+IrorcbJK+ZFyeZxA67BnDkvVtB2Osuv5RfZYCY7lThL/WxJJvJQ9po1O +GsM7IkP7LD8ZVo557sMCnFPI1lZr65REl7wausTLHFaqQLsoIqNYYee/E51U616VOiWMyLjPIzKr +smxERobHZCIy5SsjMkINgz+b7hOR8Zmi7kctsQsNEZnyPTKIAAjrHUoGC7XVzecpgTlXj8jotJSh +3RyRgbvVkZ3/HoRRKM45q3lXSnaBRXpCkdOYUsKsyKI61GTziAmN5We1OlQlY5l/EoUv+e4w3sgM +22epkI4wU0Wj1wIWGU2lo2xIR2FFBkOLWm8eGjJ3ebJ/BYfC8jH56BI3IJ16Xd3N54Ztn2HWzQVp +s3LTZFDO1tOUPQgJc0vpKN9LelYMgqoW14kT9Wq8fVSWk+Gv6psPV9bDXX5e3zX1cLJ7SXeth4NY +bi1GVa+H01hncWM9HFtnIaiIu7p6RKYe7sKK1Cvr4aSrBe9dD6euLe9RD8dafdeXamioh9N8DslN +9XAS8/JL2u9dDyc8oZ2pHbp5W4euY7u9sh4ub1o3h7jdarmQJQR2a04kp/lbG005kWoVXz4pap/v +WCmZAdnzBImrqtERHOetZnNWlM6gUCeuDuculVwwl0HWb77oLFJoj8HiOvmA2KUZz9DysouEkLLH +VCZCoxi2ZD1o4QlUqrVMV+7RSkQUIbB7pSZ3t0gIb7PGIbW1eIsq1nj2LqcBU9WCOZVCLC3iA6DI +i4/mszuyXH7D5b3hWbBZ5SOBL8r8Fh0JLH324AVHzNic5zEsWHomcKgl6sW05VLB+J9mAirpsYuP +FlaqSB089CTLSK+oSB08DCUDBpdVpLbvU5H6tbtHRSqEco+KVFgvdo+KVAjn9opUCEVckSp3DLR6 +/Vb7zL8WJCxAbamaZiQUQ5eEGHaU41ras21vKYWTWsXuXwonOy93LYXjzoHX4rhfWwonTbF7l8Jp +9CtvLIXTae7ULaVwZxkRV5bCKRuGvNrqrtLmymUnwmdFCRLinZHL6+ok3SLRjo3OrGHPBgLTdFKX +XE6g4JRmAOym8CSfYoIjhuX3ktQ3F1AJm5bz1Yz0fqXM8jA8KG3haF8cqNO0umdnfV+ag8qPAM2o +O+Oc0jkk9BygCzIT1Vlh2Rr0csbxKU9ETKkfopmo5VOeoyVLNJOhLrrOPPeR36fSxWCznM24R9ls +xvMMLyFobJnFyLwUx2DpmJOwGkuh7ixu+JS/uS38Fq0JI4rCYrfYqPrCDz/zkAZmdnPcsJErduso +VNgdHoixhy8gomK3Zka+wg5eqj2QQ9pXrLAruCI8pOL7zKKOA4tUXOwGr5pmbzXkF4BR9/FZlYrd +cLcsUkc8tpKrsAsajbvg6Uu2wq77qVR3tlKqsNs0m1JImfv4KuRsLFdhRyrVEr515JHmXz8LPF9M +TGDT2hfrySF9O2MlIK40evSJ5vOoxOxLt4xpguj/qii3g1joesca1ZJeOitBCVOUEVzitBQvp0pn +qaV42bYaj/13rM/S5GuPG+WcDZ3mOhpNh7jzoiZK91jtlDuluUvC49xVc64uvklOyvql1sp73iQn +tSBS+8gqh65rpZNsiuRl+TA5DTeOCAxMxXvfrrxETgoUYk2BDXMtH6heNgJtmPMRSnZK5a4BpS7x +1v3cpcmUCl0SRY5vkJcCqXINEZfsyq+AuE81nVQPxbsJt1fTSdXSnd2ZcnM1nVTAi7mL837VdFK1 +dJpOnryomk5+v/Ke1XRy2vK+1XQ3Ra01V9NJOR8SnHxjNZ3ASKBr6YSyf49qOqlaOikNc1s1nZTf +rLt7NZ1ULR2793q3ajraMBTU0jHZtverppOqpePiMPeqppOaXRS1vms1nfSu6L2r6aS6pOP15z7V +dFLzJ3my8U3VdFK1dMqW0jXVdFKgdBcCU6+m07jDe2M1nRgU5Ph7UUzZJryQYhqq6bRT7JZqOqla +Omr37Z7VdFK1dNI35d1STScF4Lxm5NZqOh5Z2N0SuZqR66vppGxnnfhAspur6aRq6VTuFb2imk5q +hhTO6L6ymo4/XKaWTptfKUsOjeU38jvv11bTSQ1IfKb9RdV0wi4pOIAKFalCB1Bix/W3pPXoJhUv +qaR2TaW2WixAse/DTk3Y+eRXu69O2rq49311mu9NUL2vTmvN2tFhEebBXkun3FHZsDg/UUfhKjdh +gcKlXWJsfi1X1Wkt7zy/gla+UliFTqoWgOiUM4VOyadSXNYlKC/K8U8plSn0iJJ4+SAKlftMka1o +3T/PP9ISBrvkmjt5nVy+28Hgq7KYYlfnIypec6c5dnHTNXesvChddKe5TEnumrvL8pOvveZOdEqA +9EV3l4XdJK65U79pQiZN4aJr7pi1UvGiO/Hmkfo1d1rPhds+3xyZ8yXfcbNwfbk6AfFZQ2WRTqPR +vX2+JQ+f5mQwuCfbzYV0spmHF+Rao0K664qKRFWc5psrYJ+lUjgur0qDd9NFrR9qgitIIpO7IxVQ +R1MRjLZ6IsRjRou4oggemqqcaKtpv6dQW4n9lysLxFSywS/IhgLANOUia8qGAsC0ZHQr55cjzXeX +ysdL75hkeUwM5+aaWgSFXvLktaVGOPJJVBfdk3iPiyaZexLvWljbECdNoHsTGut7nQoIQUnYdxL1 +lVoqTkBvtSgz4U0Tspl7TY2k5DuSEiYEF7my2c89eliLd/3ZAOLqpztUpojPPZY4V0FzKQMAVlGu +irjgBkPwqKZhk1jtBj/Wfr+t8lFrIYPyHUMQzq235kIo9zglgLpOTsmI57LT1eEIxfCSS+nO70lU +LGW4uJDBQc++UAxb9xFD0Q1319dXXnLDHY1FXgzvcsMdtWchf8fdJWIof8PdhZWPV9YTSdyUd7sY +nt1wd8NNeRf40oo35cmL4YU33FG3/8ifFK4CTFw9IXPDnVrWjcbC2rZyepNWPfa1u8XMOat9u1th +7ddOfAvAlbevab4lXbny8eUOdekAivv2nCsER8WH0mmFc5P7xGjLs+Saq+vbqevylA== + + + chQvr2+PWp1nYhi1iiuTJfL6NIlh56IiJskonLAi7EfWmNRcxMTeYBi1yl8PdtF2EwQljuacUUzr +0eYQmBaplI9bCim21nB0nCa/sqO1jEmpiKm3l11nEZbLalw7lxcxodpqedNQ4rhEVCp1oWEodx9f +1n17nh1DSnjv2/1qXLuyOzasPaa9xrV7+dFU8udcde9z3SNzU96dalyzbo/sBo7OfAZMrsb1LA1D +liPOunR+BhHs1B2ue6QjQHAaKiE4FikiMKYfrHgrPjVzCzyb8ZTbOSNZbuSSjkbzadN3BMGnQo2q +7et8EWOvJfGQoxYeFNjlU4z5LCjDe03W+UgF9XAHY6tb44eqhPewRbOfXVE9HK8uSb4Mb3/qR3FZ +pBiB2eUq/4JGU6hu++Z7r8KCrS/5gsMHYuuTR1owfryLkCLNz9zDVhq6p3L3sNkUStNqAfl6uIMl +9Ljn5Vr7RFWONmvycylTmmZTvHFuIK78QxmqLIGf4zUZpEGj2f+a68vVw/UUkBZMQYG8iC+6ezN+ +yCANFwWllWKkdRFSKu+C5d/nljzSfP6dEM6qCT51sp/oEsyT/ckjakdR7LylL4tpgIj17dG0hnaA +YtHNMc8tk2DUXb84a4HdrpFYOrMK7hPvZDCNiZOAqAGbcDcopzVtUsMtZk/KpU1nERKJ6h/K5s9d +mFol36WsZF4b7+QWraVNh8tzyaVtmLOArrbUKskqKbiua8yEVKFTQyUBTXtVmobUKq1VaSo5mlr4 +iQHF3/JSyelVq7rTmKXFeBYKnTrL07q8S6iK83FzUZ6WUpeko8RXyMtGIUuL7o3ETRMidZX/StiF +6ip/c4yZ9l4B7JKGDUOVujJZ7Xzx3U9dl0oqjJT7K6Nh7hBe/slzdv7V8bGLDoyTj4/l77Fl/ZNH +kWXFM4g0VWxuNRxCq9NAmGu9FilOzml0irUkjYg3WOk77O5yDDRxRx95QFweDJaL88OCOwU766JA +wIA4j/NfevKQMKbi352durAI79VvL9VcSNZROuVM/YwIQSmgmt0mObtSmSrjgmp9u9ZKpoiBqxbU +cs6BfHWb0smoGqxxQafkk/U1FALyo6OAogvTnUo5hXuKaJfn6lJA9UuvKFC8W2aUgCnfa6zaL64i +FQI7v9n42kGe7VfeBEytlucSiqnsXF5GMZWdy4sGWfF/yVLsrFxY1pm96EY93vpyRRWg1hpAgVRe +XAV43gfpGkCBNX5xFaDCzrO2eLKmKkCtNYCqN7DLgbjoRj3JbCjNVYBaawClz+nVWgWolZ5Sa6X2 +KkCtNYAafGSFKkCtNYAqu2/KVYApqjfnoxJfykflKAoKD/6BS/lUOVmlakvbpXxqJ1Hc51I+SsOU +/uFL+UT3Jf1Dl/LJ3I9850v5LonCXX8pn/gstX/mUj7BKvaPXconaSlppVNQwXZGvVE/G+qye/0u +Oxvq2nv9+Crq/Fa/q8+GEt3rp5y8qFL1rPleP8WhWW/PUyrf52woTff6qZ4NdZd7/ZRv9bugvvKG +WgiJmsSr7vWTMti5W/1Et5jdIWlY6la/ayq5Ls9WlK/kuuxeP+Vb/W6+v5K+1++2uKXWe/2Uq+4Q +ljvc66ecr68tQ1X9Xj+t9ZW33esnkIezihlJTr7iXj+ucE9qoVOyxy651095JuWq0u5U7k7f6qch +zq/pXj/l1U5rFrTavX7a7+O7ueZd9la/q+7ju3jJk76P7xYJ5KBwultxx+qCe/3UteU97vVTLk+h +IvC33+unnFTAv8kIu+FevzNSCm71U5wX3k6N2r1+yrf6SVcMXX6vn7I5qFaVdp/yTnqtvFvdg/St +fhfLvsy9fspmgOR9fFfc6ycBxak2+5ff66cMReU+Ps33+inf6qewx3dZ3QOpdKsf0mN3uNdP+VY/ +nfkSMZS/1+/CqrS7VVnzb/XTqsfU7vW7zRrXeq+flvv4br/XT/lWv8vu47tWfMT38V17r58QiviY +P+nKlMvv9ZMKpl10oo6me/2UHWp0rvUd7vVTvtVPxXvVXgyveKsf7+bim+71u+jUpqvv9ROVI4r2 +s66/j++SaJbifXy3F8PTt/rdmnPF3OsnE86mE2roTJWb7/XTcnb67ff6Kce1hHdyXX+vn1T5GOdr +SaxiV93rp+y2U5nDt9/rp+y2i6Xy2nv9pCimMRPygnv9NPqVN97rpyl78OZ7/c4MQ8GtfiyWG+/1 +YydW8lY/3mnzN93rp1wQq1NzdjXe66e8Y8Oj2E33+gn7JQ5OXm3DiO71U95cUDkdSPO9fsq3+lHn +9tx+rx/TJemCWGpP/PKzUjwSi8OH7OJA1fC+aznENFGYnZ2oiH6T38NkEu/P70mUKFwU8RNFEy6G +lXja8nQubbLRqKzCVazv3nCEwTxVMshO8qvAF60c9nvvYWYAy0rZ4Ph8NWGeziJENYH1VAbTS6Lk +xqxrg2f0ufX79rMyASi2/I68vdutrpXNktllsOL0NW3cnTJBw9dg7AOf+ilTOHbKP75Ud/XAbtH9 +DAXc/lH4hei4n917Q6BS8Pcz9cV7ctx4CbZnTfI1sGtZyYmpnbb5c78PzfqzzryILuOdDZm0rne9 +0M68T62Dr4b2a9Ji8lkLQfPks1SynWbGT//mi4yiqUWVnYn3ZqNlcDt+UgbvdNdyxH2WFEZknjMY +MRmVsULwsb7f9yPW/SHcBvJyMP4Eh4fA8LPGlgI2HU8eV9vtq0QemLK3X8/+8LWBl81FjNK7voLq +0thHpRdJj962UE02tuy8wPskT33cbE+nKmUpYiFygOEeH/d7n8mgONKZdWAha8bWRzNhWu89YF4e +vf7pybgcG8awlrTMFIcaTs6t/xXmq72sUU2iIU00m2bMRI7Bb7WN0GDfisQHDK2W5SKrdDyZWit5 +91sCtSZFiUTQnD3lPgiyg67PzH4X6p3ga3b8kPIc4+WU5zCOERHjopZvp3w/gGzrRGHZ6nzpzOli +0DAEcFo7Bix1gaYVdyxCsJix+5OKVQx7NKr0alM5pJ/b7Z4j3+oU4Scw3NrSDYt2nZRTnwh098hz +wjxHK8xF6B0ZH9kTcFuYT7gVxY4BTUJr8DVkR3W/QOGUtuDrkxN9BavY5x58zbqZ1wgPkfe+hAHY +IubIOc0nwloslXCnZdbTmZmOPtv4jyLHAfvAwX9QcYzYBy7+g58QyT7w8B9ss1MeFpz3qJDZwfqC +Vzv/t3frkGn86uQ/mPrH7AM3ut8QL5pSGFwSTHjRRfjQuv+KA120WeDFZN0Hvr7xYQ+nDkjbNyfV +ZGQKRWntBVQhZK8MPnI94bCJB1YtrfBRsgTJ9kYDHb29U1jeYFFr3Ajp7YDVxWhhMnltLj+0/ps8 +wnhtyVQMYonBDe96Zume2tO10aSSey4ZGhxDspsCWV6uAt97ZUQg47UVifjlEKXgUf4LgPhWeWIh +ZgLHmoksfH+Ep+nGyTTPf4xrGBwVzvGv9/v0k8rOBx4c83R/fAx7Nf28geeSIYpVEMXaLkRCb+4t +C9fAtodh/DaAPfyGd7O1cdrqDbTRarCBn3zsJz8FIB9bBcHXDxpeb0TAef7wsDVWgQ+M/cTjNpgW +O2cY6MPHf5BbmPKjxS6CeRa/AWYsH/TlmpjNFMa8y4Y574zYfiAnYy0TP1jTt9J7qtSAuD906I+O +1iUC324Oqe/RVoVE/QZ/um0r/ISzn6B1wWv5MvXDX/0S/Xkj+q1uNucI2wgi/9IK02vqcRXAyGE0 +CPnT7TPF432iZ/v8EC3fgjtTqAWcXvIzwK5z5GkDhdG1vGVinwxZoo8brz/fzuxaQFvac45IwB9n +9OY2CR68lHOnQa0KsEQCT0kiYqqPs99lYzGxM60q4qML6Akrr2idBfpLCfbgoWxDYsY0ae0gY7sh +jSGxvg7wKZx9hjm/wA+hPdKWqMIZlSILtGXDj2BDZ2dHT3wg5UKF5jAdHdhjzhatjslaKE4Zy5P3 +6KfwJAo2tDv5SX2JZx8+gBrWI6FaHZRWZTr8TSvwRNYFe2hFd0AMF5nlw5oQ6lXALKFWMdtfpMfA +Dd1maAksRG1wcl6QoQaoE8Yp2gFdGgazO61SuhSpMKBGA0iDwrEgRWlKeXLl+AYDcKoY7IDNZ4pN +0wzsdy/8DdLOISolz/Ij/mAF5Fl1mNUd49nJEnbdMWiwvX5EDI6ROwX/ZAxOL/FKfbXFX6MGZ+un +ZHB5LHWD4+3hET5tGFxpXwL+GRucL52iwbbfOw1OQx+dRNFZtFhD4JEKHJK1JwdcjOkzBPJfxI41 +IZGqS+UH/fwitd55+qmWpd5NN2O/1lzpM1gGms/6kIonCTdrLuzoyBUyHTwz88YpdD80I83Oicc9 +wNfZpTbFfZfoOYvGdHUar6SbOb9JZ85N3g51JGgHw7clh43N69x+//RhROaENzeqJq/D/JabPG6N +UV82N9SZwdBHPeUBC4a73gOIDb/YC4Q8BLeILdQ5B/RRDy9rKHouZv8F6SzskFtnqrXUN5ELBPqX +Yv6KyGJmzrsQ4uZry1HPnop9zXo5d72/z06e1kMR0ZVJ7kvvDTnxPVb/PI8l3nv2vMgrpbVlAd3f +Xl7Rh2cQPd517r5M2BcOGqOVeiqaJ+eZhdX6li/W5nhql/akc6XVHPjIRG6JZ2hZ9OfmYAGrH6FU +Wtz+Ynp1+UxLURtw8mX0TkbfKMcmcXo0aB24znzR0FUHLs1oKAKvfehXDhzKSyzxyDn4mGewc4n7 +o1WN2i3GuMG521agGq1AN/oZPHABewyqz4bBaUsBXWvPOA2usOvHYJsvgXJdv33BtzHYPAk7ZRIY +CdpYAIq6zny9sGtnPnTLjAh3i0y1np9KRO/YNOT7wepMs7BfrWHuotsEGRHaSa19uJDRajozmNXw +iYqg2KeHs2KoSyZZdszAThaMGiizlimnVdq0yhq0xm9U6xqUOtoTv3AVv3wNZ84cvvOCIjJZrl7F +Lhou1JZXkfqi4erMEgOWYLSM5ZYxAx5THzWSLLFc3cxjPHvtKmuNJ1xb5Dnx7+SSCohlM27MC1y3 +7mvaucVS6dHbK5FLOgLltHMTteQ+iON3uhjsv6YmzW0sv/8eVgPL4Y8J+Xkpz/5oyvRfvQ1gXUSM +gQTn8cVO04Qz4/bvW15L0l4QxcyYA7486KgsNwq8MO5hH3jiQeMh75h/zNLNVnsfIyP7BRi9YaYz +h3bFeiU/GFjc+Y/xwwxRnjcH5s13FloIXuDM4iXBmLViNgFrHFgSuy84B4D82Z8vbebE4ZU+x0wb +Uri+8NC2vTm3O94GGv0bT8XKi/oFSIH1xDMhBNYTlUF0k+GowXo6r679J5YynfncftJOb63UBhbs +DTbj3S2lmxZRnfk+9oOy9UBHFe5tLIswAwv2Yg17mycOQ141nmsGY1g3TjxNd6AtNVFejP7zojFT +uQqXryro4M8yI2ZPdTHJYRgIHY9wlnchCBdOQ9Hv2ksELB7BFPgTz4CFwviKvsbjrg== + + + YxysIIUKWHgalZTnmHxOFwPvbrDctBrgK0ZEHze5aM44DmL/yPoirQCA5teqcC9xV0XqVme+SuFe +iFlnllb122w2s7Csv3LukOXALa0aFtb/2fWFv7KdVQxpD4lcMFykYbamfzgYI7G+ALXuWrvCS3FI +RG5R18RjsWdT7itXKDwtgF7x7S6aaa0mFOUjX7a+Xs7idG7PfcJgspiRj3ybYGvgNp35IvG6crgX +6LGbeOwi8bpSuOT0mNZJ1iZcF/LYlcIFNIyEeMGNuS4/p0yYkopo58zVvTCk92pwfFhTBsfSTxic +vXEZfrUYnLPfbxjBe4X7JjGAxRV2VQ22/iQMt1TysKXP4CpHuncM/Qni/HeJtksZNzCz675xinvG ++S9z1s/i/Dd6qlf6yPewot+gnXyJRXmdEwMpdofwqwr6q2KwF3M8Gx+TsKjv58TozEpbDrdjpjhe +Z76TK/EPxmDVvTcmPgaEylq8Jj623u6JZtLfQQ4JEXk4hZCvIuWpAH//al/FYs3ODZ82DYsMkBf6 +M50p6IjPg206u6MzOF7B57iFPGZnoW9SJQbLhSJ3DjqvL7BqfzYfG9cxWhr6yIulnUgvB78aNDr6 +BOA4iIMhSbau30uSGLDW4XYMG0/z2lUsfeVw96d+JXS9Hrt4uHRM6eb5VR4uzIG/x/wqDxf6YveY +X+Xhwhtz7jG/V8X6bmBnqdnVvGN17XDR7F4fT75kuMDjk51fOsa1NvL35fmZ9o+CBcO64vcVZc1z +N3/RR6fQL9oFL/p3XAYV0tNndaFnqZ2v/Gz4/E8A2TU6M/Tp3vg3qdC59C6e6fc4Cj/zOop+Mxyt +B9YprJ0B8NsLyFxC0wSxPG0EI0Arbdz1wq20Xmuk6+PGTyV4mzMm1vIePZ4ByHh4AADFiE4B5zIT +wdDdK8htVjRXnnniHSYq1jaeuTOaQK4Z81trx/zW3Xvm1bWDzYSEpx+9PnNrL6pMgaP22+ClQhED +vWDGVnVolxuYK44iRupBbPn+yp9k4kS7lKf+k9fB3uljT7XtA0ZwcZRxBzp6ft0PcxULmgNfqLqg +s/29J5y3fMdG1RdYLvEAe9MV3n1k41MMsm6eyq/fZ7qfLE/PrENT/QsfPPgLqD8C5sO3LAl++CTw +Tt9YEnxwJABjgf3hE2ER3jJESPl4RDDHDX2GCH4PRwLYm4X4AF8hCRAnC4iQjC7WDBHsZiERXCwR +aKR0iQGaEgUScJUpT0eG+08GjggG/+HzUQsfJKO1I83YGdszS4Lit/vh9x3JPiKC2yXLB7Du18JQ +MYrLsJICAGhd/JLWW0DQZ6ooAQDzogyCOg9CVSIUAOAPDsZLunIY1F2cqgAUpJKuXrxlGBW/m9GW +1w7jPeqRZSoRAGoVOwfxk8K0gpDUTk7LzMrJNndXmnbpxp3Y2naRetCZz0BEjvZbNAzuzJodIgA0 +xbTOBqx/cUr2gQ+A3wcEgL8vBksPXWqzMYi/ciB8n0s8zAfwE3JLMbbOrH0Y0yfPlcJFR0dhXQ+m +SgkF2cBdphJOGXwPhWKGARA02j/3vp2AYoXMzka3JH5xrqXg+jrYrvKgziD8UenM4k4V3q2OW7QO +XvhxixmE4TGtbFqY+lUZ5LwPQopto5IsonkYsCpAipSAx7QOo+girtU6DI8VgxX8JokvJute1RV5 +n/DgLIii/+h+j/NADH/MN2kdgGU4dThUKKHShy0urXXYPqD1RYkSI1PIdRNHjFxPbjZueZ3iGgWz +WrSOxIqMXK4AbkVGIlc7hNCHXYaRP5d09DooiyD7XY4Y6TqoQMrFVl9+eb8P4wNV5WdPf6VFuzxt +K6q94RXq5H+icboIpkqu6TqhzsLl7RXHTpSYTRX9fR9mqG7HjRxTX/L9AVV2WtCpEuhMSKMFHSUF ++uO3UTVI+a/UBnyNOqiKTctTfYd6S339PpBUKSfnsMA1fMrWAfG7CRbWPq++kl/vCNY7tpbymV9L +CZYgtpby2c1/MH2a8KqNuAdAWc84LK82upio8sCWib7yy0SBFmTLRF/5ZaJAMcGyt1cPU871ilGV +lkDUoYH1ymQQQbljYb85qEZADiCHvrlYm99EBWzBb266YjOYhXDeMHis/x4fFavoq5cu4Pz4xOkT +2zBPl3B4XhoLKE9NqjrKawtGWcI03VIFgGrlf4LyMJ2wALDpuRmiEB7GnNdHxTs8xkPc8R7bBxPv +/td06Htspcs7PxoGmn+7n15WIvoce3ltp/GCGXjbya/iLD7BNbzN1It5cx8lqrwMJjEH6E/Ldy/9 +6fT5QwVM8rZBj/7kncKSs3aArtj8SEGIH25409bG21tWqBpeb+9Ux3V0JW3f1pmxxZpefrFmbPzL +PvCzNXRD3lj6bUNWuT6WkX1Bhewj+0dcceszn0psEd63h5LzR+87VUboe4x9BuhPuQFbYvrtoynm +e2yt0uL+VLPNbyK3fBil680vS37oSrVh9V4c3URA10Aet0GqGJVSZkQvIIh/eR7pakFGlF7W9ItV +0k5R0fLUsNNV5sRpiTQVjDRgtKZq5weUcgFeJ5ySohXJEHQA4VliRTuFCp78pTN7c65PB6oyZ4vJ +XahwGpWaw3MqOmz5I3MUbIDwSJ/WEyhh8OSLN/qwJ+4EKsyT8CMtD8wXqzVK699EFA3DCnTy+BN1 +GRriUBU8U2XAyKClqxgThJtl8W+fKbJYUpWUUIVx9chAhUHZodYDoMfc9PgKKQdXS0nr6QLhghWZ +GK2nCxUPFhg+J2nthYoogxWWXV+ZiiGowpjinfR/J3QhL4bpw5GA1+3HwxF/wId7A3pP/bQk99X9 +fDpf6526mM6TLuH4+3q8IfYk2ST/OuY2o9OKXB/1Ub0n3ciWSuFAjhxtxqQe3S4W6Id4ERCKVeh8 +Af5pH4JEAqrOOzeJFBZFY/1pkJtg3YQ4zcDmKz6hAkydGWYExKlCI+dsPoPZBG6D4xRtwEKinMGF +vXipkJzEOSq8PI2P4Ooj7uoTm1Dbh435Kg9l9AIj6GmYdm5fy6nnyCERLsbbbmLz4W/l918fWO6D +6DaJp/TTCB1/oLkUlTszhH/WvKCG6hFWnPrhWFtwpDmDKRf2UOVR4LcyTKR4pVIqwIMkrwDVvjPu +oSUQFgamHbQWw+1ZPEazMNHrMQxS2zAS1AB23XQKI5StHX38w+LBTekSU2R1hHW0HqpWGYiolf70 +S8JTE4o2Jtd2YtnBnJSig/4atbpo6URfK34axOQ9emTKnUsYJyNA9I4RRtJCNu4B6r/OzDx6cvAe +DUzZJ+ZBlrOyvr2Zj/ck86Dk4UsiV1ScqOLsgx82Alt4snO/8mlXyDp5D3iYCyU31OF2oDC+kCll +A3L6ewIP6jhVyZx8N4CvtRQFWWdG53CgszjBrwSysuxAyskM4ka4gQEN1koYHzxUwdTWqh6oMJ0A +wc4Evr4jsHZqcjy1Tx9rQDi4AyFQrSAMUncrHGH6DBa0jfvhynkG8cfodG15J+J5/y93homDOuGE +Uo6s1mRUJ3sgTwTol8HDOntHiIKNZls5/BYJF3RmImUhm7nS+MlAy1O3g7PnPfBXZtuyZ2SsjIGf +HfiAz17DKjJxnfQJJsN3D2uNDTsYPqyUbOATsNGohWz4401ESl4wV8OBj/k09iMQ9NQu6giiC51D +Br52mNVz8Ykxn35w3uwPvZZkJUH3ZzH2sR0den8Mvh5tQrzszMyREKsgL9eL/LFNsrMgUc0sw8Yw +T2VSewBACenMzMkBzB/qTC7m+Dawrne4BWpEs8rxB8MLeMoKPg1w5tOYs9VG9Npz/PXT54Lx+xM4 +tgi7LRELtVwPL0T/xRyh7JbH3iGElQsOaH59B2ljqYMZBWkP5+fp0Ge4VaKC83OlUtHs38QJZpx1 +6Nyyl3YHLhNWWm+eojWoUItAlyabwiyzCJVgxp03Te+eUlMG1hJKg+a/0sgxszNGTmNLN4GFsfSx +OX4rd2wOa5xY4N1jO6gtHay2hMYNT1t2N27a/0oZvmk3K+uGh9vVnN7vU7zkmXeObsosnDujDnRq +BtBj+bLUiWtoT+ls9uGjd/pECpFyRSIAtCrT5Wf6iAbgncGxPHu40x4EWrWCASy0ASI+TyfInvdg +Z8dnQ/4uzXxAl1K/wcNTKQ2K9CYwuX4pO6noIqBv/orzTyHhnaej5SAw/tFhATHnCBUTPOOMYT/k +zzueGvmxwv5g/Jk6Z43aYMw2h37BBmOgaNwFTy8MgL5ZuMeDTrka1nb8ndAPb/lsJ/Spu2J3Qt/P +d0K7/DqYx8CGEJw4TO1ilT45EA0KBCNZlCtEswDRs3htq0wIGu5W4DpPMWi02OjfBjs7/dviwQHN +0ADvrJPxWYbmDRsmyBtiNz6hVNJnjn3zdyGX769yu5BWbl607kEKb4Douzc3bcBBh/K2qCWSfZoI +uUODJcEXnwSnzypLgg5HAkqPOTUQwZd6s1ppIgySVQEJogflvWhoJyvvQuLlwy27PehiJjp77Lrd +aAsVVONtIEsxEgCgM8uD4HGjEghZANyWOhjLlSDyXwk7n/xK8kDNyxmIwUPBccsw+AwJAMhJpSII +dmddwzAQAJ1ZDALoHfctw4B+uEd1d18ZBLow7GKu5NkwVj5fXirdFAAeVwoAMBUj6iA4vrxWw1j5 +fMkHoXU2rHyuPAfw/7s79/aojSyNf4L+Dr27wwQTkKtKdXUmmRiHhGSdgQCemNzYxm6MJ3abp91A +8s9+9v2dKkktd8vY4WF35tkQk27pqC7n8p73HMlKE/sXV7E6xNIvL7fGux7WkLdc9fzyfZzq5jW8 +snlO5dIhln75DlW+K+X10VLd/+Lx83aIp7OVR3SWzqe+fHK3W+3Tn1flrudj73oaqO9jf1Szxcc2 +LvOx64bKxtLHhhyk87F3bWMF+/6wg2xc9LH32sbSxy718yt8bOMyH7v2Gq6Vkf/toy9++q4Zwpz/ +cnGIW9dFvl5G3l8dovPL91zDxYz8Ppq41ffKKz1iMCPferdfXg1ct94/I+dGJQWp0M/7t1dfc3zn +m/SD/DrWD1IeUzI/2LhdnnikJj1c3nu7X7UvW971a48eLz6PmfAt22W9Em7yp9OfSnvjo0+fNndu +7u4/y/Xgndy7z/3k5o2KbcF9v3s5o9wekC7H9PzXWxdvD9wuGypfd6qqWWZz2eby1Yz5rYXLjqK9 +2etCXuz39wrl3o3Yzz6/3Ws19ho5F5r++e2ky1l2e73Oldcm5tq3P/NXn3/cazX2Zv7qy2Uv7xcU +uDfPNwK6t/R+9UCJf3/ctAaXr01cNr8e7nycm4lN2ffw6zttTfr6VlOdP9ytSr/xo0/3qQMePlKC +Pzq/EfJQDuyXYUGEWdW8c/ZP1UbTO376dbblx/3e6dMH1XXbV9K3/OjHnWXTqt/gWLavnj7a/EMN +sZXxRgMj7qneXYK9T7d2tvf+/Ml/7bwM//lq+8n27PvSnrz7461fmruVB/vdfbYn9Q== + + + 8rW0S+vmjuLu7V4XsvTZnj8qr12W//nORvk0+fe/l6bk8naZuftDfT//KmZuA+VPjWGfH7nSb2y7 +1r/uVQIpGrvFXPjc6ZpWd/q96l8nptdq7PVzfj2y3TtnXe+G5l/3vryfu7ESldfu73a309b6u3/p +++Lix838zAKr3s57rvLTMN98XI721r04qvOx9pWw/W6z/+H0/skXL26cP/n8L3/dt6W3+Jn72YEm +391s7oke3/hzbqVmMMuzNN32D/Pm16H3vpbf5PmQb34deu8r1v/Ab34deu9rxuQP+ubXofe+ludU +rnrz69l/fzb6ZHRD7lA+uzc77N+dHN24wZHH08XrVyLgnt2dHh3Pdie/T+cjPS5/FH/k75DG2sSx +cY4vTo7uPh/dzLJjvTHenY3UePve6Mazze354ovjg8Xx2Wwy/328JYf2v93d+/qL8da4XPCMCz4Z +32RJ6hnSnNqQ+6JZ7m9ykzRfNDDIpScZ7bfTkxmn70wWi/nx89eL6Xkz6PZ8PlmTOnh5fHI4n86K +jBlvfj1bLM/KX4vfX03L2ZsvF4tXW5ubb9++rd7W1dn8aFOnlDaV2TTmzvzwxZ3z32eLyW93Zuf/ +sTHefMz8s6OLg72ZnLxuR5Pj51tcdonsbHLaiDbrbYSv1ND/tRKMwg/P3xxde8+Xyw7sOQv/a+z5 +1ev5Sd7x4cHm9GQqoXO+qSu9ee2dHx5cf+Mi+6+x74P5dLI4fjM9ODs9PZudZxX8ER8/+AO7Pji4 +cOB9N6bfubGrF/747189e/Ly+PxeMfN11r92ST7OjyAiP/tv5cN09HrlP3tXguVRHaN75p4No+VN +Xan8z1itfehOWa0ra2KKfmxdtSGXBW1Nir2dbR+ePZ8+eP6P6cHi2wnHfmvUvbqwle83F/PJ7Pxk +spj+dLNMk24zB8PXP230hs9iL87mpxc0tt0ZV4a9cKp3oGixZCE0+TtfvuHDPzj0dqzV+Nvxjz+r +8aFo+dEoixyO/Pjmxnj/+zWlPxipKtjoha8m/gqaVFb5EL21yTntoqmtHPEpaR9V9MrpJEdiCkpp +561TJmif1Vwnw5HoTbBOX+vI/mRkk6pcHUytrTxKVI8RqKzytTPBO+v1+HRUm1QljYyvTZSnjdZk +dke6dpXlpDdGBVXrcahN5ZN2KrFO602W8VUK3jjOWaPT0DiRqaIx6MKnZj2mUsHhHyqEhIxcY7RR +tdeyHJFAi7W3tYpJySiqsoHV4qo+6BgG1rsz0qykNso57znDnqyKsgFnyzxlvakKKuqk2H3y6Voy +XqtKa2MVGjZFpramcikYk8QAyg+N43BXj4jVRqtUxyEZw1zeJRnbGO/82AfPzlONW7QyV9tzd/Ri +dLWGTq8hs/vBZF6MnE0Sp8jVKdqh/Z+OPM4BzTF5lAH9XDg/MMvaHNeRGZjnxUjsW0VlL5/tdF1m +0HuiqsDCWmU3rK8lMxR9V67nejLsjIkrgsvYUOIY7JHZreJfr2KQnaWQKmuD+OAlaBCBg4DfEwJG +omJIBqeo+DHee4GycXB1FU0X6XnvXtsqEuQ2XD6XDXV1OS6BCxW5wKDSiBT7CZVmquRkfTrPYj0r +Ccr4Wlx00ObaK1sRTyZD1yUyZUdGew6Ihh2Wcwak9dG0MtEKnpVRLnEKHA/lKcDAXwYFV5spG1Pr +CBqQOFyqmQxNV4CQrxUYI3vHlgqtq0AhlTIMeuOBLzAG/1cNbKva9pfsdajQL2hkY9agViCwTbVu +oFQElCOleVegXyttQEmjuSCvwzCgdsGEbCczPmAShe20b53Ty5zJkAaMyjBKeVOFCGTn511xGbIi +qmZMVaZAIdH6VvXMRiJxyRpftipTaMe0wYXsLIFwkMGJhwLUbCNWNaMKAMsQsa5EE9G5knlQRJJF +BTxHBCL7rLm6Ma/Oc8A3VGQxeY5IxiOTkyCMOJsM4Qhmknh5bDc6WWVok0U+j6YkZmQT0UtEkA5D +488ygfMkClJdUWXExerAOZuNkUcgy+ocUjJDQo8uefyp3QQGd50pMHLllFVNmm6mkDHJWE3MEYPk +tpAIkCzCJhm0hKMQGGRddqisIgIfj9ct1ssGe7lZhuei5mp8WJuUiq/J1VjNK3yn+Cv0AWXV4uZF +PSn5KrZuFvlSC5rBnfLWd0YJ0oG1fDO7j67CraNlxUS2ODP2rFr1ihOxhhpkcNlHEm6K4zfBAnAA +JTUMIWi5OImH+roObagQyTHEdnXiYjHpqm7znJzXqLCLNgCI+Ux0xTTeOSyJl4XGh2MIFYYMOezz ++oAqMj1Ep6xvZxShYp17AFkVpCxpqAd/Mn3CJXEqV5clhuT6UQArS2Bl6lJAhHWgUzSEb8gIOFrV +6Vc5/D/ERgFiO5kRwtGtkM1XSjio9TZbMIjHhpShNs/PjnDRVAwg543UAbYTAOqEk6Z2gczhhTEk +2yyRYMMMNZptgkyGgMLGNiXgqJVjztQiVvARt8JH2xGwA4QaRGmYqOwDNSLn+F7QIuAorArdZluL +4thGIQHZk2B1y1WYrDkj4KDKCJ6oMsJZS6RnZwAtGkdDTYBAIjiKH+IiRGW50klAs/UOLaN36ATs +bti2BdqTdcurGdqTIcCFJgPDUyp4NwaLRQWCCn3moSVeMUbdOjpR3+bdlvvqmrQWVOPJCY1g+O4X +DIAolAjEF1+TWIFNLMFSzhsKC9fS3owaxqfl5XzRts26zFDjezaV/LUUWZqJ9ILWQknKeRes0mns +3xgJYK1aLpy1wADoyNm62Ig5cPdadRzfaXxJ+WUi1eRKclmbEpzLFosNf+A85AuHb5zVi5oAG5O6 +CbTG7rZutSSZjwheEnKtCQib2oA2As0WX2ksyemI8buIZq8XiweZIdQXkivYSxok95nUjIEAcd2t +QVYUe2pgEuhaD1UkvjC+M13y1aKGssdAPlhGdFaBJ0M0gAJegbmhzYly+gqKsZPpMrCFq3WalOKE +cSJ2JK9HK0REkw10a+s1gZxzLFDd1jWIEtZQriYtDUiAKbnuwsXE6Up6XpGhxhYnIyVnnjFeWQaV +J3hmpa4tp9d2sirBJDWeLTpqoGF9EGKNAy3+xIFVrEkM7GVNpmgEB0/EQ43OVhdSlBooMokVEbjS +LgdYb2+Umv7F0KemmUHIwBGXkMLqJBNBUwpLxMIkcgIctRNBufzXGZeIqFD4zdjV4CS+FVvYRUJS +HBm34AYSRJARlGl4L6kTiiU82LED9rQzctAXK44RSsMCPVAU64gOYLKk0hzntQI1TdOI0ExG5Bun +CpEZAxkkTu1w5JxnkGBUsZCvM0Yyj4cuxiXT0mTuPqGUgrRItJ2TelAG2GMjDgqVYWhIBi4ND+w1 +K9ZkyC5ooYckhK0WNGxT/5AEKUyx5XbPaO5KGdYr9LGP2wMywjLqYKCvpYtTYpPk7SA/gnzCVJQw +gSWZBorJoDVlZeMMUAChH8v6UIMxuAt2BKTEOYMYzVjsmG2EekE4+IYVlWsAiS3BVoQjGYC+jbW1 +5UYWh+uGpnxIH1BmxQhRKgxqXB8bkrlmSICUkGW7XZCsSrAnaCpGMsRJLjSGXKaREUyoJcQGXU/Y +oUpdzbQm4qMWeIASa9FeaoBKconPhC53oExXlZGKrCQDYXJQI5uDBDiFX6jYDlFLhZAsxNlmiGEd +wAAo3hbOgmQBLZDngaOMZEKlE7SzlrJTujIMKWvXQp2ThLTUv5RAoe6wTgFtQbWJDCTzOAdEsaPw +gi4wdNIgXxwGggY6Sd9qif81NYbHvq0Bg5S2EbcsxaxgLBpJUgQEyrC8ZSGwICp4Vag+MEsdg7mg +DTHjz24rw9pqV9QyIAP3oL4wycXSihqSIftivx7WrcpIIYyFKLqULrGIdauaUpuJswEGJKDHGk02 +fFH2ROhZuaYlAmsyUlpRrUFjG+adQ60W3tnlG2RAeAoKpWPpZpUQgWYnW+gvRaEnyDlVklJO0dTh +sBkKlWxJoaYhyAIywRWv9BqX6kiH1EmB4OT6SKZo1rK+3iC2xX54V4O815FZ0R77hXunGnYfTc5I +qxZIFjKuY4mh7FWrEjsZOggr1RS/dsjWRaYGN0p9NShDuAUiVkUh22rA96LYhHUucz78uSKuUl2K +wAJBVOUtriJRKigCO7Y+ThBLm7mpgCSXU3JEJ05khZ2Lb4ImZD8jNbTO8Ex8QmWDbeEZ/eqEDH4X +Qq5Zx1pyM7AFRctVJwqneIr9nGRr6WOSErTLoc8MUkkwbS69k4whJDbZpjAWskSmx0yx6WrURSZK +b7KJ7CwBlEsZVGcLkJIh4ywDp8evigTLWMK7SFC94vhFYkearFFu4HSlmSA58/i2ahEmJ2bEULkF +g2c6amArIV7aEEAKmaXmapW7KLFZCQESS6cgc8zs8r5rNgBjUmPWtdw5KhSSskA5aT7VDbUjJKwS +1/ai/HJF7UKXX8kmOCrmapCZ7YiWtDXNfoR157LPaumrZgpJsUDOWHZ8xHQECPArsIpS3jAKlRn5 +3TYVCnaCEBtYmy4xz1rZoGt8Ni8WrI51V9Q3oxIasKCS8gDFCuO1NW3WiRGDpSUd8LmklKAq3FBi +uzJNsUd+0XIfDT7a0GUjNAvBEErTmtpNMoakP0Kl2JePQNqyDUzGkxZK1+LDX6Xp22sjohWDv0KQ +G+6Te3xKusJZ76xTmgmYw7YYuDNKEgUYEr7f7JeVVjAbuTWW9wuysRCnux6GFmxl0hr5gvyUAySY +5a0MLSV3FCOE4vMHIycZUDhX2zHS+LdQFgZi4WiFcKjkvlWThlCTtKWMlyKhrJYEWpFVg7K62Y9U +6sbhiSHXqMIsRQaYjssELjLEURs7u1lGbN4qpshoaYSnkPFCJJLr0WApMkgLbe9kfGUVIvWMHm+/ +GqnmBm55pGh/Qv2ZoqQmsiE6j1S2aLXyykjVEAiLXKOuyUizFUyOwjwyWsGA5CwI7fBi8aGsYciB +CV42Dn4BGuQK76n2wrqE1OPSL4evGFGhdwOjKBZHzR9wJvBqaCXrEiv7kXJ4VUb4BHAaiDOFpsfr +K4GE4Xfgj4dIxaH9rErkHsaKVtZHWdXs+kquso/Ydvj5hdXHBCbHW1v3Tk6OX51PN8abe7NjeQ9G ++3CAnNw9fjN9/HLyarq1dX8yOzyZzv/WPV+xOpoeb949OzsZ90fd2to5OTv49e3xeXORGm8+mk5W +hR6dLSYy1Pbs6KQRJN1J977t3A1ddX96fPRycfHhkgsCX8+OF8eTk+9eTw7nk/bxjyB5JwokkhjB +uMGhd6azxXT+9F1rfng8vTc77K34UrHHi8l80ROEEV/0lMtXsH9tZXx/fLh42T2rsWK7h5P55PR8 ++OzFh2Ly8xj/7GcxcHHwmdqDjMVRL0ENeXCC3tIFLW2yNRnopZGimTDxmVGXXoZJWm7L5EQHwVBQ +A7ZCZhBG7SlD4WoxB8+6hIRs7aUDrgXpSzJcG8XI7ZM6CEUiUw+tZE1iZT8yz5pMvg== + + + uSx3BKTRqMcDK0nSpJJGMQRObjqt72dFIkPQqlbWRlnT7NpKrrLP/wsIChJ0Hf+39QcFoSQ36BJE +QZru/p8BQiu+ciUIXVCHMKL/LRjaW31cbKjdunu3PBfN9vODy3fujG7ceDg5mj6ZT45xktHR+eTN +dDyZzcSw01ecGR/Np+eLs/l0fP7y7K0c4ZJW/MaNew++HP0Phl8izg== + + + diff --git a/dist/images/KiwixLogoVertical_v2.svg.png b/dist/images/KiwixLogoVertical_v2.svg.png new file mode 100644 index 000000000..20e2da196 Binary files /dev/null and b/dist/images/KiwixLogoVertical_v2.svg.png differ diff --git a/dist/images/KiwixLogoVertical_v3.png b/dist/images/KiwixLogoVertical_v3.png new file mode 100644 index 000000000..87f9d431d Binary files /dev/null and b/dist/images/KiwixLogoVertical_v3.png differ diff --git a/dist/images/KiwixLogoVertical_v3.svg b/dist/images/KiwixLogoVertical_v3.svg new file mode 100644 index 000000000..44d23fd87 --- /dev/null +++ b/dist/images/KiwixLogoVertical_v3.svg @@ -0,0 +1,614 @@ + + + +image/svg+xml + eJzcfediArmu8PcCvAMECB1m6C10hhISCBBKGnUoobct98d99s/29GEaZe+ee3fPyQLjkWxZkiVZ +ss2GWsOVHm+GpMvnxvQ6szm7JwfHzT6qR7/qS8vl6XDcw5+sdZseD7kx0ChdCvfohi1yf5hv1lG9 +FwBw+8FDAr5tbYxmy8GUPJJ7p75xJCeDtf7LOtqsAazRkRx/2Wx6qw20bs6PSxK0fy61Sx1XpVqo +9jDcvR1PbExnAPTc4Aja4LgH/BvRe6PekL72Ap8P1n8MDof5f8GnQV/YB37LbE7r8Xw9zWz+iuox +vR8L6fFIOAD++LzgcXFeJw/CNm5/KOT1+cLhYAgPhwLwFbc3GMH9AW8g5AvD1/3ukA/zev1BLIJ+ +8OHucNjnDfkCEV8gCMDmNqPTilwfa/vNiDwcspvlZn+I6rN/g3G/ADqsjwN9l1wuN3/qM8vBaKED +NAz0iPmSBORaDY563Acpmy7h3l7mNF+OX0+rIQkIGQhH4M++HgL5fgCwAFj4Gf4c6pVW4JcGeTyC +4QCEcHbqhQy/G5AK8F/rZ52cztFkApJ+22iw+812NdgvDvchBATZJFfbJZgxRN1IBHcH9KEg5o7g +4Yg/4MO9Ackf6XcBRdB7YNzuIOYLeSNefxgL6MMRzI2Fgl4s4vcG/GBOwSNBA9zvj/BbUPC4eSH/ +mJN/RvWvmzVJET+9PzYozvH7MYz6Sz2pn5bk/n09PwKioDFFKOq/bMbkErRn3ycAix8Y+uLcX6pB +c7AHAgDYbbM8HZGMhBkMYHYrg79JyCI4haC6JdfNTQv10QVmQe+NhHxuP0czzO0NBPxhPxYIgCnC +vbgeDwT9ehwDffcGEd5wWO/3sb3Bub8UUogCImAwAxKZa4B7qvv5dL6O+rx6rxfjoaQYrLCfjzn+ +Cnn1YeoPGqgbjAj+g+MRQHdvROsvEfRPKIgHwrjfq+UXikqA4McjuaapBmQl+8Ljfcz90gBjyq/H +2c0KzvoB6gPA9GsgD8vNlHrGfkZPwOunLUUf9L0HGKS2n68hTN0rehLu1ZYn8Kiw35y2pfVko7NS +yrEyX5N66pkePQQ6Df022B//3OwX4GtpTA44KXcP5lubIsjGgjyOZmKg9K/Xg22RI6CrAbeP9dXh +L/gCYUDNoW8CfQyGCr6zbdTBgWnYMyMHb6KvzH/V386RE9Bt7nXq1/z6D3K52fLAUu3U4dWWg/Vg +zxKLmZs/wJMBmEgOIGxIHjsaIAL52AJyIBjCqVBtwHukYbr/Xg03y/lhxULm/1IDEz4fLcnG34cj +qYEQjRGUjr0+sz8dZvrmZrPkwAoesRShf0a/wvb/GThq6IV1dQ0+zKQw0Q3EmIBGpt75D8XFviOF +Bzz834IjO1gu59P9YDubj6TQSDxn8fGfXTZNYERLcj0+sGiorxxoKPLUb5qnXZ8fz4HSkxFyxTaN +PwdAJ1fmQ0VssN+T+XoMxKJxmh9Jjkab1RZaofrGbLAlkbAzLRsswEAPrFf8FcnlUluqqOUOdYPS +9MyIqXl4AapyCjpT3QNENuVnesXZ9oC/J7AonT/22PRuqjNwteV35c5DkuNDnVWua+ARtFu8yG5C +/4f/eimb6a7djlBPoJF5/HtJHnSe5/XmzzX6oo/qrJ9gdRuclsdvm97zOliReqfO05gDw5lkmmD6 +qg7jWXO4vjMAP9R1mDvkj4S8uD8I/uuPBKFtGAxFcGD3hqBNCIxE9AsGngWBLRyOBILQ6opgwJIP +4REsgPuCOE6D7qR1jO0KvvwNvpTBh1/w05+AQPoX/ec3ph+Dnzt1HerEWOeh1tWYTu8BowD/ReMF +BOJGq0qy2mAJDDcSjbA2vPOYxK4OomDnv3RnLlBtpKtl2M4yfbpkYisAHH82z2iBGlzDQThGPaIs +Agjm/9E/A0CiH2WA031lnCDgRg905p6H+Q6YDH6bjyA1Bvu/qe+dl8orcHQkH8b01r9WyzV47ALK +cT8fno4kUMhO2DS93w80gLgDfF6r0Qz4yntyTbXx6j0lMCz2Kfxz/BuqV/jUuiKPgzGgAR4EQgf8 +uxF43ABY1lPhK38MlifmnflYue0ayC7VFPQKNnbeh0z/uymtnb778SQ6GG5OxwvIzHvnP4faNxLU +p0zQOXTWPIc/pg7QQDt1jUfyL0hZNZI6lbqGK3ZNGji/E+NRdIL8VO1T7PwP5u3Z8biNejzb037p +3uynnvEI/G81hy0AKebLJXKsL5OAPXnYnPYjlbfOhIB7Tbsc/JPTTDW/2yT/BwwIRqcvG9E/1p3R +KNpG0Z//iN5A9qvniP8bIv24PvT+GOwPMRlVyR84/P2gQaUyDe+0Qv2L1BnO0WYJroE4gIgN8viK +yKBOIX7rf1oZqIxxvVnLdZk/vuVmtCDHWsbGtPwfNVD+MWkHMzUfDJekFsb/PyXo0T80izps+i9z +MRze6HQ4blb/rib75/gwehjAGAn0ZIHq0MqO/7hcgL78B3Xl/4KUHiZ//gevxv+yGByW89H/dl2M +B7x+dxD3496wzxfEw3pPnRws5cc8I+fTmRYpY1v+u8oYJUt4A95IBAt5vcGg2vj+nI+PMy3Doxv+ +u6MTp4aoDO5vLQP7+98e1FkCjMqo/tKkeP7tUQFlk9lsFIYx3ByBxVAhJ0cqE0TLqM7f+Q+wDpBa +bKCICMrw+tfNA7CI/dtdYGLedwobRG7sjnFM7z1oYTJeYySeNO50Ccf17B4GSuDRVwbr6Qnms9Q2 +W7g9i5B9vpDj+Wml51Kwvs/JIAWNTjMi9/ranjyQRz3no+IBjFEL6VJE/0IeZvr64HAk9/P/QrtK +PGzUGz5M8Eb1dNyejirvMEOF2XnpPTlIo3yScxtFpEdCXoyvw7z6EObF3AFfAOizEMzrojpS28zX +RzhdVpTpxpdgBnFuftguB3+/DGDACREzvT8ON4P9WB84pyGPPMxQa+m6jFIVJw3y+lQnl81NneoP +6l9tc5jDAaKnOG9h5WchSq5FGuB5RfqxdGDG2CCXJMxSlW1Ab/e9nosN0wJNklCE4ewPGCqOYEIh +S3MKPmJFhuf1i/VmtNgAVplSGQeiphH9drAFHHqYr07LAcc6wQCYb1mMely/Z8YFDDBvWL6lVz9k +5Va16XRPkmvF4cwBhw+OJABKonCScOmCQI/7wfqwHQBdM/obAJyP9TCzV+OoLugrSwBVoLxR4YJR +IbWw/4PUN8m/jihBZDCcL+dHZsZhLjILmFEuVLZygx2TWHpZwg2Wc3rV9NNAQIfEzLIaHBairh22 +G1pVhhi6jrdzN62GWAt0Oxhzgal0SZ8+HTesPmLsO9b44eWzwVTQHlzzicGITK+nS7oxEOVgiEYo +bl6HtniBoyOnPiVbVreDEUtGTAlmhp1w/jRKNq0zE26lktR5a88iXSJOyyUzRXQ2O3h6zsuYfsIu +C0AslzDRk9pe09LycNxvFowxxG8c5DUerI9zPZj9wUGaQ4RGFNBSxcERdL2yGQ2WUBcdeFpHpi2g +Erkv5fgt+Y+bMIQAsTJrl9xsZcnlkmNlr/y0FmFO6WZd5DllXpnJavKcQyW8WWDcHdXYCdmmIm6S +bkksN5t9dTI5kKpAqaZ8qJD5ZIYDe8Cynjfoxf0KDfkiEo6EcYWmHOeH8YjXjXsDkVAwEPQG9GG/ +H3eHsIg/5KV+EC33YmiN44BdDdVFGQ2eHZA/EA7JDQi15I1IFSo3JJhipNZrwO2Mrg9jbiq7HPPi +AUWdlf/reGZJitvBnH9JwLii0uKD9odlmQfm3gOlA0yr42A9UlW0CLRI08KMNdYI5quZPVLfrj9Q +Drd+OFhyGHAZzTRazrdgpYPh1L/AmjgFjCCjdoCCYFOIwBNP/q/tZn+EmiJ9AEJzeCZZEXMFGGtX +fv6AVTaAX9DMtwbr+WEGyMJjQkW9j5K4W/PDnFpwIQvLSEMocpk0cOCbmy2vO7dKGQc3g7xmPmhg +pDOgYWmHHuC6HLYUDUORAAs5gMOKDR8evAQylBnUaahxtQgPz5corcfkXw1ytFnTyiLs97G9CfmA +eXZpbzgaXtsdYr4/qLyCGFKev+ReYyn1j3AlC/2+TMmCPePJUAhnIfuxyOU8CUFLsaScItoyxvTm +D3K/hQmMtB6y0jFUPBLw8Wy2RquAytYym7/aXCzUige8OF29JN2Yb4JYGfWuZz6I3oHKGrzT6TI2 +Ehj0aLMfk+NzFan3vG6OgseCKAHu1QMru7AfjOfQERqsx3TYQClQQL2Eqolg1j58Cfka4peEmHB9 +vta4GBX1ljouxsiugMWG8XNLOZprAvzoDIRHeRQeqqxIn+EvSWrUo0F5uCCi53czdCPeGCyXjJ92 +sGlqLpRecas9CbjuQG5Q0jvFG+cBDvFLTA+AxzolleED1215pkLEjQ6L+XYICLQQx9HOxgQz9Dmk +MdYfhQnZ5c0QVh3oOftdhdBy3RnOj6sBFEshq0m03k5XCzcwBMjxZjJxnw4kMBQy8Cs9N6zTefYS +KjqFL1GhZJGNLo+D31yqR6OVm1Eoo9XfC3m68xpujjNm8mVArgAz0EIQCUh2crt383ZmpGcQMMzB +TW3Q06z27m649W1yqM9uAJOM9V/WRrta+7Lp//AqcyHq/WYyZyxDQUGB0nuAHUnEE4Kg3dmYD8el +e0xBRHKkUTjga9vtGJJrudaMYDuWnyZIWAHJ1DtANWehhv1euRnjbxVKsjdoQ3eSbhSWA4UydN1L +sPZpJxRFWI5OYQxXBs9n/kAopNx4z1vuAHMA9T7WD//W5/Zgod4r9w4C4U2fyqCPm62C+I4QoTc8 +/1q+GU+CFBqJYCko/wOlyTQ05YuSuv7naONVAjqkd6FkVdAS8PZmDabjCGN3Ki05HSTXgjWghvCM +AeVRj8nDfLoenK/uAqD7sXtLx8wVUINWE+BNzjb7/1KaPNBss5+6Z0yMUg7WZg+tl4E60sNouxyJ +wztSKP/guc/SrQ4wqMC0k8QHWQ+FqNXwgUlYDrbumXLfj8BRYKLgqrD+kFdRVOdHa7Fzc7aCHmA1 +kkobcg29ekYbu73SSx1sCbQijGvyBFaVuDNN4oWgUxpcs0iidwBT0+naikMc7TcK+oCzNVTaQENs +DowtVcXHW2E0WDf7i1qzileDmcWtTBoAc401QOb1WUNrts9SzDxZH93jpbKio2YR7tAMB3sFlbk9 +uNfkdMBtnEo1gggPp+FByQY4AHsYWtDKUMbL7X6yWSspcQAJxtuA0XngPDHpdkvglSg4LggSWLTW +anTa8+od2SFKTNHBDf3xNeiZIlKw7ArbhaRWjb+2bkEE0ietGSC82QC4Xcy2CPJlpaBNxa6ID5Np +uRe3lGlHr7qC/RvJecDhjA0UGgFgcNsG7dqwCl2KjyBWsEgqQtpsRxtlCLS1gHaTVECNT/ImCmhw +OG0RK/45mx9JJZ2IgB0UsCG3ZnJaj1SaCFYXST6kINGRIYbHVJQ/emewXjN7n1LDBQ== + + 3hI0tdlQlLbUEBERBLkpPLc7zbTiOd7CTXAYDqnSG4FNluW4vACmiSj+JdwmhDu1cH8wLeA0mZHw +sltQIEkpo4WHBbXNwo2BLL0xUOdvDOBno7qkLUOBhvxWKGwmMcizLkqC4tGTaiQOJ6qSiuqnAq34 +US6EQyHIhcl1WsABXDrHesMFQPXzNdqagaa3GNzZdths82dxPhbP5lmz9eA8iQSY4GzqU23+F7kE +b03Ikbh78N32DFhjuf3gz/NZYR+/bP4AT3tAX87EXCBucyCn6ISmM0I0Bn+QL8DfngOWSgsDfSrR +LOsn77Q6/X3DIXAOazkC7piux6BHCpYU5CPYFIXBKqwhJQPVD5syQTN5/cngb+4H261KQ4QdHViW +YQ0kGeyoKSsn6k2pMc3XCr4l05QAktEmhzCOTotfcwakSQ9PjjrOSD0dVtEf6PO79H/OyLX+MIDc +oR+s+ScP6qEjoB8c4M/00Sw5gs0scuvfDwgk+CsE9vfmpN8CidRv1nog+fAJQk2Bmw6AkM0FiJx6 +gIx9dQ3Gqj9uIIgRqZ8joRzol4O/YVIWmIblfERl7x3gYSOge6V1DjnVHBgK2xqwyAn0bjPh0M8P ++tN6AY8EcStzKDPzAPRoP98KLBsV5qsrB7c4VqFsUiBt6tMKdDxMClRyggV9yKhFdwWtm0p2CNMS +nllX4rtesi2b+/mK11slwabSMmF2DDrEEc4R1Ai1DZjlv9VpyCSE8ZgpT3FcdrClcsPmzDolbbwy +kF42681ott+syBxgDqrcSbwRI2l1X5QRIEsHeuyl9QgMBOWGqBJANd1J0itktQ8K5hFgwGnqeLuM +SoCfebGwH/yd5dypt9OAS8CT8Tg0598q4ZWaoOc5s9Mt7cMItLL8vMq8qpx55oUptMoY4amaXLKW +lMvJ1wWAJIJkRpU5kKSCIos3gMMNphw4sHVIfi3DgIiEo1BaJcGCgEzzpjDGJr9WUeRt8hJQNYwd +zsfgSDZnp9VwPZgvOW7XyrMcwWR6p5QcqKgiqZ0FqPuaSqeyyGvC7GY95od9ZWKBYk3b5u+xa8NH +H8n0N2eAaXwRrIhAwQ60G2+8F7TqdZHA8jhcAQ96KYs8dbEKvUwVctajX1GtQJXEdRKdP5Iebpi4 +Fy9FQKwMNZQvXO4qi6QKJoEgP4qbJFWFJSkjyqpVqIo0KnRt+XDXCU5pDEyJ+WTO7JxeNvWabTch +tQSroNcrYydIEEzMNH5NK6D0PGmwk9Kj/WY4OFJHEV9DH9ZSVB6kSH7Fo7xoZs+MQzYYBNpQLJ5l +3UnaY83MGW813ciWSuFAjoTI4EN/svr46Yi3nyyxQcdZ9j1WXZnUvrCaRadrQ5kwOK2W7HzgPpiC +78V80BhNvRcSL/5ktPJleUntT6MQkfe+hM2432/EsEPuNzd1YqZU7MdtT8Wd20Pq8Oz16MypWMWw +ZxqVj5lp8a2SivvJRnb+lBjl3G7L9AxVZdwF+EI5whwNfRSOud/vjP/D5UyvNpUDcNCPM0ciaDwR +Ob+pnfldWto6c26ClYeSwEyhyCTUevv8Sjez7pY8Un676HcqviC+U9GDe+XIOc0nwloYT3RmRCyi +D6YjN/luhzLL1LITnWRmx+ws9IELyNF/zI3wyi4VT1raFBzQ5UP2Z/qzAZ8ed7nSuGTIuMK/pnTD +ZVxTfegMxiedOfJrdYzyo8CbNTvz92LxtNn36Mi8OvuOVNbyTmTJkz3RKhtnsdFosICf5o78pDKj +MOOYZxDaz0396PynPM4szUmLa+/4OqUrjccd7L8tFSvPfDpzMNb6TqXXI8vK8fQS84RWX0/zUMhz +mPjS+1EJdyyiOAtxlCsfWoBsIQsZavuwcXSe9QzA/OIvT1aXk8wsQ7UVNYJuxZzKluLGdt4ZCRzA +vJQ+g8ZEKLv5ccRb48+od2j8RmATazMYUCJoN8Ip+Qy2g29rSKdEZmELumjWbI0rGP5tfMl5BvFH +wuD42EMsQfjgB0FBTXRmbPhQ8qPPjgQRpz/F2/lnqnnWme9TwLxdbwmwbgdzJBJ5pzeXnD7RcNpP +8dj49/UHzSTbYQCvmgnQWECjTJntwDfXAdz6VIeNSD/6LWDI5HqI1GC9T/qDH8HfUbqZ+3XkJp7n +XX4wsJgyweH7W6Rm7rynq9lMLTdpzHep3Xd0qjNn/N1mjyLmR3D8ke/hjlbG30lXidxvu5ed/wY9 +scnKPCWyEzsOCJjoh0L18YbDF27sVs/pasX+TORs42eKNgyhKd4Hs3/cut8cydZgRw0oEQwPUrHm +8SHdLB9P50MTUZZHB2YiOnsDA6oBJKeaPerM+Y+xeertx5M5jPhK+RALxPtxIge4w+50ZDaRH/Fc +CSnLn1hmIijOSc4OJ0QlMBY+ncqVQrpXxhHHxB3bWJ+wTp7daSze/PDaTD9xqiNCcgRP9QhJWB+3 +tuwsWF/kHRU3wXEqEIDuBmqYRn4MOTQFhGr1CIZmtGWns/whFBu919OhD29bPAe14rIlgP1QyLuc +w4jUlEQW5HNWZ043X8YOoGESkVym0l1I9Ra15LUrdEMTIDR5L+Yt+F/OOedYI2y1ZYzIBT68jkSh +79KZuXGBUY0mRD4XCGWCrmoLKRw3Xmw5EdKcp7+1Z36P41VmuW5t0s1ZxwRAPDtYANu8c/PqJR5d +oc90fTKzgNe+HzNBR2VGaUtbbmIpBkFvNzNKC+ZbnSKjwgGC5++mj0hNnzpQwfdzQ/+snX43jw7C +do/pevNzGf5duuJIo3ELAcDCPd+UsXhmYd3OiXgBt/J0+0fdPuDTBKwlPGWNY8NT3vq0a3Mrjegp +4GTrMTQF3SMbZ8/DfUesdJgAjT0yBjL4afmZbvTLWfppJN1PxYtZN2jSbwEtUHnM4B+nXrpxavq5 +p6gx0GPgh1VqP4o+UrPFl09PN56sZteh+mRqxYc/72nfo8GUhzydxQvZSgp+SmDlAv6EkcNoEnda +s0n2twT3hs7MtUS/wq8ZqAqz6EX0NdioeN/g0yfqbQZBFv6WoYCl4y4iFHDl6t7exzYPm8RRY/g1 +pzOz3cvARq8cHAoLxCcEkWI7n2DfiKEmsDc11CV2uGnUEZ0ZDZMaMOxUqFZ8acLfYggYhwWBEJOI +6bIYKfrKwmvQWNi30Tsx+BwNI8mREjVH3aOouJ7G3lgSNBA9WSxx0dSB2RdOlMTUXjERommgsVDv +QGJxsNEwEJ2E5HhCo+K+ImAs5oJEH1KSY0moTwnVZfSJhUghFX6l2AJofjnGkGUL2LjCjopjFUli +oQeAk8+J9USNFUkOQ44nbsywcVWKqCJJZQn4RFFMNExEk6gQRFLYmyyLmeJpEVLUmJM6wMncbAlm +NcFxLWoOKZGWEJUY28MaqzwoJkUPaNlHYC8ntTK/IJIjKiLINI9JKUA0NFY0L2NDakpYGaK0Jepj +PRjGbVX0iSI/HAbqPPzzITT97Olm63lNpCxkE1j6Ey9/wYik12CtnFaI/ks3ShjsbrCKwXGFmdXe +ZQKWS26Rahvfp9n5Ty+VHy12j9RSxjMnAseavDvDNzscbeTOAF9M6NCgjuamLluSMv1qJdsXt8YJ +vC3MmGpZrJHs7FT/yD0/7zL8AWV6ZLq+zlVTjZ/9EFiwy9QKF2JxIN8h+oote3FXn9iIn3oebJ/A +CW1t8yNn05MJOr0unt+IZ4bTHGnPFznbClpK5VOEIwxthX2FqzzXjW9EANcU+raRJbGZUObZGYCO +H7zm2nhe6l9p2C9gKQFrPfBxi3OiwTWBltKNzokG14S2+lgOdcGhUS6zwPf9WXAeSnjp3hfpOXg3 +L2j7qFPOIDOWoxMH6v+WZ4EcacafKn7lnjNBC0BgG2beUp/2zJv5+4jMYagqQhJ04vsiiO0TwWd3 +rvQbGnBkA54FJBxN/vS6GGotK8109f0ZsDuQToo5uY7IORUUPRPBoJ0VgEJmGZx+IutfZ+bs//OO +ktVcYWEmgXi9xWFQYwQ+OY+F7cMwEnHE/K9CsBUZJyVuoTRMId1Yphzg7ekOH9WTVW/q3RChPdWm +nQTEWvhVnH7vx8KYnX0ZoqDDvR4z+99uMFw3kP3M4sUBHJHaxM8KSBQ6Bj+ZhffJwD1gmR2LjldL +DE5TWeAjBzNEPP/lZqGEiJ9vu5HIr09AKr3myCpMcZbT5PkMh0aVcuatlgKrRXf1Snf01DWn314b +LehrMw/avz6axptHLLQ4DWtYZeteFg5Vci/CTEulCPe9MevMLEsSqf1+9u6PvrSTCEEMS8b60LvL +YpNItsSDXd1mihn/KYPhzveDQTAHnz/pSOzZxT5o+nfueRr5Ynlnav9QLhJ2m9MP1FUb+DfO8Rqs +TnWC6NkMMzhSXyo+/Fmn2m+Ox+jM0ZiDxS/yi/icp53PAhhFV668t/cpHjvnGEM+QbVk5VcATJv0 +eoPpR7QCwjiMmvz6uKCjsvTyOgKlF7iCm0l2fpgHYVTB9VnHyvldVgRRg5fPA/tmACs3I70+YL48 +L1GTKB42AJufsHVrx/RzFx9T0/j0/DrOjVcRJ8N81gfgpyexXLZopBYj18aQcFOBACp61n4KRMn+ +I0nTqVjzZJbuOg6ANtbI7NCZKYyv7+HvfO/H/Ak6PzWkdpkfK7tizVi+A1o3aDIDSkRKcM2Z5oee +j7nQhkEa+xP57vR6XZkCSynUftk2hGs31TIU9+XJ/E912AO2SQwqnIktP3JgX2m/NfIG1F87TNkC +NHqfMRVPvj/mSqv5ZybQ6rjTb/baNF1vOoBnUTAXvkOZBT7e800VakF58uRKnxU7NDbqqAnQzvGG +VOfDzUdTg+gZH7u5CaBXZhk2OXNlq82KjBtW9pElMTUvAE9EHmITU2MmgdQPFtH6Ie+wByf85Q3O +1baX+Um1TMcji7kCpnhqCB4rRB1wcqDpdgkeWQxY6bMQp0Gw6yuK0L78TibRueXtBZh0zjSR6xbt +UkMTtAs4dObY9+bzS6lRyx56HcWqoiYx8se2QHG06Os0Ns87Nx840IwBPN0IEN+F1dFuge1+GQ1z +xkXGA1hLXmaUIZMMdgrZ12wrKeINevdib/gEZvOuDiY5teNZhzQozA3I297qzGgDRGIO3EA+n4PB +J2JXjOeWlQBnBNOT+GM05CaN/iY7fzAFAGP7q+l1orSR4iE4L5DpqpvRNvIy8eDpajT/nIpltnzL +m+5Z3JrauyInqJNT6dD3+DU3ifQ9+Q/y+CiiZ+R3b2mCdf+nm97MqnZAMSGzsOYS+vrFdR50Klni +cUniKeiTYpDIIp1vpkOROjIbe7nJ2wGsyJSqoHtbNBLZ9PeUyKam9aLpCS+lI55FWrpJ2v6bajVL +AyKeO/J6AzSx8SEVbZPTVHi776G45DkW4NDZ0VwBLqrNtI6UMvOEUOKF5cvKkQgVimB92X3EuuxE ++YCizB9gmP4NcMfvY6o1aZ54sBPB8innro9dqejr74JnnIM/zeADsc7SWy+suO7S0A== + + e82swOonIL9l6ZmRP32G1KSfT45i9ZQr/hwOOeeQyMdtJvM74MXuLrOqJgLn/PL2AJavxQe0lGK4 +Feg5vxmYak1PbtLcA2cPm6x4Elg6fPcLZsLwnNobf465yWbvlmDYCFg1pza4t9MhspOkjxMf2n+B +xkEIBmIpE4swdX7nmDewmOUKCTMJTIxIkIrBjlofBxZsjLCWxm3oXH5BHdHJkfEf6CqcHJwDyOzy ++OxWWziwj7WBVVT4TVfxjA+42clFKp7YGvmyyJhB4NPYw6MidnB+BBPv/nw64Hp+g4oCP8eCGqGO +/hDepuSa9EBU1vlRYA0wu9w2CWJZ0qHGCwHmoFtLb9ITqzQWQPnnsBwIK7CesGn0xeEDK2nz0aBJ +UgVsT82LHOOzwXfsCIS4uU5j3iTxBpiqj+VH3X0glypud0xj5wYadEGKkQrd1BJtHNLWheOp/FHm +UQesOt+ZZShlQq4EvZEZhJsLIfsJ6ot61DWJ79mR8kMQL0Ubllkut32RA8/xGG/ZHuaHWNzCt+Bp +iEHqQXo5IOGuhBFu1mDp+qZyzDmruzFjKS1ObK/56wvC8pgfPQS/gSdj2BP5cL0oNjZ2xXoFOcqx +yerxEbjtv0HOFpKwAF6Axs670WQDLAo2Raydd1QtDkDAH5dSu8QLEMNnE8BMuKUw68ws7nYqviRs +fBtcDKwhL3dQhHfZ13ykjxYUR+LwEeGUI9CWcEhP1jdbF3oor565MRqnDVqmEdFbeoJARwaXqVBn +mk+HC4cj3Pp2Edayq5XF31eHGBl9XIEx1218zIndClmRUCcnR6RQW57S4eF2ylsSkML9eBsUga23 +wWKTE7kXq96NPefhvcFuDCOm0ZmDOzzSAPZ2gyBSU8DkjVNzrM6/QeT0IjpAP+AFsE/bC+yR+Eu6 +4UyBeZna13wsiDnzo9NDLx12uR+gQRgUsRdYjtZkxr8Yj4Ot9+9WOJTMFrOzz/ED9LAeUvE330/u ++Tn+wG4Wi18D9hgxeMynYt/vwOwMvTkwr3M3Alr+YwHW3Mk2XV8G2gIlPOikDrbOQ+657ANsb8xs +pRQqs2tf+wg1e6e1zgxaZp9y00DwIe48fc2DiZ09D7wg+46IEyOaG1n9xKomRifReuxAOxW1R8dT +KvSQQ7kDoCPf2VBjvIkDa3xr+nFxwc3oeDxqRr0Dey2zdOHNQuejswbzcsxw0TyqyevP8ET0v08z +mG1hQb6Ra+1s+tFE8Ccbg/cSUrMx8bjaYOLfren1cHpgdZsA4o93hdZAXo6FAGwLGK8/J0DArhmo +tbcT95TisXa6+R5qcrSLLFK/FTDyVVsQsoRU7rfBErXFDmks/rrlxUQRsTKWeDNnn3tGcWf3OZMO +O0sQ3uMcjAXJKmsQyVGemRzawssDYyozSlefi3C7dNqFdPAKuvT2ABYH8jM2aG9+gffqyf+aiXxk +M8//dGbvQOG4uhLN+8H36ucvrWEqxJcsbMJ2jG3yo6AtkHmx2eahdenNAT1xcTT6Daz7L4QFsLPp +I+/qhqcZf9vn4s3+/Mc5TTdzB3tw9zxIPgHf2AqcqzguxMdCsT8BeRlGF0+573nXyGM0Fg5y68Ga +s5ID4XvLzlJjV660zLZFSz7mffsyEtbnTBjMS+3DueGNXxAHD7KaYQ79z0B+2MwHOM0owPwBDYfi +GAWsmQjJRwTFVKCP7MPGwphLND/o/zrT66ShRvSt314oDF+5smGCcd1jYPd+YqVqsR6Mdt6HYCwk +QZuIgNVobVHGpmD2gZlnAwi++LH6YNT4rSm1KBDpOfIvjgiQOocTyFDzkB8ligDU++PWFHnPf5oi +0zbwkUHPijAu7/5JN2ejI+zjfyfYEkgvPHNIX0VVKQd9Dp0zjgoUQsJKOX4rLoXbyhXzUOlzsIZ/ +QzUT1zDyIUjULrLlZfBwyLMy3EarALPNqbzzIz8lnH67VUBdQWeobgcj0dke4HF+PdqMJSrfWoXa +dHLeejUkx1Ra7TmmJrnacidC8UHBg3ifyf1asvPwkNfzfFb6IZfkzcfUGWzPkcDqQ+rGb2EaOXiU +a+bOoIOJGc3Py9XBE3S7bfP8mgGZEr70cik8Vjt2XsHH3SQsvLIWZnNSV9nC3jPPdCjLk/+LZJ6l +IxHohxzJ1tCDeRwvLkdydvTBT15//C3qYx+8sZ/Qg5gv2TxmgNVYWBSN9acBdPcS7FOv46kenBls +vuKTweWx1HVmgyOxiBtsrx8Rg3M2B4/6E7fBcYo2DM6XTs7gwl68mOepa0XoA4as7c1/8B6AsRLI +LfzJaj/hy4R9YaCaVh8o1ol0CPcUK/bIrM683yeehmnn9rWceo4cEuFivO0mNh/+Vn7/9YHlPohu +k3hKP41wYFWuaSw+02VDgx4FGtx+7zc4Wz8lgyvsChscI3cDjioMf8sbnL1xwGCbL5YG2zEzh0Oz +8Yfmd9Yxj79RZzFTA6fH0jcvdWbYckvPxlPXT5E1szm8Up/oFysH0I0cQNBZhMRNYDf3X4NPv9tX +CZ8ciYLhkSOq23MIF3Rm76nbH4IfCkts/NjN8cHGDp39ty33Ajsq6B4gNXjX8eF/8Ebt4DUckbLK +Q/r9DgxqFqnOLEIbePMt9nJI+/vv3fFdBml2GKwPXF4ppGD2D+E2LjfWoj9iTi+kkcYfHg8W02Yr +hXR/6rtN1qGp/oWQUvPCQ4sRWDIugzRoNIVjk4g0Un/3CyOamTcppDrz4YHYRs3V+UtdaqxYwbip +yCK1lCv+Fznyvu+/Rt4yRAo9vTMCP7R95sDRAl70b85mNWpK0EhrFotoTv3NUGGJkALhGuY5pFAq +Y4fv/XdriHjedo402gu8j6ceSaQ/ruarLNKQZ9KwIKQ6swgtmFUgooeo4yCNtBb68XdmFacU0oMl +0cWlkOrMAG1gZrNkyILUWOGsdjEigr1KIn0gpiFTfeWtSiHFiO9vAiGFOlk81qDRvFi/ZOWQDrCC +s9+SRlrA0hbSGuqKkNJ6bH80OpP0WLsuq0hokq/+py8Kaf5rQQiQfsSxSsiFQ6T2M6RFcoMkVWcG +aENb8Vgrnx8DGaRBY2gxJn7kkOawF/t3RIQUYKHQlnbR1O/+tS6JtBGz+GSRPpMNHyaD9NOFNXq2 +B4BFcqzPRfL188NmlUTasqynskgbszda+3JIIRYabQFrPW/j0kgrPvM7kYo/SSPdlh9kkbZ6hYcj +Wvclx1rF2snnnDTSl0S+9/P2/S2J9Lu6KImQIiw02t9uYEzIIP0KY9+HpUsa6evvdlWNhH2SSHsl +F9DJsmPdmxsOgwzS7juWn6/KkkjDr64HQ+rblQdIozuEFKxinFY69UI9GunQZxMJje2jMrAjpF5L +wloUjrSC9e3RNETqPFtper87nfkRL/eaAO3TXqwKD5vHJxrpMekQjdQAFnobhTTTxUtCRejcH94T +BojUjZCi6hpOK5VczFizRxFSR6z4EKSQJvFnlwBpYObc+l/7CKnPFM0+C5GaoOYfDNcQLSYe6z5N +bhj+LRvE+jfwG83QSKNvbhF5HzZkv0ktb+SgFxRZF4Hi++PPJso9Fz3tvuGrltzTGbS9TlJPac0P +VG/uUeZtMAePjqyZfvpLhkRPg2G8x/T7sAiLn65nDx2dWfZ5qFaKfsk+DXvt9b7809ngx8I9FVEs +aEx7Hz9Gsm9XHOukV/7psDqJST1FFAsaqw+jYVHm7XDxsRh/P1BPJ5ZdRAT73TGP/dJP8Yeo+Omw +3FgzFJN43so5GCtT4mnbPPQY5J9+5aJP3NMzivXNPyGT7Nu/x9q2KPt00fJm3qSe0hRbLYjEj9zb +YLhvsYDs07LXn+jIPh2th42KPMUeDY+lL7vs03z6ZUjKPi17kw+4PMXSBq/JFpV5O1DE8k92ZsxR +a0z01NF8OyTpp1l3XCyVxWa/YE9LPUcyazclGXNY6mnyI1XlPwWuGc8zzLrsWWjDWD6znHPGd82I +XkDBNfMeTdDzzRpc5UgXeL6/TfjHDX8jDM5cPQv/tIGqi5igNU47g5SGofEN6hlGb+4fvJanmote +DXAzf4VIGH1QxMsrytkBrhlPmjwv4bUFuJGdE9TJwN0BGCdxFp/RM38a2oBue8hDd8clUNZ8pI64 +d/omgzRoNL5vl5/8dZ9DC5fbD1mkYAn6xWWRYsTktSGFlJYXuGCOpMYKkY75SP0NEw9p+DXT4CEd +Pz4aOaQH44ys89Z9n4jAiZ1p9ckgLSwFSG1dWaSAvE9eKaS0NY58B3asPhGBoe/wI4O0+y0/0gfi +4Bes+8KxIt9BFin0HWbSSOMGtxRS5IshtBWLLIGRRSKLFNojTcGckhEGPfpEzz4wtrIf45VyS6rd +z2m1Vm0XNO5+8p0qX8PItAzMaL6j9UUGjPkr7eBFpDjB7VtXwmgPUP/EaY+UCyBLI0XrZO5FuE/p +5P4kttZxk3b1UbwKEDWxtcW3vPgRBJCIFE2/qA+JSOEzB9TWIA8x+xiPj9eBRN5M/3G+bGgEyIBm +EHC9AUN72lJNBJEypPQynhmZM7N/6kLPgg55VdnmOYilwB9uv5xkuvxeA18foTN3sjPUoWx+UaDu +DfnIjzwSiiiPlQNmM/oDWbKt1qVFpCTVJZ2Z7lTvZAGs++L0WpJYiYvYiAKViOje71PmmSO6NMnh +H7rr/g0VUxKPEMYADBrGh/6ozl8DeK/qM2hkx2eXHR80fN9l5w964tpmEM7fRsShqsSiQUHr4hwY +bs/8EmrAtDB7zMWu+zdzVuFrp0x3nXbKA9Po40rJEco+IJY38xEpX0ksoeqxcaqHXvdBf37ywqn1 +XTsb+a/Snk9AAI/xxAWs+4iUjwztfvIseWV648w7qT807ZhI7znXdl1CqeSrbWmpRLE8yaF1RVLJ +zsYlQ/MlW80XZULDeSk8P8J+12W6knNoGRVZcz/Ss3/G7HmEpbW5eUDQFezw+sAKoVDD9G2PoHud +nMw0Obf4wGQpqnGgDFkgFpowmCxhPLON44nhHZaTUUBImsa4CBQbh9EGTCh39vMlf0BISR2KKF4q +d4OHzklxJo248x13wj+f9Fjo3YYzxgCa0Zp/lp1QZjrhHzCdXBD7nDcGBMAi0oJ8YNU3tlO8noGx +HAuS/UoUhgepQaK85EMKI4/vnjMrTGFKHOdTMi7IrnE6s6zykebpRfggaxDIWozsWimYX2DNfB4V +Fybx/MrNbgFSpCi0YEULk2braVwQ6mnxsqSjWJdbeBU6dUyWZbpUrdO9kekSP3ZBdUrepGOnTtP8 +RUwim//MsFC2+QXzt1Y26Kj5g6cDaJjBQm11CzPwVmQIrLG+F2cJlhNKj90ArKvsxFxGMRW77jKK +9fZ3oxhfo11Bsa0gESG0P3NcjwmxEuKvYpdYx8VLXMG6jB7LdGYGrY6NtFQekw93k8pMZ2fS4ChT +Nn/dwdvNlaBOEn+uaKWOVG90Zm+m+/B4I3USB3ZZltXJnE0hbRoW1ZWCSkcgFtAV7Q== + + Lp58RxS0gM6slSZC2/KyjlDWRVFd7EWeoUNm1ZwWYej6U8QqnC8m5RtSm5pckLvOQfR+H4ZuXjgb +fCpBjs8rRkjECKhUgzPaAUtQS1CDpzygeNCZKsK5LCHD4wJ/WL5LRjV/X7MC+D6aVeIsPB5TVgCl +SxSAeHwCfx+M0HI50aVJLrAUJNcXEdfK2fK/Jbgh2NYwPp1ZdQZzRzz/fShoj2ec++S0xwe4f+a7 +G7HOBFwydqGJWBIiLssMiJMFxBKKuM8UWXiEIl4Wi7ikkyaILslESADXPtwaSyhzIVluz0LYH81O +xaostN9lIySCoKzc0Cy3DI3S/GWY1fCi6g8rhTeSePkkXJZ9wrVSNcCBugz4YOe9ckA8Ti6frapX +xH1WZbgx3BWRRWIVUyWMWqxPpAqAPy9tW0LqBDVQh6cKBJEGoSmdOlH5Y3xjGvCBlmCiuin9zJnS +cvKigXbRN7Nyb7hlkIlbyi2EvuR7yKLOESrLICUvz+KF8Kqh2WSHpjNr1ErPZ47yBXzOcfL2Wbzy +XTUgg3DJk431KSqA5Ls5cLkCEGRB04TpicP0V9mygDbsQqfIydpsWbhZZeFnb8BRgd9sIo/vWrnL +gt64tUS8GY9PetSdhngL8rrVDlnjANi94q0Q1LnoXaqTodBo2KQQcaowO52ZN9lFTyvHIyicG8lk +d1wJR0ICpaBQFqwCnBt2KjgowN+/eOWTBSbcH5S1LjTtVMByAqdVaG9mUYqrrOTQu6Ia415ZlLp6 ++XIj6VdCYF73hXt8sqT8Je0wDiNDTJltbkWNdljYzjTaYeHQqazdWjUaIExqpzIv6tZc5/0WjSaK +wANgd9No75xGu95SgnFprRpNUfbBvN1Bo6HZF4bGroWjrNF02uHcvveK4CjsBzkzVnYfxyMpOcIJ +E3nQaB+ZtynE2zqUtlLoRC8mCxF4PGexcfibcAP26pwruAmuSQlBywxa49ImaxbIeVVZM2pWsoDH +8l8tw81WPdOv7oP83qtGp7HTutKXFs4LnDdRWtM1SgFCERj2/IjiZXAUUyBEUOQyVRCcc5f6mt5E +rR+KO7yKJrkYmFIgSyp/TGk1BONziFdD8JtLWXJ02lfDwUNdMkXgIo+v076PfU+BEq6FsjymZTVs +a3WtdWYlFvnaXW7fn+k7MGs68+2rIYSjvBZqW8UQHI32vdIqhuDcbN9DKFJrIevvX7Yafu2UxPBs +LaQiV4qrYe98pxj+dkkSIJwX2dUwatWYh8WlYUiPHmWp9fYKU8InpYwtwJehjpRsC31k7dLducjS +peZFVro7mqRbVW3TFNMk4urOJZhJt5SUy2Wpydg1gJ4tjzaOUI/0ok5p5Ahp4RIuSzBLLet2nS1M +Wbd8ly9y0ryZDryLS25h0pK5JuyX/C4A9PguEC+UgXK/bFsITH33RsveDQSlM/tMsefKHZg46w5p +iifL7Q0I57KnxdKnQMn6yF3F5FsBR2jqkle0J35h4isluNx6lgi8rCU9C1b2Ub3cYWpwrd961CEq +rrTvB1bO5bXW0LHTKVlBh04JuEMNnXIFnc58nxq6M6SCCjpKW95eQ6dcQQerBe9RQ0fJmlwFHe1Z +3FxDp1xBR1cL3lxDJ4mUraCTqha8poZOuYKOObvj1ho65Qo6rvbttho65Qo6qMfuUUMnVlHCfGjp +/crLa+jOlzJ+OjKKkMhVAtUshJoHzffZ5OuAIBblZBdBpxS6pJQ/paNNQ00VU8RBMelJPsQk3knM +ie1fVTrJWb+fOW6tZ3IVrqSTKMR0nt5OUUmnXoYXswsYViLP7GloVS4FQ3t8sAzvl2zdh5+k8rDE +/otGPoi5Lhofb//lvNhNGLmSI7p6lzyinZFriE53SS1ypdQp2aI5BoR6yRziMXWGzYvzqi+O+iFP +3HnUmgyinAoiGzQWR3o1hI3zl6eCSNSKdl3Gm4vdJDIhryt2uyQVRLYm0bm9JVTF1qd5FGz+Cwgj +nwrCc0N0GnyjvGyFlkafZivMIujj53s2Q+9Ojc+16eQBcbnbKz2dQ59kAiUTUbyoyHTw8CKuOlQO +nKHZl/PtAbEU9rI1BM6YsCGzIicW4a0oTALefr9TOQx1kp6c2aVWByaqApM1uq6o4zuprUgX1PEN +letfjIKglXxp2oNCDryG4ygEXZoZ5bqU4tVYaSpoUsmBvyCLYFwQRjAlzEHN87fnIpiytuUFwNR8 +jDw6p1cbMLUSGaV+CXdFITA1R0P7ILnw6h0oplwmeiHF1I5CUKGYqHom0+m6hKlORdnqGa22LFOb +AKO+GoVdco1XrpZjT6JQAbF4UOlD3/uDwz99Kdnm5Y0X7+bsTYvCwK7UWTessycLQk09nAEQaZhp +UflwFP5MX1AoJ64ZUZ+hHqbV45GTfVjipjXIIEdPKRdOzq+UJ4daaazUnoyEzQ8GpCrngmiAQip/ +FJ0pXBfVWOWOl7iZ8pU+IrorcbJK+ZFyeZxA67BnDkvVtB2Osuv5RfZYCY7lThL/WxJJvJQ9po1O +GsM7IkP7LD8ZVo557sMCnFPI1lZr65REl7wausTLHFaqQLsoIqNYYee/E51U616VOiWMyLjPIzKr +smxERobHZCIy5SsjMkINgz+b7hOR8Zmi7kctsQsNEZnyPTKIAAjrHUoGC7XVzecpgTlXj8jotJSh +3RyRgbvVkZ3/HoRRKM45q3lXSnaBRXpCkdOYUsKsyKI61GTziAmN5We1OlQlY5l/EoUv+e4w3sgM +22epkI4wU0Wj1wIWGU2lo2xIR2FFBkOLWm8eGjJ3ebJ/BYfC8jH56BI3IJ16Xd3N54Ztn2HWzQVp +s3LTZFDO1tOUPQgJc0vpKN9LelYMgqoW14kT9Wq8fVSWk+Gv6psPV9bDXX5e3zX1cLJ7SXeth4NY +bi1GVa+H01hncWM9HFtnIaiIu7p6RKYe7sKK1Cvr4aSrBe9dD6euLe9RD8dafdeXamioh9N8DslN +9XAS8/JL2u9dDyc8oZ2pHbp5W4euY7u9sh4ub1o3h7jdarmQJQR2a04kp/lbG005kWoVXz4pap/v +WCmZAdnzBImrqtERHOetZnNWlM6gUCeuDuculVwwl0HWb77oLFJoj8HiOvmA2KUZz9DysouEkLLH +VCZCoxi2ZD1o4QlUqrVMV+7RSkQUIbB7pSZ3t0gIb7PGIbW1eIsq1nj2LqcBU9WCOZVCLC3iA6DI +i4/mszuyXH7D5b3hWbBZ5SOBL8r8Fh0JLH324AVHzNic5zEsWHomcKgl6sW05VLB+J9mAirpsYuP +FlaqSB089CTLSK+oSB08DCUDBpdVpLbvU5H6tbtHRSqEco+KVFgvdo+KVAjn9opUCEVckSp3DLR6 +/Vb7zL8WJCxAbamaZiQUQ5eEGHaU41ras21vKYWTWsXuXwonOy93LYXjzoHX4rhfWwonTbF7l8Jp +9CtvLIXTae7ULaVwZxkRV5bCKRuGvNrqrtLmymUnwmdFCRLinZHL6+ok3SLRjo3OrGHPBgLTdFKX +XE6g4JRmAOym8CSfYoIjhuX3ktQ3F1AJm5bz1Yz0fqXM8jA8KG3haF8cqNO0umdnfV+ag8qPAM2o +O+Oc0jkk9BygCzIT1Vlh2Rr0csbxKU9ETKkfopmo5VOeoyVLNJOhLrrOPPeR36fSxWCznM24R9ls +xvMMLyFobJnFyLwUx2DpmJOwGkuh7ixu+JS/uS38Fq0JI4rCYrfYqPrCDz/zkAZmdnPcsJErduso +VNgdHoixhy8gomK3Zka+wg5eqj2QQ9pXrLAruCI8pOL7zKKOA4tUXOwGr5pmbzXkF4BR9/FZlYrd +cLcsUkc8tpKrsAsajbvg6Uu2wq77qVR3tlKqsNs0m1JImfv4KuRsLFdhRyrVEr515JHmXz8LPF9M +TGDT2hfrySF9O2MlIK40evSJ5vOoxOxLt4xpguj/qii3g1joesca1ZJeOitBCVOUEVzitBQvp0pn +qaV42bYaj/13rM/S5GuPG+WcDZ3mOhpNh7jzoiZK91jtlDuluUvC49xVc64uvklOyvql1sp73iQn +tSBS+8gqh65rpZNsiuRl+TA5DTeOCAxMxXvfrrxETgoUYk2BDXMtH6heNgJtmPMRSnZK5a4BpS7x +1v3cpcmUCl0SRY5vkJcCqXINEZfsyq+AuE81nVQPxbsJt1fTSdXSnd2ZcnM1nVTAi7mL837VdFK1 +dJpOnryomk5+v/Ke1XRy2vK+1XQ3Ra01V9NJOR8SnHxjNZ3ASKBr6YSyf49qOqlaOikNc1s1nZTf +rLt7NZ1ULR2793q3ajraMBTU0jHZtverppOqpePiMPeqppOaXRS1vms1nfSu6L2r6aS6pOP15z7V +dFLzJ3my8U3VdFK1dMqW0jXVdFKgdBcCU6+m07jDe2M1nRgU5Ph7UUzZJryQYhqq6bRT7JZqOqla +Omr37Z7VdFK1dNI35d1STScF4Lxm5NZqOh5Z2N0SuZqR66vppGxnnfhAspur6aRq6VTuFb2imk5q +hhTO6L6ymo4/XKaWTptfKUsOjeU38jvv11bTSQ1IfKb9RdV0wi4pOIAKFalCB1Bix/W3pPXoJhUv +qaR2TaW2WixAse/DTk3Y+eRXu69O2rq49311mu9NUL2vTmvN2tFhEebBXkun3FHZsDg/UUfhKjdh +gcKlXWJsfi1X1Wkt7zy/gla+UliFTqoWgOiUM4VOyadSXNYlKC/K8U8plSn0iJJ4+SAKlftMka1o +3T/PP9ISBrvkmjt5nVy+28Hgq7KYYlfnIypec6c5dnHTNXesvChddKe5TEnumrvL8pOvveZOdEqA +9EV3l4XdJK65U79pQiZN4aJr7pi1UvGiO/Hmkfo1d1rPhds+3xyZ8yXfcbNwfbk6AfFZQ2WRTqPR +vX2+JQ+f5mQwuCfbzYV0spmHF+Rao0K664qKRFWc5psrYJ+lUjgur0qDd9NFrR9qgitIIpO7IxVQ +R1MRjLZ6IsRjRou4oggemqqcaKtpv6dQW4n9lysLxFSywS/IhgLANOUia8qGAsC0ZHQr55cjzXeX +ysdL75hkeUwM5+aaWgSFXvLktaVGOPJJVBfdk3iPiyaZexLvWljbECdNoHsTGut7nQoIQUnYdxL1 +lVoqTkBvtSgz4U0Tspl7TY2k5DuSEiYEF7my2c89eliLd/3ZAOLqpztUpojPPZY4V0FzKQMAVlGu +irjgBkPwqKZhk1jtBj/Wfr+t8lFrIYPyHUMQzq235kIo9zglgLpOTsmI57LT1eEIxfCSS+nO70lU +LGW4uJDBQc++UAxb9xFD0Q1319dXXnLDHY1FXgzvcsMdtWchf8fdJWIof8PdhZWPV9YTSdyUd7sY +nt1wd8NNeRf40oo35cmL4YU33FG3/8ifFK4CTFw9IXPDnVrWjcbC2rZyepNWPfa1u8XMOat9u1th +7ddOfAvAlbevab4lXbny8eUOdekAivv2nCsER8WH0mmFc5P7xGjLs+Saq+vbqevylA== + + chQvr2+PWp1nYhi1iiuTJfL6NIlh56IiJskonLAi7EfWmNRcxMTeYBi1yl8PdtF2EwQljuacUUzr +0eYQmBaplI9bCim21nB0nCa/sqO1jEmpiKm3l11nEZbLalw7lxcxodpqedNQ4rhEVCp1oWEodx9f +1n17nh1DSnjv2/1qXLuyOzasPaa9xrV7+dFU8udcde9z3SNzU96dalyzbo/sBo7OfAZMrsb1LA1D +liPOunR+BhHs1B2ue6QjQHAaKiE4FikiMKYfrHgrPjVzCzyb8ZTbOSNZbuSSjkbzadN3BMGnQo2q +7et8EWOvJfGQoxYeFNjlU4z5LCjDe03W+UgF9XAHY6tb44eqhPewRbOfXVE9HK8uSb4Mb3/qR3FZ +pBiB2eUq/4JGU6hu++Z7r8KCrS/5gsMHYuuTR1owfryLkCLNz9zDVhq6p3L3sNkUStNqAfl6uIMl +9Ljn5Vr7RFWONmvycylTmmZTvHFuIK78QxmqLIGf4zUZpEGj2f+a68vVw/UUkBZMQYG8iC+6ezN+ +yCANFwWllWKkdRFSKu+C5d/nljzSfP6dEM6qCT51sp/oEsyT/ckjakdR7LylL4tpgIj17dG0hnaA +YtHNMc8tk2DUXb84a4HdrpFYOrMK7hPvZDCNiZOAqAGbcDcopzVtUsMtZk/KpU1nERKJ6h/K5s9d +mFol36WsZF4b7+QWraVNh8tzyaVtmLOArrbUKskqKbiua8yEVKFTQyUBTXtVmobUKq1VaSo5mlr4 +iQHF3/JSyelVq7rTmKXFeBYKnTrL07q8S6iK83FzUZ6WUpeko8RXyMtGIUuL7o3ETRMidZX/StiF +6ip/c4yZ9l4B7JKGDUOVujJZ7Xzx3U9dl0oqjJT7K6Nh7hBe/slzdv7V8bGLDoyTj4/l77Fl/ZNH +kWXFM4g0VWxuNRxCq9NAmGu9FilOzml0irUkjYg3WOk77O5yDDRxRx95QFweDJaL88OCOwU766JA +wIA4j/NfevKQMKbi352durAI79VvL9VcSNZROuVM/YwIQSmgmt0mObtSmSrjgmp9u9ZKpoiBqxbU +cs6BfHWb0smoGqxxQafkk/U1FALyo6OAogvTnUo5hXuKaJfn6lJA9UuvKFC8W2aUgCnfa6zaL64i +FQI7v9n42kGe7VfeBEytlucSiqnsXF5GMZWdy4sGWfF/yVLsrFxY1pm96EY93vpyRRWg1hpAgVRe +XAV43gfpGkCBNX5xFaDCzrO2eLKmKkCtNYCqN7DLgbjoRj3JbCjNVYBaawClz+nVWgWolZ5Sa6X2 +KkCtNYAafGSFKkCtNYAqu2/KVYApqjfnoxJfykflKAoKD/6BS/lUOVmlakvbpXxqJ1Hc51I+SsOU +/uFL+UT3Jf1Dl/LJ3I9850v5LonCXX8pn/gstX/mUj7BKvaPXconaSlppVNQwXZGvVE/G+qye/0u +Oxvq2nv9+Crq/Fa/q8+GEt3rp5y8qFL1rPleP8WhWW/PUyrf52woTff6qZ4NdZd7/ZRv9bugvvKG +WgiJmsSr7vWTMti5W/1Et5jdIWlY6la/ayq5Ls9WlK/kuuxeP+Vb/W6+v5K+1++2uKXWe/2Uq+4Q +ljvc66ecr68tQ1X9Xj+t9ZW33esnkIezihlJTr7iXj+ucE9qoVOyxy651095JuWq0u5U7k7f6qch +zq/pXj/l1U5rFrTavX7a7+O7ueZd9la/q+7ju3jJk76P7xYJ5KBwultxx+qCe/3UteU97vVTLk+h +IvC33+unnFTAv8kIu+FevzNSCm71U5wX3k6N2r1+yrf6SVcMXX6vn7I5qFaVdp/yTnqtvFvdg/St +fhfLvsy9fspmgOR9fFfc6ycBxak2+5ff66cMReU+Ps33+inf6qewx3dZ3QOpdKsf0mN3uNdP+VY/ +nfkSMZS/1+/CqrS7VVnzb/XTqsfU7vW7zRrXeq+flvv4br/XT/lWv8vu47tWfMT38V17r58QiviY +P+nKlMvv9ZMKpl10oo6me/2UHWp0rvUd7vVTvtVPxXvVXgyveKsf7+bim+71u+jUpqvv9ROVI4r2 +s66/j++SaJbifXy3F8PTt/rdmnPF3OsnE86mE2roTJWb7/XTcnb67ff6Kce1hHdyXX+vn1T5GOdr +SaxiV93rp+y2U5nDt9/rp+y2i6Xy2nv9pCimMRPygnv9NPqVN97rpyl78OZ7/c4MQ8GtfiyWG+/1 +YydW8lY/3mnzN93rp1wQq1NzdjXe66e8Y8Oj2E33+gn7JQ5OXm3DiO71U95cUDkdSPO9fsq3+lHn +9tx+rx/TJemCWGpP/PKzUjwSi8OH7OJA1fC+aznENFGYnZ2oiH6T38NkEu/P70mUKFwU8RNFEy6G +lXja8nQubbLRqKzCVazv3nCEwTxVMshO8qvAF60c9nvvYWYAy0rZ4Ph8NWGeziJENYH1VAbTS6Lk +xqxrg2f0ufX79rMyASi2/I68vdutrpXNktllsOL0NW3cnTJBw9dg7AOf+ilTOHbKP75Ud/XAbtH9 +DAXc/lH4hei4n917Q6BS8Pcz9cV7ctx4CbZnTfI1sGtZyYmpnbb5c78PzfqzzryILuOdDZm0rne9 +0M68T62Dr4b2a9Ji8lkLQfPks1SynWbGT//mi4yiqUWVnYn3ZqNlcDt+UgbvdNdyxH2WFEZknjMY +MRmVsULwsb7f9yPW/SHcBvJyMP4Eh4fA8LPGlgI2HU8eV9vtq0QemLK3X8/+8LWBl81FjNK7voLq +0thHpRdJj962UE02tuy8wPskT33cbE+nKmUpYiFygOEeH/d7n8mgONKZdWAha8bWRzNhWu89YF4e +vf7pybgcG8awlrTMFIcaTs6t/xXmq72sUU2iIU00m2bMRI7Bb7WN0GDfisQHDK2W5SKrdDyZWit5 +91sCtSZFiUTQnD3lPgiyg67PzH4X6p3ga3b8kPIc4+WU5zCOERHjopZvp3w/gGzrRGHZ6nzpzOli +0DAEcFo7Bix1gaYVdyxCsJix+5OKVQx7NKr0alM5pJ/b7Z4j3+oU4Scw3NrSDYt2nZRTnwh098hz +wjxHK8xF6B0ZH9kTcFuYT7gVxY4BTUJr8DVkR3W/QOGUtuDrkxN9BavY5x58zbqZ1wgPkfe+hAHY +IubIOc0nwloslXCnZdbTmZmOPtv4jyLHAfvAwX9QcYzYBy7+g58QyT7w8B9ss1MeFpz3qJDZwfqC +Vzv/t3frkGn86uQ/mPrH7AM3ut8QL5pSGFwSTHjRRfjQuv+KA120WeDFZN0Hvr7xYQ+nDkjbNyfV +ZGQKRWntBVQhZK8MPnI94bCJB1YtrfBRsgTJ9kYDHb29U1jeYFFr3Ajp7YDVxWhhMnltLj+0/ps8 +wnhtyVQMYonBDe96Zume2tO10aSSey4ZGhxDspsCWV6uAt97ZUQg47UVifjlEKXgUf4LgPhWeWIh +ZgLHmoksfH+Ep+nGyTTPf4xrGBwVzvGv9/v0k8rOBx4c83R/fAx7Nf28geeSIYpVEMXaLkRCb+4t +C9fAtodh/DaAPfyGd7O1cdrqDbTRarCBn3zsJz8FIB9bBcHXDxpeb0TAef7wsDVWgQ+M/cTjNpgW +O2cY6MPHf5BbmPKjxS6CeRa/AWYsH/TlmpjNFMa8y4Y574zYfiAnYy0TP1jTt9J7qtSAuD906I+O +1iUC324Oqe/RVoVE/QZ/um0r/ISzn6B1wWv5MvXDX/0S/Xkj+q1uNucI2wgi/9IK02vqcRXAyGE0 +CPnT7TPF432iZ/v8EC3fgjtTqAWcXvIzwK5z5GkDhdG1vGVinwxZoo8brz/fzuxaQFvac45IwB9n +9OY2CR68lHOnQa0KsEQCT0kiYqqPs99lYzGxM60q4qML6Akrr2idBfpLCfbgoWxDYsY0ae0gY7sh +jSGxvg7wKZx9hjm/wA+hPdKWqMIZlSILtGXDj2BDZ2dHT3wg5UKF5jAdHdhjzhatjslaKE4Zy5P3 +6KfwJAo2tDv5SX2JZx8+gBrWI6FaHZRWZTr8TSvwRNYFe2hFd0AMF5nlw5oQ6lXALKFWMdtfpMfA +Dd1maAksRG1wcl6QoQaoE8Yp2gFdGgazO61SuhSpMKBGA0iDwrEgRWlKeXLl+AYDcKoY7IDNZ4pN +0wzsdy/8DdLOISolz/Ij/mAF5Fl1mNUd49nJEnbdMWiwvX5EDI6ROwX/ZAxOL/FKfbXFX6MGZ+un +ZHB5LHWD4+3hET5tGFxpXwL+GRucL52iwbbfOw1OQx+dRNFZtFhD4JEKHJK1JwdcjOkzBPJfxI41 +IZGqS+UH/fwitd55+qmWpd5NN2O/1lzpM1gGms/6kIonCTdrLuzoyBUyHTwz88YpdD80I83Oicc9 +wNfZpTbFfZfoOYvGdHUar6SbOb9JZ85N3g51JGgHw7clh43N69x+//RhROaENzeqJq/D/JabPG6N +UV82N9SZwdBHPeUBC4a73gOIDb/YC4Q8BLeILdQ5B/RRDy9rKHouZv8F6SzskFtnqrXUN5ELBPqX +Yv6KyGJmzrsQ4uZry1HPnop9zXo5d72/z06e1kMR0ZVJ7kvvDTnxPVb/PI8l3nv2vMgrpbVlAd3f +Xl7Rh2cQPd517r5M2BcOGqOVeiqaJ+eZhdX6li/W5nhql/akc6XVHPjIRG6JZ2hZ9OfmYAGrH6FU +Wtz+Ynp1+UxLURtw8mX0TkbfKMcmcXo0aB24znzR0FUHLs1oKAKvfehXDhzKSyzxyDn4mGewc4n7 +o1WN2i3GuMG521agGq1AN/oZPHABewyqz4bBaUsBXWvPOA2usOvHYJsvgXJdv33BtzHYPAk7ZRIY +CdpYAIq6zny9sGtnPnTLjAh3i0y1np9KRO/YNOT7wepMs7BfrWHuotsEGRHaSa19uJDRajozmNXw +iYqg2KeHs2KoSyZZdszAThaMGiizlimnVdq0yhq0xm9U6xqUOtoTv3AVv3wNZ84cvvOCIjJZrl7F +Lhou1JZXkfqi4erMEgOWYLSM5ZYxAx5THzWSLLFc3cxjPHvtKmuNJ1xb5Dnx7+SSCohlM27MC1y3 +7mvaucVS6dHbK5FLOgLltHMTteQ+iON3uhjsv6YmzW0sv/8eVgPL4Y8J+Xkpz/5oyvRfvQ1gXUSM +gQTn8cVO04Qz4/bvW15L0l4QxcyYA7486KgsNwq8MO5hH3jiQeMh75h/zNLNVnsfIyP7BRi9YaYz +h3bFeiU/GFjc+Y/xwwxRnjcH5s13FloIXuDM4iXBmLViNgFrHFgSuy84B4D82Z8vbebE4ZU+x0wb +Uri+8NC2vTm3O94GGv0bT8XKi/oFSIH1xDMhBNYTlUF0k+GowXo6r679J5YynfncftJOb63UBhbs +DTbj3S2lmxZRnfk+9oOy9UBHFe5tLIswAwv2Yg17mycOQ141nmsGY1g3TjxNd6AtNVFejP7zojFT +uQqXryro4M8yI2ZPdTHJYRgIHY9wlnchCBdOQ9Hv2ksELB7BFPgTz4CFwviKvsbjrg== + + YxysIIUKWHgalZTnmHxOFwPvbrDctBrgK0ZEHze5aM44DmL/yPoirQCA5teqcC9xV0XqVme+SuFe +iFlnllb122w2s7Csv3LukOXALa0aFtb/2fWFv7KdVQxpD4lcMFykYbamfzgYI7G+ALXuWrvCS3FI +RG5R18RjsWdT7itXKDwtgF7x7S6aaa0mFOUjX7a+Xs7idG7PfcJgspiRj3ybYGvgNp35IvG6crgX +6LGbeOwi8bpSuOT0mNZJ1iZcF/LYlcIFNIyEeMGNuS4/p0yYkopo58zVvTCk92pwfFhTBsfSTxic +vXEZfrUYnLPfbxjBe4X7JjGAxRV2VQ22/iQMt1TysKXP4CpHuncM/Qni/HeJtksZNzCz675xinvG ++S9z1s/i/Dd6qlf6yPewot+gnXyJRXmdEwMpdofwqwr6q2KwF3M8Gx+TsKjv58TozEpbDrdjpjhe +Z76TK/EPxmDVvTcmPgaEylq8Jj623u6JZtLfQQ4JEXk4hZCvIuWpAH//al/FYs3ODZ82DYsMkBf6 +M50p6IjPg206u6MzOF7B57iFPGZnoW9SJQbLhSJ3DjqvL7BqfzYfG9cxWhr6yIulnUgvB78aNDr6 +BOA4iIMhSbau30uSGLDW4XYMG0/z2lUsfeVw96d+JXS9Hrt4uHRM6eb5VR4uzIG/x/wqDxf6YveY +X+Xhwhtz7jG/V8X6bmBnqdnVvGN17XDR7F4fT75kuMDjk51fOsa1NvL35fmZ9o+CBcO64vcVZc1z +N3/RR6fQL9oFL/p3XAYV0tNndaFnqZ2v/Gz4/E8A2TU6M/Tp3vg3qdC59C6e6fc4Cj/zOop+Mxyt +B9YprJ0B8NsLyFxC0wSxPG0EI0Arbdz1wq20Xmuk6+PGTyV4mzMm1vIePZ4ByHh4AADFiE4B5zIT +wdDdK8htVjRXnnniHSYq1jaeuTOaQK4Z81trx/zW3Xvm1bWDzYSEpx+9PnNrL6pMgaP22+ClQhED +vWDGVnVolxuYK44iRupBbPn+yp9k4kS7lKf+k9fB3uljT7XtA0ZwcZRxBzp6ft0PcxULmgNfqLqg +s/29J5y3fMdG1RdYLvEAe9MV3n1k41MMsm6eyq/fZ7qfLE/PrENT/QsfPPgLqD8C5sO3LAl++CTw +Tt9YEnxwJABjgf3hE2ER3jJESPl4RDDHDX2GCH4PRwLYm4X4AF8hCRAnC4iQjC7WDBHsZiERXCwR +aKR0iQGaEgUScJUpT0eG+08GjggG/+HzUQsfJKO1I83YGdszS4Lit/vh9x3JPiKC2yXLB7Du18JQ +MYrLsJICAGhd/JLWW0DQZ6ooAQDzogyCOg9CVSIUAOAPDsZLunIY1F2cqgAUpJKuXrxlGBW/m9GW +1w7jPeqRZSoRAGoVOwfxk8K0gpDUTk7LzMrJNndXmnbpxp3Y2naRetCZz0BEjvZbNAzuzJodIgA0 +xbTOBqx/cUr2gQ+A3wcEgL8vBksPXWqzMYi/ciB8n0s8zAfwE3JLMbbOrH0Y0yfPlcJFR0dhXQ+m +SgkF2cBdphJOGXwPhWKGARA02j/3vp2AYoXMzka3JH5xrqXg+jrYrvKgziD8UenM4k4V3q2OW7QO +XvhxixmE4TGtbFqY+lUZ5LwPQopto5IsonkYsCpAipSAx7QOo+girtU6DI8VgxX8JokvJute1RV5 +n/DgLIii/+h+j/NADH/MN2kdgGU4dThUKKHShy0urXXYPqD1RYkSI1PIdRNHjFxPbjZueZ3iGgWz +WrSOxIqMXK4AbkVGIlc7hNCHXYaRP5d09DooiyD7XY4Y6TqoQMrFVl9+eb8P4wNV5WdPf6VFuzxt +K6q94RXq5H+icboIpkqu6TqhzsLl7RXHTpSYTRX9fR9mqG7HjRxTX/L9AVV2WtCpEuhMSKMFHSUF ++uO3UTVI+a/UBnyNOqiKTctTfYd6S339PpBUKSfnsMA1fMrWAfG7CRbWPq++kl/vCNY7tpbymV9L +CZYgtpby2c1/MH2a8KqNuAdAWc84LK82upio8sCWib7yy0SBFmTLRF/5ZaJAMcGyt1cPU871ilGV +lkDUoYH1ymQQQbljYb85qEZADiCHvrlYm99EBWzBb266YjOYhXDeMHis/x4fFavoq5cu4Pz4xOkT +2zBPl3B4XhoLKE9NqjrKawtGWcI03VIFgGrlf4LyMJ2wALDpuRmiEB7GnNdHxTs8xkPc8R7bBxPv +/td06Htspcs7PxoGmn+7n15WIvoce3ltp/GCGXjbya/iLD7BNbzN1It5cx8lqrwMJjEH6E/Ldy/9 +6fT5QwVM8rZBj/7kncKSs3aArtj8SEGIH25409bG21tWqBpeb+9Ux3V0JW3f1pmxxZpefrFmbPzL +PvCzNXRD3lj6bUNWuT6WkX1Bhewj+0dcceszn0psEd63h5LzR+87VUboe4x9BuhPuQFbYvrtoynm +e2yt0uL+VLPNbyK3fBil680vS37oSrVh9V4c3URA10Aet0GqGJVSZkQvIIh/eR7pakFGlF7W9ItV +0k5R0fLUsNNV5sRpiTQVjDRgtKZq5weUcgFeJ5ySohXJEHQA4VliRTuFCp78pTN7c65PB6oyZ4vJ +XahwGpWaw3MqOmz5I3MUbIDwSJ/WEyhh8OSLN/qwJ+4EKsyT8CMtD8wXqzVK699EFA3DCnTy+BN1 +GRriUBU8U2XAyKClqxgThJtl8W+fKbJYUpWUUIVx9chAhUHZodYDoMfc9PgKKQdXS0nr6QLhghWZ +GK2nCxUPFhg+J2nthYoogxWWXV+ZiiGowpjinfR/J3QhL4bpw5GA1+3HwxF/wId7A3pP/bQk99X9 +fDpf6526mM6TLuH4+3q8IfYk2ST/OuY2o9OKXB/1Ub0n3ciWSuFAjhxtxqQe3S4W6Id4ERCKVeh8 +Af5pH4JEAqrOOzeJFBZFY/1pkJtg3YQ4zcDmKz6hAkydGWYExKlCI+dsPoPZBG6D4xRtwEKinMGF +vXipkJzEOSq8PI2P4Ooj7uoTm1Dbh435Kg9l9AIj6GmYdm5fy6nnyCERLsbbbmLz4W/l918fWO6D +6DaJp/TTCB1/oLkUlTszhH/WvKCG6hFWnPrhWFtwpDmDKRf2UOVR4LcyTKR4pVIqwIMkrwDVvjPu +oSUQFgamHbQWw+1ZPEazMNHrMQxS2zAS1AB23XQKI5StHX38w+LBTekSU2R1hHW0HqpWGYiolf70 +S8JTE4o2Jtd2YtnBnJSig/4atbpo6URfK34axOQ9emTKnUsYJyNA9I4RRtJCNu4B6r/OzDx6cvAe +DUzZJ+ZBlrOyvr2Zj/ck86Dk4UsiV1ScqOLsgx82Alt4snO/8mlXyDp5D3iYCyU31OF2oDC+kCll +A3L6ewIP6jhVyZx8N4CvtRQFWWdG53CgszjBrwSysuxAyskM4ka4gQEN1koYHzxUwdTWqh6oMJ0A +wc4Evr4jsHZqcjy1Tx9rQDi4AyFQrSAMUncrHGH6DBa0jfvhynkG8cfodG15J+J5/y93homDOuGE +Uo6s1mRUJ3sgTwTol8HDOntHiIKNZls5/BYJF3RmImUhm7nS+MlAy1O3g7PnPfBXZtuyZ2SsjIGf +HfiAz17DKjJxnfQJJsN3D2uNDTsYPqyUbOATsNGohWz4401ESl4wV8OBj/k09iMQ9NQu6giiC51D +Br52mNVz8Ykxn35w3uwPvZZkJUH3ZzH2sR0den8Mvh5tQrzszMyREKsgL9eL/LFNsrMgUc0sw8Yw +T2VSewBACenMzMkBzB/qTC7m+Dawrne4BWpEs8rxB8MLeMoKPg1w5tOYs9VG9Npz/PXT54Lx+xM4 +tgi7LRELtVwPL0T/xRyh7JbH3iGElQsOaH59B2ljqYMZBWkP5+fp0Ge4VaKC83OlUtHs38QJZpx1 +6Nyyl3YHLhNWWm+eojWoUItAlyabwiyzCJVgxp03Te+eUlMG1hJKg+a/0sgxszNGTmNLN4GFsfSx +OX4rd2wOa5xY4N1jO6gtHay2hMYNT1t2N27a/0oZvmk3K+uGh9vVnN7vU7zkmXeObsosnDujDnRq +BtBj+bLUiWtoT+ls9uGjd/pECpFyRSIAtCrT5Wf6iAbgncGxPHu40x4EWrWCASy0ASI+TyfInvdg +Z8dnQ/4uzXxAl1K/wcNTKQ2K9CYwuX4pO6noIqBv/orzTyHhnaej5SAw/tFhATHnCBUTPOOMYT/k +zzueGvmxwv5g/Jk6Z43aYMw2h37BBmOgaNwFTy8MgL5ZuMeDTrka1nb8ndAPb/lsJ/Spu2J3Qt/P +d0K7/DqYx8CGEJw4TO1ilT45EA0KBCNZlCtEswDRs3htq0wIGu5W4DpPMWi02OjfBjs7/dviwQHN +0ADvrJPxWYbmDRsmyBtiNz6hVNJnjn3zdyGX769yu5BWbl607kEKb4Douzc3bcBBh/K2qCWSfZoI +uUODJcEXnwSnzypLgg5HAkqPOTUQwZd6s1ppIgySVQEJogflvWhoJyvvQuLlwy27PehiJjp77Lrd +aAsVVONtIEsxEgCgM8uD4HGjEghZANyWOhjLlSDyXwk7n/xK8kDNyxmIwUPBccsw+AwJAMhJpSII +dmddwzAQAJ1ZDALoHfctw4B+uEd1d18ZBLow7GKu5NkwVj5fXirdFAAeVwoAMBUj6iA4vrxWw1j5 +fMkHoXU2rHyuPAfw/7s79/aojSyNf4L+Dr27wwQTkKtKdXUmmRiHhGSdgQCemNzYxm6MJ3abp91A +8s9+9v2dKkktd8vY4WF35tkQk27pqC7n8p73HMlKE/sXV7E6xNIvL7fGux7WkLdc9fzyfZzq5jW8 +snlO5dIhln75DlW+K+X10VLd/+Lx83aIp7OVR3SWzqe+fHK3W+3Tn1flrudj73oaqO9jf1Szxcc2 +LvOx64bKxtLHhhyk87F3bWMF+/6wg2xc9LH32sbSxy718yt8bOMyH7v2Gq6Vkf/toy9++q4Zwpz/ +cnGIW9dFvl5G3l8dovPL91zDxYz8Ppq41ffKKz1iMCPferdfXg1ct94/I+dGJQWp0M/7t1dfc3zn +m/SD/DrWD1IeUzI/2LhdnnikJj1c3nu7X7UvW971a48eLz6PmfAt22W9Em7yp9OfSnvjo0+fNndu +7u4/y/Xgndy7z/3k5o2KbcF9v3s5o9wekC7H9PzXWxdvD9wuGypfd6qqWWZz2eby1Yz5rYXLjqK9 +2etCXuz39wrl3o3Yzz6/3Ws19ho5F5r++e2ky1l2e73Oldcm5tq3P/NXn3/cazX2Zv7qy2Uv7xcU +uDfPNwK6t/R+9UCJf3/ctAaXr01cNr8e7nycm4lN2ffw6zttTfr6VlOdP9ytSr/xo0/3qQMePlKC +Pzq/EfJQDuyXYUGEWdW8c/ZP1UbTO376dbblx/3e6dMH1XXbV9K3/OjHnWXTqt/gWLavnj7a/EMN +sZXxRgMj7qneXYK9T7d2tvf+/Ml/7bwM//lq+8n27PvSnrz7461fmruVB/vdfbYn9Q== + + 8rW0S+vmjuLu7V4XsvTZnj8qr12W//nORvk0+fe/l6bk8naZuftDfT//KmZuA+VPjWGfH7nSb2y7 +1r/uVQIpGrvFXPjc6ZpWd/q96l8nptdq7PVzfj2y3TtnXe+G5l/3vryfu7ESldfu73a309b6u3/p +++Lix838zAKr3s57rvLTMN98XI721r04qvOx9pWw/W6z/+H0/skXL26cP/n8L3/dt6W3+Jn72YEm +391s7oke3/hzbqVmMMuzNN32D/Pm16H3vpbf5PmQb34deu8r1v/Ab34deu9rxuQP+ubXofe+ludU +rnrz69l/fzb6ZHRD7lA+uzc77N+dHN24wZHH08XrVyLgnt2dHh3Pdie/T+cjPS5/FH/k75DG2sSx +cY4vTo7uPh/dzLJjvTHenY3UePve6Mazze354ovjg8Xx2Wwy/328JYf2v93d+/qL8da4XPCMCz4Z +32RJ6hnSnNqQ+6JZ7m9ykzRfNDDIpScZ7bfTkxmn70wWi/nx89eL6Xkz6PZ8PlmTOnh5fHI4n86K +jBlvfj1bLM/KX4vfX03L2ZsvF4tXW5ubb9++rd7W1dn8aFOnlDaV2TTmzvzwxZ3z32eLyW93Zuf/ +sTHefMz8s6OLg72ZnLxuR5Pj51tcdonsbHLaiDbrbYSv1ND/tRKMwg/P3xxde8+Xyw7sOQv/a+z5 +1ev5Sd7x4cHm9GQqoXO+qSu9ee2dHx5cf+Mi+6+x74P5dLI4fjM9ODs9PZudZxX8ER8/+AO7Pji4 +cOB9N6bfubGrF/747189e/Ly+PxeMfN11r92ST7OjyAiP/tv5cN09HrlP3tXguVRHaN75p4No+VN +Xan8z1itfehOWa0ra2KKfmxdtSGXBW1Nir2dbR+ePZ8+eP6P6cHi2wnHfmvUvbqwle83F/PJ7Pxk +spj+dLNMk24zB8PXP230hs9iL87mpxc0tt0ZV4a9cKp3oGixZCE0+TtfvuHDPzj0dqzV+Nvxjz+r +8aFo+dEoixyO/Pjmxnj/+zWlPxipKtjoha8m/gqaVFb5EL21yTntoqmtHPEpaR9V9MrpJEdiCkpp +561TJmif1Vwnw5HoTbBOX+vI/mRkk6pcHUytrTxKVI8RqKzytTPBO+v1+HRUm1QljYyvTZSnjdZk +dke6dpXlpDdGBVXrcahN5ZN2KrFO602W8VUK3jjOWaPT0DiRqaIx6MKnZj2mUsHhHyqEhIxcY7RR +tdeyHJFAi7W3tYpJySiqsoHV4qo+6BgG1rsz0qykNso57znDnqyKsgFnyzxlvakKKuqk2H3y6Voy +XqtKa2MVGjZFpramcikYk8QAyg+N43BXj4jVRqtUxyEZw1zeJRnbGO/82AfPzlONW7QyV9tzd/Ri +dLWGTq8hs/vBZF6MnE0Sp8jVKdqh/Z+OPM4BzTF5lAH9XDg/MMvaHNeRGZjnxUjsW0VlL5/tdF1m +0HuiqsDCWmU3rK8lMxR9V67nejLsjIkrgsvYUOIY7JHZreJfr2KQnaWQKmuD+OAlaBCBg4DfEwJG +omJIBqeo+DHee4GycXB1FU0X6XnvXtsqEuQ2XD6XDXV1OS6BCxW5wKDSiBT7CZVmquRkfTrPYj0r +Ccr4Wlx00ObaK1sRTyZD1yUyZUdGew6Ihh2Wcwak9dG0MtEKnpVRLnEKHA/lKcDAXwYFV5spG1Pr +CBqQOFyqmQxNV4CQrxUYI3vHlgqtq0AhlTIMeuOBLzAG/1cNbKva9pfsdajQL2hkY9agViCwTbVu +oFQElCOleVegXyttQEmjuSCvwzCgdsGEbCczPmAShe20b53Ty5zJkAaMyjBKeVOFCGTn511xGbIi +qmZMVaZAIdH6VvXMRiJxyRpftipTaMe0wYXsLIFwkMGJhwLUbCNWNaMKAMsQsa5EE9G5knlQRJJF +BTxHBCL7rLm6Ma/Oc8A3VGQxeY5IxiOTkyCMOJsM4Qhmknh5bDc6WWVok0U+j6YkZmQT0UtEkA5D +488ygfMkClJdUWXExerAOZuNkUcgy+ocUjJDQo8uefyp3QQGd50pMHLllFVNmm6mkDHJWE3MEYPk +tpAIkCzCJhm0hKMQGGRddqisIgIfj9ct1ssGe7lZhuei5mp8WJuUiq/J1VjNK3yn+Cv0AWXV4uZF +PSn5KrZuFvlSC5rBnfLWd0YJ0oG1fDO7j67CraNlxUS2ODP2rFr1ihOxhhpkcNlHEm6K4zfBAnAA +JTUMIWi5OImH+roObagQyTHEdnXiYjHpqm7znJzXqLCLNgCI+Ux0xTTeOSyJl4XGh2MIFYYMOezz ++oAqMj1Ep6xvZxShYp17AFkVpCxpqAd/Mn3CJXEqV5clhuT6UQArS2Bl6lJAhHWgUzSEb8gIOFrV +6Vc5/D/ERgFiO5kRwtGtkM1XSjio9TZbMIjHhpShNs/PjnDRVAwg543UAbYTAOqEk6Z2gczhhTEk +2yyRYMMMNZptgkyGgMLGNiXgqJVjztQiVvARt8JH2xGwA4QaRGmYqOwDNSLn+F7QIuAorArdZluL +4thGIQHZk2B1y1WYrDkj4KDKCJ6oMsJZS6RnZwAtGkdDTYBAIjiKH+IiRGW50klAs/UOLaN36ATs +bti2BdqTdcurGdqTIcCFJgPDUyp4NwaLRQWCCn3moSVeMUbdOjpR3+bdlvvqmrQWVOPJCY1g+O4X +DIAolAjEF1+TWIFNLMFSzhsKC9fS3owaxqfl5XzRts26zFDjezaV/LUUWZqJ9ILWQknKeRes0mns +3xgJYK1aLpy1wADoyNm62Ig5cPdadRzfaXxJ+WUi1eRKclmbEpzLFosNf+A85AuHb5zVi5oAG5O6 +CbTG7rZutSSZjwheEnKtCQib2oA2As0WX2ksyemI8buIZq8XiweZIdQXkivYSxok95nUjIEAcd2t +QVYUe2pgEuhaD1UkvjC+M13y1aKGssdAPlhGdFaBJ0M0gAJegbmhzYly+gqKsZPpMrCFq3WalOKE +cSJ2JK9HK0REkw10a+s1gZxzLFDd1jWIEtZQriYtDUiAKbnuwsXE6Up6XpGhxhYnIyVnnjFeWQaV +J3hmpa4tp9d2sirBJDWeLTpqoGF9EGKNAy3+xIFVrEkM7GVNpmgEB0/EQ43OVhdSlBooMokVEbjS +LgdYb2+Umv7F0KemmUHIwBGXkMLqJBNBUwpLxMIkcgIctRNBufzXGZeIqFD4zdjV4CS+FVvYRUJS +HBm34AYSRJARlGl4L6kTiiU82LED9rQzctAXK44RSsMCPVAU64gOYLKk0hzntQI1TdOI0ExG5Bun +CpEZAxkkTu1w5JxnkGBUsZCvM0Yyj4cuxiXT0mTuPqGUgrRItJ2TelAG2GMjDgqVYWhIBi4ND+w1 +K9ZkyC5ooYckhK0WNGxT/5AEKUyx5XbPaO5KGdYr9LGP2wMywjLqYKCvpYtTYpPk7SA/gnzCVJQw +gSWZBorJoDVlZeMMUAChH8v6UIMxuAt2BKTEOYMYzVjsmG2EekE4+IYVlWsAiS3BVoQjGYC+jbW1 +5UYWh+uGpnxIH1BmxQhRKgxqXB8bkrlmSICUkGW7XZCsSrAnaCpGMsRJLjSGXKaREUyoJcQGXU/Y +oUpdzbQm4qMWeIASa9FeaoBKconPhC53oExXlZGKrCQDYXJQI5uDBDiFX6jYDlFLhZAsxNlmiGEd +wAAo3hbOgmQBLZDngaOMZEKlE7SzlrJTujIMKWvXQp2ThLTUv5RAoe6wTgFtQbWJDCTzOAdEsaPw +gi4wdNIgXxwGggY6Sd9qif81NYbHvq0Bg5S2EbcsxaxgLBpJUgQEyrC8ZSGwICp4Vag+MEsdg7mg +DTHjz24rw9pqV9QyIAP3oL4wycXSihqSIftivx7WrcpIIYyFKLqULrGIdauaUpuJswEGJKDHGk02 +fFH2ROhZuaYlAmsyUlpRrUFjG+adQ60W3tnlG2RAeAoKpWPpZpUQgWYnW+gvRaEnyDlVklJO0dTh +sBkKlWxJoaYhyAIywRWv9BqX6kiH1EmB4OT6SKZo1rK+3iC2xX54V4O815FZ0R77hXunGnYfTc5I +qxZIFjKuY4mh7FWrEjsZOggr1RS/dsjWRaYGN0p9NShDuAUiVkUh22rA96LYhHUucz78uSKuUl2K +wAJBVOUtriJRKigCO7Y+ThBLm7mpgCSXU3JEJ05khZ2Lb4ImZD8jNbTO8Ex8QmWDbeEZ/eqEDH4X +Qq5Zx1pyM7AFRctVJwqneIr9nGRr6WOSErTLoc8MUkkwbS69k4whJDbZpjAWskSmx0yx6WrURSZK +b7KJ7CwBlEsZVGcLkJIh4ywDp8evigTLWMK7SFC94vhFYkearFFu4HSlmSA58/i2ahEmJ2bEULkF +g2c6amArIV7aEEAKmaXmapW7KLFZCQESS6cgc8zs8r5rNgBjUmPWtdw5KhSSskA5aT7VDbUjJKwS +1/ai/HJF7UKXX8kmOCrmapCZ7YiWtDXNfoR157LPaumrZgpJsUDOWHZ8xHQECPArsIpS3jAKlRn5 +3TYVCnaCEBtYmy4xz1rZoGt8Ni8WrI51V9Q3oxIasKCS8gDFCuO1NW3WiRGDpSUd8LmklKAq3FBi +uzJNsUd+0XIfDT7a0GUjNAvBEErTmtpNMoakP0Kl2JePQNqyDUzGkxZK1+LDX6Xp22sjohWDv0KQ +G+6Te3xKusJZ76xTmgmYw7YYuDNKEgUYEr7f7JeVVjAbuTWW9wuysRCnux6GFmxl0hr5gvyUAySY +5a0MLSV3FCOE4vMHIycZUDhX2zHS+LdQFgZi4WiFcKjkvlWThlCTtKWMlyKhrJYEWpFVg7K62Y9U +6sbhiSHXqMIsRQaYjssELjLEURs7u1lGbN4qpshoaYSnkPFCJJLr0WApMkgLbe9kfGUVIvWMHm+/ +GqnmBm55pGh/Qv2ZoqQmsiE6j1S2aLXyykjVEAiLXKOuyUizFUyOwjwyWsGA5CwI7fBi8aGsYciB +CV42Dn4BGuQK76n2wrqE1OPSL4evGFGhdwOjKBZHzR9wJvBqaCXrEiv7kXJ4VUb4BHAaiDOFpsfr +K4GE4Xfgj4dIxaH9rErkHsaKVtZHWdXs+kquso/Ydvj5hdXHBCbHW1v3Tk6OX51PN8abe7NjeQ9G ++3CAnNw9fjN9/HLyarq1dX8yOzyZzv/WPV+xOpoeb949OzsZ90fd2to5OTv49e3xeXORGm8+mk5W +hR6dLSYy1Pbs6KQRJN1J977t3A1ddX96fPRycfHhkgsCX8+OF8eTk+9eTw7nk/bxjyB5JwokkhjB +uMGhd6azxXT+9F1rfng8vTc77K34UrHHi8l80ROEEV/0lMtXsH9tZXx/fLh42T2rsWK7h5P55PR8 ++OzFh2Ly8xj/7GcxcHHwmdqDjMVRL0ENeXCC3tIFLW2yNRnopZGimTDxmVGXXoZJWm7L5EQHwVBQ +A7ZCZhBG7SlD4WoxB8+6hIRs7aUDrgXpSzJcG8XI7ZM6CEUiUw+tZE1iZT8yz5pMvg== + + uSx3BKTRqMcDK0nSpJJGMQRObjqt72dFIkPQqlbWRlnT7NpKrrLP/wsIChJ0Hf+39QcFoSQ36BJE +QZru/p8BQiu+ciUIXVCHMKL/LRjaW31cbKjdunu3PBfN9vODy3fujG7ceDg5mj6ZT45xktHR+eTN +dDyZzcSw01ecGR/Np+eLs/l0fP7y7K0c4ZJW/MaNew++HP0Phl8izg== + \ No newline at end of file diff --git a/dist/images/KiwixLogoVertical_v3_440.png b/dist/images/KiwixLogoVertical_v3_440.png new file mode 100644 index 000000000..fa091d9a6 Binary files /dev/null and b/dist/images/KiwixLogoVertical_v3_440.png differ diff --git a/dist/images/KiwixLogoVertical_v3_440x280.png b/dist/images/KiwixLogoVertical_v3_440x280.png new file mode 100644 index 000000000..7caef7e91 Binary files /dev/null and b/dist/images/KiwixLogoVertical_v3_440x280.png differ diff --git a/dist/images/KiwixLogoVertical_v3_store.svg.png b/dist/images/KiwixLogoVertical_v3_store.svg.png new file mode 100644 index 000000000..70a932255 Binary files /dev/null and b/dist/images/KiwixLogoVertical_v3_store.svg.png differ diff --git a/dist/images/KiwixLogoVertical_v3_white.svg.png b/dist/images/KiwixLogoVertical_v3_white.svg.png new file mode 100644 index 000000000..be9161e3c Binary files /dev/null and b/dist/images/KiwixLogoVertical_v3_white.svg.png differ diff --git a/dist/images/Kiwix_icon_nontransparent_store_logo.png b/dist/images/Kiwix_icon_nontransparent_store_logo.png new file mode 100644 index 000000000..403e8cc03 Binary files /dev/null and b/dist/images/Kiwix_icon_nontransparent_store_logo.png differ diff --git a/dist/images/Kiwix_icon_nontransparent_store_logo_1080.png b/dist/images/Kiwix_icon_nontransparent_store_logo_1080.png new file mode 100644 index 000000000..583e1f466 Binary files /dev/null and b/dist/images/Kiwix_icon_nontransparent_store_logo_1080.png differ diff --git a/dist/images/Kiwix_icon_nontransparent_store_logo_150.png b/dist/images/Kiwix_icon_nontransparent_store_logo_150.png new file mode 100644 index 000000000..7e5e8cbfe Binary files /dev/null and b/dist/images/Kiwix_icon_nontransparent_store_logo_150.png differ diff --git a/dist/images/Kiwix_icon_nontransparent_store_logo_300.png b/dist/images/Kiwix_icon_nontransparent_store_logo_300.png new file mode 100644 index 000000000..d6c9f224e Binary files /dev/null and b/dist/images/Kiwix_icon_nontransparent_store_logo_300.png differ diff --git a/dist/images/Kiwix_icon_nontransparent_store_logo_71.png b/dist/images/Kiwix_icon_nontransparent_store_logo_71.png new file mode 100644 index 000000000..a900ea2df Binary files /dev/null and b/dist/images/Kiwix_icon_nontransparent_store_logo_71.png differ diff --git a/dist/images/Kiwix_icon_transparent.svg b/dist/images/Kiwix_icon_transparent.svg new file mode 100644 index 000000000..094c6cea7 --- /dev/null +++ b/dist/images/Kiwix_icon_transparent.svg @@ -0,0 +1,71 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + diff --git a/dist/images/Kiwix_logo_v3.png b/dist/images/Kiwix_logo_v3.png new file mode 100644 index 000000000..e29499a4b Binary files /dev/null and b/dist/images/Kiwix_logo_v3.png differ diff --git a/dist/images/Kiwix_logo_v3.svg b/dist/images/Kiwix_logo_v3.svg new file mode 100644 index 000000000..566b1064b --- /dev/null +++ b/dist/images/Kiwix_logo_v3.svg @@ -0,0 +1,20 @@ + + + + + + diff --git a/dist/images/Kiwix_logo_v3_2048.png b/dist/images/Kiwix_logo_v3_2048.png new file mode 100644 index 000000000..c13bcc88a Binary files /dev/null and b/dist/images/Kiwix_logo_v3_2048.png differ diff --git a/dist/images/Kiwix_logo_v3_2048_store_template.png b/dist/images/Kiwix_logo_v3_2048_store_template.png new file mode 100644 index 000000000..1a6eb2d51 Binary files /dev/null and b/dist/images/Kiwix_logo_v3_2048_store_template.png differ diff --git a/dist/images/Kiwix_logo_v3_300.png b/dist/images/Kiwix_logo_v3_300.png new file mode 100644 index 000000000..ab33b6080 Binary files /dev/null and b/dist/images/Kiwix_logo_v3_300.png differ diff --git a/dist/images/Kiwix_logo_v3_300_midnight_blue.png b/dist/images/Kiwix_logo_v3_300_midnight_blue.png new file mode 100644 index 000000000..a5fd346eb Binary files /dev/null and b/dist/images/Kiwix_logo_v3_300_midnight_blue.png differ diff --git a/dist/images/Kiwix_logo_v3_navy.png b/dist/images/Kiwix_logo_v3_navy.png new file mode 100644 index 000000000..0449f2442 Binary files /dev/null and b/dist/images/Kiwix_logo_v3_navy.png differ diff --git a/dist/images/Kiwix_logo_v3_navy_drawing.png b/dist/images/Kiwix_logo_v3_navy_drawing.png new file mode 100644 index 000000000..dd7dcd45b Binary files /dev/null and b/dist/images/Kiwix_logo_v3_navy_drawing.png differ diff --git a/dist/images/Kiwix_logo_v3_no_trans.png b/dist/images/Kiwix_logo_v3_no_trans.png new file mode 100644 index 000000000..dce2b76ad Binary files /dev/null and b/dist/images/Kiwix_logo_v3_no_trans.png differ diff --git a/dist/images/Kiwix_logo_v3_no_trans_512.png b/dist/images/Kiwix_logo_v3_no_trans_512.png new file mode 100644 index 000000000..6fe60862b Binary files /dev/null and b/dist/images/Kiwix_logo_v3_no_trans_512.png differ diff --git a/dist/images/Kiwix_logo_v3_outline.png b/dist/images/Kiwix_logo_v3_outline.png new file mode 100644 index 000000000..eead281c9 Binary files /dev/null and b/dist/images/Kiwix_logo_v3_outline.png differ diff --git a/dist/images/Kiwix_logo_v3_outline_trans.png b/dist/images/Kiwix_logo_v3_outline_trans.png new file mode 100644 index 000000000..2ea8886da Binary files /dev/null and b/dist/images/Kiwix_logo_v3_outline_trans.png differ diff --git a/dist/images/Kiwix_logo_v3_outline_trans_blue.png b/dist/images/Kiwix_logo_v3_outline_trans_blue.png new file mode 100644 index 000000000..f3a8a9e50 Binary files /dev/null and b/dist/images/Kiwix_logo_v3_outline_trans_blue.png differ diff --git a/dist/images/Kiwix_logo_v3_store_150.png b/dist/images/Kiwix_logo_v3_store_150.png new file mode 100644 index 000000000..97024f1b6 Binary files /dev/null and b/dist/images/Kiwix_logo_v3_store_150.png differ diff --git a/dist/images/Kiwix_logo_v3_store_2160.png b/dist/images/Kiwix_logo_v3_store_2160.png new file mode 100644 index 000000000..d83e2d00f Binary files /dev/null and b/dist/images/Kiwix_logo_v3_store_2160.png differ diff --git a/dist/images/Kiwix_logo_v3_store_300.png b/dist/images/Kiwix_logo_v3_store_300.png new file mode 100644 index 000000000..2caa8d6c3 Binary files /dev/null and b/dist/images/Kiwix_logo_v3_store_300.png differ diff --git a/dist/images/Kiwix_logo_v3_store_71.png b/dist/images/Kiwix_logo_v3_store_71.png new file mode 100644 index 000000000..bd51ff953 Binary files /dev/null and b/dist/images/Kiwix_logo_v3_store_71.png differ diff --git a/dist/images/Kiwix_midnightblue_icon_transparent_530.png b/dist/images/Kiwix_midnightblue_icon_transparent_530.png new file mode 100644 index 000000000..e846672ab Binary files /dev/null and b/dist/images/Kiwix_midnightblue_icon_transparent_530.png differ diff --git a/dist/images/LargeTile.scale-100.png b/dist/images/LargeTile.scale-100.png new file mode 100644 index 000000000..0e78604da Binary files /dev/null and b/dist/images/LargeTile.scale-100.png differ diff --git a/dist/images/LargeTile.scale-125.png b/dist/images/LargeTile.scale-125.png new file mode 100644 index 000000000..c912adafb Binary files /dev/null and b/dist/images/LargeTile.scale-125.png differ diff --git a/dist/images/LargeTile.scale-150.png b/dist/images/LargeTile.scale-150.png new file mode 100644 index 000000000..f13f993f2 Binary files /dev/null and b/dist/images/LargeTile.scale-150.png differ diff --git a/dist/images/LargeTile.scale-200.png b/dist/images/LargeTile.scale-200.png new file mode 100644 index 000000000..2b04c8747 Binary files /dev/null and b/dist/images/LargeTile.scale-200.png differ diff --git a/dist/images/LargeTile.scale-400.png b/dist/images/LargeTile.scale-400.png new file mode 100644 index 000000000..ec9720cdd Binary files /dev/null and b/dist/images/LargeTile.scale-400.png differ diff --git a/dist/images/SmallTile.scale-100.png b/dist/images/SmallTile.scale-100.png new file mode 100644 index 000000000..7d1ce2ee9 Binary files /dev/null and b/dist/images/SmallTile.scale-100.png differ diff --git a/dist/images/SmallTile.scale-125.png b/dist/images/SmallTile.scale-125.png new file mode 100644 index 000000000..b0cc54ebc Binary files /dev/null and b/dist/images/SmallTile.scale-125.png differ diff --git a/dist/images/SmallTile.scale-150.png b/dist/images/SmallTile.scale-150.png new file mode 100644 index 000000000..0a099f2c8 Binary files /dev/null and b/dist/images/SmallTile.scale-150.png differ diff --git a/dist/images/SmallTile.scale-200.png b/dist/images/SmallTile.scale-200.png new file mode 100644 index 000000000..b8fd22b44 Binary files /dev/null and b/dist/images/SmallTile.scale-200.png differ diff --git a/dist/images/SmallTile.scale-400.png b/dist/images/SmallTile.scale-400.png new file mode 100644 index 000000000..95ab59089 Binary files /dev/null and b/dist/images/SmallTile.scale-400.png differ diff --git a/dist/images/Square150x150Logo.scale-100.png b/dist/images/Square150x150Logo.scale-100.png new file mode 100644 index 000000000..31cf1876f Binary files /dev/null and b/dist/images/Square150x150Logo.scale-100.png differ diff --git a/dist/images/Square150x150Logo.scale-125.png b/dist/images/Square150x150Logo.scale-125.png new file mode 100644 index 000000000..5bc6a79a5 Binary files /dev/null and b/dist/images/Square150x150Logo.scale-125.png differ diff --git a/dist/images/Square150x150Logo.scale-150.png b/dist/images/Square150x150Logo.scale-150.png new file mode 100644 index 000000000..bac45e910 Binary files /dev/null and b/dist/images/Square150x150Logo.scale-150.png differ diff --git a/dist/images/Square150x150Logo.scale-200.png b/dist/images/Square150x150Logo.scale-200.png new file mode 100644 index 000000000..b9c9e50c9 Binary files /dev/null and b/dist/images/Square150x150Logo.scale-200.png differ diff --git a/dist/images/Square150x150Logo.scale-400.png b/dist/images/Square150x150Logo.scale-400.png new file mode 100644 index 000000000..c77d9d6a2 Binary files /dev/null and b/dist/images/Square150x150Logo.scale-400.png differ diff --git a/dist/images/Square44x44Logo.altform-unplated_targetsize-16.png b/dist/images/Square44x44Logo.altform-unplated_targetsize-16.png new file mode 100644 index 000000000..e9820a43a Binary files /dev/null and b/dist/images/Square44x44Logo.altform-unplated_targetsize-16.png differ diff --git a/dist/images/Square44x44Logo.altform-unplated_targetsize-256.png b/dist/images/Square44x44Logo.altform-unplated_targetsize-256.png new file mode 100644 index 000000000..37d5405c5 Binary files /dev/null and b/dist/images/Square44x44Logo.altform-unplated_targetsize-256.png differ diff --git a/dist/images/Square44x44Logo.altform-unplated_targetsize-32.png b/dist/images/Square44x44Logo.altform-unplated_targetsize-32.png new file mode 100644 index 000000000..3c3872f5e Binary files /dev/null and b/dist/images/Square44x44Logo.altform-unplated_targetsize-32.png differ diff --git a/dist/images/Square44x44Logo.altform-unplated_targetsize-48.png b/dist/images/Square44x44Logo.altform-unplated_targetsize-48.png new file mode 100644 index 000000000..e4dd924e3 Binary files /dev/null and b/dist/images/Square44x44Logo.altform-unplated_targetsize-48.png differ diff --git a/dist/images/Square44x44Logo.scale-100.png b/dist/images/Square44x44Logo.scale-100.png new file mode 100644 index 000000000..d4f6cee77 Binary files /dev/null and b/dist/images/Square44x44Logo.scale-100.png differ diff --git a/dist/images/Square44x44Logo.scale-125.png b/dist/images/Square44x44Logo.scale-125.png new file mode 100644 index 000000000..6f220382d Binary files /dev/null and b/dist/images/Square44x44Logo.scale-125.png differ diff --git a/dist/images/Square44x44Logo.scale-150.png b/dist/images/Square44x44Logo.scale-150.png new file mode 100644 index 000000000..64acaa9cc Binary files /dev/null and b/dist/images/Square44x44Logo.scale-150.png differ diff --git a/dist/images/Square44x44Logo.scale-200.png b/dist/images/Square44x44Logo.scale-200.png new file mode 100644 index 000000000..0db563a58 Binary files /dev/null and b/dist/images/Square44x44Logo.scale-200.png differ diff --git a/dist/images/Square44x44Logo.scale-400.png b/dist/images/Square44x44Logo.scale-400.png new file mode 100644 index 000000000..d3124261b Binary files /dev/null and b/dist/images/Square44x44Logo.scale-400.png differ diff --git a/dist/images/Square44x44Logo.targetsize-16.png b/dist/images/Square44x44Logo.targetsize-16.png new file mode 100644 index 000000000..e9820a43a Binary files /dev/null and b/dist/images/Square44x44Logo.targetsize-16.png differ diff --git a/dist/images/Square44x44Logo.targetsize-24.png b/dist/images/Square44x44Logo.targetsize-24.png new file mode 100644 index 000000000..46fb0a933 Binary files /dev/null and b/dist/images/Square44x44Logo.targetsize-24.png differ diff --git a/dist/images/Square44x44Logo.targetsize-24_altform-unplated.png b/dist/images/Square44x44Logo.targetsize-24_altform-unplated.png new file mode 100644 index 000000000..46fb0a933 Binary files /dev/null and b/dist/images/Square44x44Logo.targetsize-24_altform-unplated.png differ diff --git a/dist/images/Square44x44Logo.targetsize-256.png b/dist/images/Square44x44Logo.targetsize-256.png new file mode 100644 index 000000000..16718d711 Binary files /dev/null and b/dist/images/Square44x44Logo.targetsize-256.png differ diff --git a/dist/images/Square44x44Logo.targetsize-32.png b/dist/images/Square44x44Logo.targetsize-32.png new file mode 100644 index 000000000..3c3872f5e Binary files /dev/null and b/dist/images/Square44x44Logo.targetsize-32.png differ diff --git a/dist/images/Square44x44Logo.targetsize-48.png b/dist/images/Square44x44Logo.targetsize-48.png new file mode 100644 index 000000000..e4dd924e3 Binary files /dev/null and b/dist/images/Square44x44Logo.targetsize-48.png differ diff --git a/dist/images/Wide310x150Logo.scale-100.png b/dist/images/Wide310x150Logo.scale-100.png new file mode 100644 index 000000000..345c826b8 Binary files /dev/null and b/dist/images/Wide310x150Logo.scale-100.png differ diff --git a/dist/images/Wide310x150Logo.scale-125.png b/dist/images/Wide310x150Logo.scale-125.png new file mode 100644 index 000000000..0106d79f6 Binary files /dev/null and b/dist/images/Wide310x150Logo.scale-125.png differ diff --git a/dist/images/Wide310x150Logo.scale-150.png b/dist/images/Wide310x150Logo.scale-150.png new file mode 100644 index 000000000..4eec8e038 Binary files /dev/null and b/dist/images/Wide310x150Logo.scale-150.png differ diff --git a/dist/images/Wide310x150Logo.scale-200.png b/dist/images/Wide310x150Logo.scale-200.png new file mode 100644 index 000000000..c3d785c62 Binary files /dev/null and b/dist/images/Wide310x150Logo.scale-200.png differ diff --git a/dist/images/Wide310x150Logo.scale-400.png b/dist/images/Wide310x150Logo.scale-400.png new file mode 100644 index 000000000..88ba5f4a5 Binary files /dev/null and b/dist/images/Wide310x150Logo.scale-400.png differ diff --git a/dist/images/WikiMed_400x430.png b/dist/images/WikiMed_400x430.png new file mode 100644 index 000000000..3872903ad Binary files /dev/null and b/dist/images/WikiMed_400x430.png differ diff --git a/dist/images/Wikivoyage_400x400_colour_pop.png b/dist/images/Wikivoyage_400x400_colour_pop.png new file mode 100644 index 000000000..16f9bb9a2 Binary files /dev/null and b/dist/images/Wikivoyage_400x400_colour_pop.png differ diff --git a/dist/images/edgelegacy-color.svg b/dist/images/edgelegacy-color.svg new file mode 100644 index 000000000..08ac2cc89 --- /dev/null +++ b/dist/images/edgelegacy-color.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/dist/images/electron-color.svg b/dist/images/electron-color.svg new file mode 100644 index 000000000..dc81c99d2 --- /dev/null +++ b/dist/images/electron-color.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/dist/images/firefoxbrowser-color.svg b/dist/images/firefoxbrowser-color.svg new file mode 100644 index 000000000..a154f42b6 --- /dev/null +++ b/dist/images/firefoxbrowser-color.svg @@ -0,0 +1 @@ +Firefox Browser \ No newline at end of file diff --git a/dist/images/googlechrome-color.svg b/dist/images/googlechrome-color.svg new file mode 100644 index 000000000..8673cb399 --- /dev/null +++ b/dist/images/googlechrome-color.svg @@ -0,0 +1 @@ +Google Chrome \ No newline at end of file diff --git a/dist/images/icon.ico b/dist/images/icon.ico new file mode 100644 index 000000000..4ca685851 Binary files /dev/null and b/dist/images/icon.ico differ diff --git a/dist/images/icon.png b/dist/images/icon.png new file mode 100644 index 000000000..5c833403f Binary files /dev/null and b/dist/images/icon.png differ diff --git a/dist/images/icon_transparency.png b/dist/images/icon_transparency.png new file mode 100644 index 000000000..1ec3dd070 Binary files /dev/null and b/dist/images/icon_transparency.png differ diff --git a/dist/images/kiwix_store_200.png b/dist/images/kiwix_store_200.png new file mode 100644 index 000000000..fff52e4d4 Binary files /dev/null and b/dist/images/kiwix_store_200.png differ diff --git a/dist/images/microsoftedge-color.svg b/dist/images/microsoftedge-color.svg new file mode 100644 index 000000000..2f04e1a96 --- /dev/null +++ b/dist/images/microsoftedge-color.svg @@ -0,0 +1 @@ +Microsoft Edge \ No newline at end of file diff --git a/dist/images/microsoftwindows-color.svg b/dist/images/microsoftwindows-color.svg new file mode 100644 index 000000000..d0332d415 --- /dev/null +++ b/dist/images/microsoftwindows-color.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/dist/images/nwjs-color.svg b/dist/images/nwjs-color.svg new file mode 100644 index 000000000..2b2c530c4 --- /dev/null +++ b/dist/images/nwjs-color.svg @@ -0,0 +1,11 @@ + + + + + + + + + + + diff --git a/dist/images/safari-color.svg b/dist/images/safari-color.svg new file mode 100644 index 000000000..2ff888ba3 --- /dev/null +++ b/dist/images/safari-color.svg @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/dist/images/splashscreen.scale-100.png b/dist/images/splashscreen.scale-100.png new file mode 100644 index 000000000..c3d785c62 Binary files /dev/null and b/dist/images/splashscreen.scale-100.png differ diff --git a/dist/images/splashscreen.scale-125.png b/dist/images/splashscreen.scale-125.png new file mode 100644 index 000000000..901fb69c6 Binary files /dev/null and b/dist/images/splashscreen.scale-125.png differ diff --git a/dist/images/splashscreen.scale-150.png b/dist/images/splashscreen.scale-150.png new file mode 100644 index 000000000..53d9ea855 Binary files /dev/null and b/dist/images/splashscreen.scale-150.png differ diff --git a/dist/images/splashscreen.scale-200.png b/dist/images/splashscreen.scale-200.png new file mode 100644 index 000000000..88ba5f4a5 Binary files /dev/null and b/dist/images/splashscreen.scale-200.png differ diff --git a/dist/images/splashscreen.scale-400.png b/dist/images/splashscreen.scale-400.png new file mode 100644 index 000000000..1ab91de6d Binary files /dev/null and b/dist/images/splashscreen.scale-400.png differ diff --git a/dist/images/storelogo.scale-100.png b/dist/images/storelogo.scale-100.png new file mode 100644 index 000000000..32334b23e Binary files /dev/null and b/dist/images/storelogo.scale-100.png differ diff --git a/dist/images/storelogo.scale-125.png b/dist/images/storelogo.scale-125.png new file mode 100644 index 000000000..3841ebfaf Binary files /dev/null and b/dist/images/storelogo.scale-125.png differ diff --git a/dist/images/storelogo.scale-150.png b/dist/images/storelogo.scale-150.png new file mode 100644 index 000000000..adc3f9afe Binary files /dev/null and b/dist/images/storelogo.scale-150.png differ diff --git a/dist/images/storelogo.scale-200.png b/dist/images/storelogo.scale-200.png new file mode 100644 index 000000000..639fcff58 Binary files /dev/null and b/dist/images/storelogo.scale-200.png differ diff --git a/dist/images/storelogo.scale-400.png b/dist/images/storelogo.scale-400.png new file mode 100644 index 000000000..9c004d00a Binary files /dev/null and b/dist/images/storelogo.scale-400.png differ diff --git a/dist/images/web_hi_res_512.png b/dist/images/web_hi_res_512.png new file mode 100644 index 000000000..abd8a8dc9 Binary files /dev/null and b/dist/images/web_hi_res_512.png differ diff --git a/dist/index.html b/dist/index.html new file mode 100644 index 000000000..4cd4a69f7 --- /dev/null +++ b/dist/index.html @@ -0,0 +1,8 @@ + + + + +Redirection to index.html + + + \ No newline at end of file diff --git a/dist/main.cjs b/dist/main.cjs new file mode 100644 index 000000000..905d597a0 --- /dev/null +++ b/dist/main.cjs @@ -0,0 +1,294 @@ +// Modules to control application life and create native browser window +const { app, dialog, ipcMain, BrowserWindow, shell } = require('electron'); +const express = require('express'); +const Store = require('electron-store'); +const path = require('path'); +const { autoUpdater } = require('electron-updater'); +const contextMenu = require('electron-context-menu'); +// const https = require('https'); +// const fs = require('fs'); + +const store = new Store(); + +let expressServer; // This gets populated in the startServer function + +// Get the stored port value or standard value if not set +// Use these values: +// 3000: Main App +// 3001: WikiMed +// 3002: WikiVoyage +let port = 3000; +// Check if we previously stored a different port, and validate it for security +if (store.has('expressPort')) { + const storedPort = store.get('expressPort'); + if (typeof storedPort === 'number' && storedPort >= 3000 && storedPort <= 3999) { + port = storedPort; + } +} +console.log('Express Port: ' + port); + +app.commandLine.appendSwitch('enable-experimental-web-platform-features'); + +contextMenu({ + labels: { + cut: 'Cut', + copy: 'Copy', + paste: 'Paste', + save: 'Save Image', + saveImageAs: 'Save Image As…', + copyLink: 'Copy Link', + saveLinkAs: 'Save Link As…', + inspect: 'Inspect Element' + }, + prepend: () => { }, + append: () => { }, + showCopyImageAddress: true, + showSaveImageAs: true, + showInspectElement: true, + showSaveLinkAs: true, + cut: true, + copy: true, + paste: true, + save: true, + saveImageAs: true, + copyLink: true, + saveLinkAs: true, + inspect: true +}); + +let mainWindow; + +function createWindow () { + // Create the browser window. + mainWindow = new BrowserWindow({ + // titleBarStyle: 'hidden', + width: 1281, + height: 800, + minWidth: 640, + minHeight: 480, + autoHideMenuBar: true, + icon: path.join(__dirname, 'www/img/icons/kiwix-64.png'), + // titleBarStyle: 'hidden', + // titleBarOverlay: { + // color: '#000000', + // symbolColor: '#ffffff', + // height: 16 + // }, + webPreferences: { + preload: path.join(__dirname, 'preload.cjs'), + nativeWindowOpen: true, + nodeIntegrationInWorker: true, + nodeIntegration: false, + contextIsolation: true + // enableRemoteModule: false, + // sandbox: true + } + }); + + // DEV: Uncomment this to open dev tools early in load process + // mainWindow.webContents.openDevTools(); + + // mainWindow.loadFile('www/index.html'); + mainWindow.loadURL('http://localhost:' + port + '/www/index.html'); +} + +function registerListeners () { + ipcMain.on('file-dialog', function (event) { + dialog.showOpenDialog(mainWindow, { + filters: [ + { name: 'ZIM Archives', extensions: ['zim', 'zimaa'] } + ], + properties: ['openFile'] + }).then(function ({ filePaths }) { + if (filePaths.length) { + event.reply('file-dialog', filePaths[0]); + } + }); + }); + ipcMain.on('dir-dialog', function (event) { + dialog.showOpenDialog(mainWindow, { + properties: ['openDirectory'] + }).then(function ({ filePaths }) { + if (filePaths.length) { + event.reply('dir-dialog', filePaths[0]); + } + }); + }); + ipcMain.on('check-updates', function (event) { + console.log('Auto-update check request received...\n'); + autoUpdater.checkForUpdates(); + }); + // Set a value using the Electron Store API + ipcMain.on('set-store-value', function (event, key, value) { + console.log('Setting store value for key ' + key + ' to ' + value); + store.set(key, value); + }); + // Get a value from the Electron Store API + ipcMain.on('get-store-value', function (event, key) { + var value = store.get(key); + console.log('Store value for key ' + key + ' is ' + value); + event.reply('get-store-value', key, value); + }); + ipcMain.on('open-external', function (event, url) { + console.log('Opening external URL: ' + url); + shell.openExternal(url); + }); + // Registers listener for download events + mainWindow.webContents.session.on('will-download', (event, item, webContents) => { + // Set the save path, making Electron not to prompt a save dialog. + // item.setSavePath('/tmp/save.pdf') + let receivedBytes = 0; + item.on('updated', (event, state) => { + if (state === 'interrupted') { + console.log('Download is interrupted but can be resumed'); + mainWindow.webContents.send('dl-received', state); + } else if (state === 'progressing') { + if (item.isPaused()) { + console.log('Download is paused'); + mainWindow.webContents.send('dl-received', 'paused'); + } else { + const newReceivedBytes = item.getReceivedBytes(); + const totalBytes = item.getTotalBytes(); + if (newReceivedBytes - receivedBytes < 250000) return; + receivedBytes = newReceivedBytes; + mainWindow.webContents.send('dl-received', receivedBytes, totalBytes); + } + } + }); + item.once('done', (event, state) => { + if (state === 'completed') { + console.log('Download successful'); + } else { + console.log(`Download failed: ${state}`); + } + mainWindow.webContents.send('dl-received', state); + }); + }); +} + +// Get the launch file path +function processLaunchFilePath (arg) { + console.log('Scanning for launch file path...'); + var openFilePath = null; + if (arg && arg.length >= 2) { + for (var i = 0; i < arg.length; i++) { + console.log('Arg ' + i + ': ' + arg[i]); + if (/\.zim(?:\w\w)?$/i.test(arg[i])) { + openFilePath = arg[i]; + break; + } + } + console.log('Launch file path: ' + openFilePath); + } + return openFilePath; +} + +// Prevent launching multiple instances for now (they are not isolated) +// Code from https://stackoverflow.com/a/73669484/9727685 +// Behaviour on second instance for parent process +const gotSingleInstanceLock = app.requestSingleInstanceLock(); +if (!gotSingleInstanceLock) { + app.quit(); // Quits the app if app.requestSingleInstanceLock() returns false +} else { + app.on('second-instance', (_, argv) => { + // User requested a second instance of the app. + // argv has the process.argv arguments of the second instance. + if (app.hasSingleInstanceLock()) { + if (mainWindow) { + if (mainWindow.isMinimized()) { + mainWindow.restore(); + } + mainWindow.focus(); + const launchFilePath = processLaunchFilePath(argv); + mainWindow.webContents.send('get-launch-file-path', launchFilePath); + } + } + }); +} + +// SSL options +// var options = { +// key: fs.readFileSync('path/to/your/key.pem'), +// cert: fs.readFileSync('path/to/your/cert.pem') +// }; + +app.whenReady().then(() => { + const server = express() + + // Add security headers + server.use((req, res, next) => { + res.setHeader('X-Content-Type-Options', 'nosniff'); + // res.setHeader('X-Frame-Options', 'SAMEORIGIN'); + res.setHeader('X-XSS-Protection', '1; mode=block'); + // We already set the CSP in the HTML file and in the SErviceWorker... + // res.setHeader('Content-Security-Policy', "default-src 'self'"); + next(); + }); + + // Serve static files from the www directory + server.use(express.static(path.join(__dirname, '/'))); + + // Function to start the Express server and check for port availability + const startServer = (port) => { + if (port > 3999) { // Set a reasonable maximum + console.error('Unable to find available port in acceptable range'); + // Remove the expressPort key from the store so app will try again on restart + store.delete('expressPort'); + app.quit(); + return; + } + expressServer = server.listen(port, () => { + console.log(`Server running on port ${port}`); + // Create the new window + createWindow(); + registerListeners(); + mainWindow.webContents.on('did-finish-load', () => { + const launchFilePath = processLaunchFilePath(process.argv); + mainWindow.webContents.send('get-launch-file-path', launchFilePath); + }); + }).on('error', (err) => { + if (err.code === 'EADDRINUSE') { + const newPort = port + 10; + console.log(`Port ${port} is already in use, trying port ${newPort}`); + store.set('expressPort', newPort); + startServer(newPort); // Try the next port + } else { + console.error(err); + app.quit(); // Or handle error differently + } + }); + }; + + startServer(port); + + var appName = app.getName(); + console.log('App name: ' + appName); + + // Send message to renderer if update is available + autoUpdater.on('update-downloaded', function (info) { + mainWindow.webContents.send('update-available', info); + }); + autoUpdater.on('download-progress', function (info) { + mainWindow.webContents.send('update-available', info); + }); + + app.on('activate', function () { + // On macOS it's common to re-create a window in the app when the + // dock icon is clicked and there are no other windows open. + if (BrowserWindow.getAllWindows().length === 0) createWindow(); + }); +}); + +// Quit when all windows are closed. +app.on('window-all-closed', function () { + // On macOS it is common for applications and their menu bar + // to stay active until the user quits explicitly with Cmd + Q + if (process.platform !== 'darwin') app.quit(); +}); + +// Explicit shutdown of the Express server for security +app.on('before-quit', () => { + if (expressServer) { + expressServer.close(); + } +}); diff --git a/dist/manifest.json b/dist/manifest.json new file mode 100644 index 000000000..cbb8e9592 --- /dev/null +++ b/dist/manifest.json @@ -0,0 +1,67 @@ +{ + "dir": "ltr", + "lang": "en-GB", + "name": "Kiwix JS PWA Edition", + "display": "standalone", + "display_override": ["window-controls-overlay", "standalone", "browser"], + "edge_side_panel": { + "preferred_width": 496 + }, + "categories": ["reference", "books", "education"], + "iarc_rating_id": "3596f0d9-387e-4d64-a165-5fef16a6c8e3", + "start_url": ".", + "short_name": "Kiwix PWA", + "theme_color": "#2F4F4F", + "description": "Kiwix is an offline reader for content from Wikipedia, Project Gutenberg, TED Talks, Wikivoyage, Stackexchange, and many other Web archives. It makes knowledge available to people with limited or no Internet access.", + "background_color": "#000", + "related_applications": [ + { + "platform": "windows", + "url": "https://apps.microsoft.com/detail/9P8SLZ4J979J", + "id": "9P8SLZ4J979J" + } + ], + "prefer_related_applications": false, + "icons": [ + { + "src": "www/img/icons/kiwix-48.png", + "sizes": "48x48", + "type": "image/png" + }, + { + "src": "www/img/icons/kiwix-64.ico", + "sizes": "64x64", + "type": "image/ico" + }, + { + "src": "www/img/icons/kiwix-192.png", + "sizes": "192x192", + "type": "image/png" + }, + { + "src": "www/img/icons/kiwix-256.png", + "sizes": "256x256", + "type": "image/png" + }, + { + "src": "www/img/icons/kiwix-512.png", + "sizes": "512x512", + "type": "image/png" + } + ], + "file_handlers": [ + { + "action": "www/index.html", + "accept": { + "application/octet-stream": [ ".zim" ] + }, + "icons": [ + { + "src": "www/img/icons/kiwix-256.png", + "sizes": "256x256", + "type": "image/png" + } + ],"launch_type": "single-client" + } + ] +} diff --git a/dist/package-github.appxmanifest b/dist/package-github.appxmanifest new file mode 100644 index 000000000..40b698308 --- /dev/null +++ b/dist/package-github.appxmanifest @@ -0,0 +1,57 @@ + + + + + + Kiwix JS + Kiwix + images\storelogo.png + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ZIM Archive + images\Kiwix_midnightblue_icon_transparent_530.png + Compressed ZIM FIle Archive + + .zim + .zimaa + + + + + + + + + + diff --git a/dist/package.appxmanifest b/dist/package.appxmanifest new file mode 100644 index 000000000..4b68b267f --- /dev/null +++ b/dist/package.appxmanifest @@ -0,0 +1,57 @@ + + + + + + Kiwix JS + Kiwix + images\storelogo.png + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ZIM Archive + images\Kiwix_midnightblue_icon_transparent_530.png + Compressed ZIM FIle Archive + + .zim + .zimaa + + + + + + + + + + diff --git a/dist/package.json b/dist/package.json new file mode 100644 index 000000000..146e4340e --- /dev/null +++ b/dist/package.json @@ -0,0 +1,188 @@ +{ + "name": "kiwix-js-electron", + "productName": "Kiwix JS Electron", + "version": "3.4.8-E", + "description": "Kiwix JS offline ZIM archive reader packaged for the Electron framework", + "main": "main.cjs", + "type": "module", + "build": { + "appId": "kiwix.js.electron", + "productName": "Kiwix JS Electron", + "directories": { + "output": "bld/Electron", + "buildResources": "../electron_icons" + }, + "win": { + "certificateSha1": "82B88B62A6F87FBA62B2C933D747E52EDBF0F7F6", + "signingHashAlgorithms": [ + "sha256" + ], + "rfc3161TimeStampServer": "http://ts.ssl.com", + "asar": "true", + "extraResources": { + "from": "archives", + "to": "archives" + }, + "publish": [ + "github" + ], + "target": [ + { + "target": "NSIS", + "arch": "ia32" + }, + { + "target": "portable", + "arch": "ia32" + }, + { + "target": "appx" + }, + { + "target": "nsis-web", + "arch": "ia32" + }, + { + "target": "nsis-web", + "arch": "x64" + }, + { + "target": "nsis-web", + "arch": "arm64" + } + ] + }, + "linux": { + "asar": "true", + "extraResources": { + "from": "archives", + "to": "archives" + }, + "publish": [ + "github" + ], + "target": [ + { + "target": "AppImage", + "arch": [ + "x64", + "arm64" + ] + }, + { + "target": "deb", + "arch": [ + "x64" + ] + }, + { + "target": "rpm", + "arch": [ + "x64" + ] + } + ], + "category": "Education" + }, + "nsis": { + "oneClick": "false", + "allowElevation": "true", + "runAfterFinish": "true" + }, + "nsisWeb": { + "oneClick": "false", + "allowElevation": "true", + "runAfterFinish": "true" + }, + "appx": { + "backgroundColor": "transparent", + "displayName": "Kiwix JS", + "identityName": "Kiwix.KiwixJS", + "publisher": "CN=Association Kiwix, O=Association Kiwix, L=Lausanne, S=Canton of Vaud, C=CH", + "publisherDisplayName": "Association Kiwix", + "languages": "en-GB", + "showNameOnTiles": "true" + }, + "files": [ + "service-worker.js", + "index.html", + "CHANGELOG.md", + "LICENCE", + "manifest.json", + "replayWorker.js", + "www/**", + "preload.cjs", + "main.cjs", + "!**/*.dev.{js,wasm}" + ] + }, + "scripts": { + "serve": "vite", + "preview": "del-cli dist && npm run build-src && vite preview", + "prebuild": "del-cli dist", + "build": "rollup --config --file dist/www/js/bundle.js && rollup --config --file dist/www/js/bundle.min.js --environment BUILD:production", + "prebuild-min": "del-cli dist", + "build-min": "rollup --config --file dist/www/js/bundle.min.js --environment BUILD:production", + "prebuild-src": "del-cli dist", + "build-src": "rollup --config --file dist/www/js/bundle.js", + "del": "del-cli dist", + "start": "electron .", + "dist-win": "electron-builder build --win --projectDir dist", + "dist-win-arm64": "electron-builder build --win NSIS:arm64 --projectDir dist", + "dist-win-nsis": "electron-builder build --win NSIS:ia32 --publish never --projectDir dist", + "dist-win-nsis-skipsigning": "electron-builder build --config ../scripts/electronBuilder.cjs --win NSIS:ia32 --publish never --projectDir dist", + "dist-win-nisis-x64": "electron-builder build --win NSIS:x64 --publish never --projectDir dist", + "dist-linux": "electron-builder build --linux --projectDir dist", + "dist-linux-appimage": "electron-builder build --linux AppImage:x64 --projectDir dist", + "publish": "electron-builder build --projectDir dist", + "build-skipsigning": "electron-builder build --config ../scripts/electronBuilder.cjs --publish never --projectDir dist", + "postpackage-win": "(robocopy archives bld\\Electron\\kiwix-js-pwa-win32-ia32\\resources\\app\\archives\\ > null) ^& IF %ERRORLEVEL% LSS 8 SET ERRORLEVEL = 0", + "postpackage-linux": "(robocopy archives bld\\Electron\\kiwix-js-pwa-linux-x64\\archives\\ > null) ^& IF %ERRORLEVEL% LSS 8 SET ERRORLEVEL = 0" + }, + "repository": "https://github.com/kiwix/kiwix-js-pwa", + "keywords": [ + "Kiwix", + "offline", + "Wikipedia", + "ZIM", + "reader" + ], + "author": { + "name": "Kiwix", + "email": "kiwix@kiwix.org" + }, + "maintainer": "Jaifroid", + "license": "CC0-1.0", + "devDependencies": { + "@babel/cli": "^7.21.5", + "@babel/core": "^7.21.5", + "@babel/preset-env": "^7.21.5", + "@rollup/plugin-babel": "^6.0.4", + "@rollup/plugin-commonjs": "^25.0.7", + "@rollup/plugin-node-resolve": "^15.2.3", + "@rollup/plugin-replace": "^5.0.5", + "@rollup/plugin-terser": "^0.4.4", + "@vitejs/plugin-legacy": "^4.0.3", + "babel-plugin-polyfill-corejs3": "^0.7.1", + "del-cli": "^5.0.0", + "electron": "29.3.1", + "electron-builder": "^24.13.3", + "eslint": "^8.42.0", + "eslint-config-standard": "^17.1.0", + "eslint-plugin-import": "^2.27.5", + "eslint-plugin-n": "^16.0.0", + "eslint-plugin-promise": "^6.1.1", + "rollup": "^4.5.0", + "rollup-plugin-copy": "^3.4.0", + "vite": "^4.5.3" + }, + "dependencies": { + "@types/fs-extra": "^9.0.11", + "core-js": "3.30.2", + "electron-context-menu": "^3.1.1", + "electron-store": "^8.1.0", + "electron-updater": "^6.2.1", + "express": "^4.21.0", + "jquery": "^3.7.1" + } +} diff --git a/dist/preload.cjs b/dist/preload.cjs new file mode 100644 index 000000000..244c94d1e --- /dev/null +++ b/dist/preload.cjs @@ -0,0 +1,76 @@ +// All of the Node.js APIs are available in the preload process. +// It has the same sandbox as a Chrome extension. + +'use strict'; + +// A regular expression that matches the hash of the Kiwix publisher on the Microsoft Store (CN=0A5438F5-EEA6-4300-9B77-E45BBD148885) +// If the app is installed from the Store rather than from the signed GitHub release, we need to disable update checking +const regexpInstalledFromMicrosoftStore = /_mc3511b08yc0e/; +console.log('[Preload] App directory: ' + __dirname); +console.log('[Preload] Is app installed from Microsoft Store? ' + (process.windowsStore && regexpInstalledFromMicrosoftStore.test(__dirname) ? 'Yes' : 'No')); +console.log('[Preload] Window location: ' + window.location.pathname + '\nStore publisher hash: ' + regexpInstalledFromMicrosoftStore); + +// DEV: TO SUPPORT ELECTRON ^12 YOU WILL NEED THIS +const { ipcRenderer, contextBridge, webFrame } = require('electron'); +const { open, read, close, stat, readdir } = require('fs'); + +console.log('Inserting required Electron functions into DOM...'); + +// DEV: FOR ELECTRON ^12 DO IT THIS WAY: +contextBridge.exposeInMainWorld('fs', { + open: open, + read: read, + readdir: readdir, + close: close, + stat: stat +}); +// Exposed events and Event callback for electronAPI (you can add events to listen to, so long as main.js sends a message with name of the event) +contextBridge.exposeInMainWorld('electronAPI', { + checkForUpdates: function () { + ipcRenderer.send('check-updates'); + }, + setStoreValue: function (key, value) { + ipcRenderer.send('set-store-value', key, value); + }, + getStoreValue: function (key) { + ipcRenderer.send('get-store-value', key); + }, + openExternal: function (url) { + ipcRenderer.send('open-external', url); + }, + setZoomLimits: function (min, max) { + console.log('Setting zoom limits to ' + min + ' and ' + max); + webFrame.setVisualZoomLevelLimits(min, max); + }, + isMicrosoftStoreApp: process.windowsStore && regexpInstalledFromMicrosoftStore.test(__dirname), + __dirname: __dirname, + on: function (event, callback) { + ipcRenderer.on(event, function (_, data1, data2) { + callback(data1, data2); + }); + } +}); + +// Adapted from: https://stackoverflow.com/questions/69717365/using-electron-save-dialog-in-renderer-with-context-isolation +contextBridge.exposeInMainWorld('dialog', { + openFile: function () { + ipcRenderer.send('file-dialog'); // adjust naming for your project + }, + openDirectory: function () { + ipcRenderer.send('dir-dialog'); // adjust naming for your project + }, + // Provide an easier way to listen to events + on: function (channel, callback) { + ipcRenderer.on(channel, function (_, data) { + callback(data); + }); + } +}); + +// window.Buffer = Buffer; + +// console.log(win.session.cookies); + +// win.session.cookies.get({}, (error, cookies) => { +// console.log(cookies); +// }); diff --git a/dist/replayWorker.js b/dist/replayWorker.js new file mode 100644 index 000000000..4c3dd21cb --- /dev/null +++ b/dist/replayWorker.js @@ -0,0 +1,60349 @@ +/*! sw.js is part of Webrecorder project. Copyright (C) 2020-2023, Webrecorder Software. Licensed under the Affero General Public License v3. */ +/******/ (() => { // webpackBootstrap +/******/ var __webpack_modules__ = ({ + +/***/ 9742: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + + +exports.byteLength = byteLength +exports.toByteArray = toByteArray +exports.fromByteArray = fromByteArray + +var lookup = [] +var revLookup = [] +var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array + +var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/' +for (var i = 0, len = code.length; i < len; ++i) { + lookup[i] = code[i] + revLookup[code.charCodeAt(i)] = i +} + +// Support decoding URL-safe base64 strings, as Node.js does. +// See: https://en.wikipedia.org/wiki/Base64#URL_applications +revLookup['-'.charCodeAt(0)] = 62 +revLookup['_'.charCodeAt(0)] = 63 + +function getLens (b64) { + var len = b64.length + + if (len % 4 > 0) { + throw new Error('Invalid string. Length must be a multiple of 4') + } + + // Trim off extra bytes after placeholder bytes are found + // See: https://github.com/beatgammit/base64-js/issues/42 + var validLen = b64.indexOf('=') + if (validLen === -1) validLen = len + + var placeHoldersLen = validLen === len + ? 0 + : 4 - (validLen % 4) + + return [validLen, placeHoldersLen] +} + +// base64 is 4/3 + up to two characters of the original data +function byteLength (b64) { + var lens = getLens(b64) + var validLen = lens[0] + var placeHoldersLen = lens[1] + return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen +} + +function _byteLength (b64, validLen, placeHoldersLen) { + return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen +} + +function toByteArray (b64) { + var tmp + var lens = getLens(b64) + var validLen = lens[0] + var placeHoldersLen = lens[1] + + var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen)) + + var curByte = 0 + + // if there are placeholders, only get up to the last complete 4 chars + var len = placeHoldersLen > 0 + ? validLen - 4 + : validLen + + var i + for (i = 0; i < len; i += 4) { + tmp = + (revLookup[b64.charCodeAt(i)] << 18) | + (revLookup[b64.charCodeAt(i + 1)] << 12) | + (revLookup[b64.charCodeAt(i + 2)] << 6) | + revLookup[b64.charCodeAt(i + 3)] + arr[curByte++] = (tmp >> 16) & 0xFF + arr[curByte++] = (tmp >> 8) & 0xFF + arr[curByte++] = tmp & 0xFF + } + + if (placeHoldersLen === 2) { + tmp = + (revLookup[b64.charCodeAt(i)] << 2) | + (revLookup[b64.charCodeAt(i + 1)] >> 4) + arr[curByte++] = tmp & 0xFF + } + + if (placeHoldersLen === 1) { + tmp = + (revLookup[b64.charCodeAt(i)] << 10) | + (revLookup[b64.charCodeAt(i + 1)] << 4) | + (revLookup[b64.charCodeAt(i + 2)] >> 2) + arr[curByte++] = (tmp >> 8) & 0xFF + arr[curByte++] = tmp & 0xFF + } + + return arr +} + +function tripletToBase64 (num) { + return lookup[num >> 18 & 0x3F] + + lookup[num >> 12 & 0x3F] + + lookup[num >> 6 & 0x3F] + + lookup[num & 0x3F] +} + +function encodeChunk (uint8, start, end) { + var tmp + var output = [] + for (var i = start; i < end; i += 3) { + tmp = + ((uint8[i] << 16) & 0xFF0000) + + ((uint8[i + 1] << 8) & 0xFF00) + + (uint8[i + 2] & 0xFF) + output.push(tripletToBase64(tmp)) + } + return output.join('') +} + +function fromByteArray (uint8) { + var tmp + var len = uint8.length + var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes + var parts = [] + var maxChunkLength = 16383 // must be multiple of 3 + + // go through the array every three bytes, we'll deal with trailing stuff later + for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) { + parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength))) + } + + // pad the end with zeros, but make sure to not forget the extra bytes + if (extraBytes === 1) { + tmp = uint8[len - 1] + parts.push( + lookup[tmp >> 2] + + lookup[(tmp << 4) & 0x3F] + + '==' + ) + } else if (extraBytes === 2) { + tmp = (uint8[len - 2] << 8) + uint8[len - 1] + parts.push( + lookup[tmp >> 10] + + lookup[(tmp >> 4) & 0x3F] + + lookup[(tmp << 2) & 0x3F] + + '=' + ) + } + + return parts.join('') +} + + +/***/ }), + +/***/ 4181: +/***/ ((module) => { + +/* Copyright 2013 Google Inc. All Rights Reserved. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + Bit reading helpers +*/ + +var BROTLI_READ_SIZE = 4096; +var BROTLI_IBUF_SIZE = (2 * BROTLI_READ_SIZE + 32); +var BROTLI_IBUF_MASK = (2 * BROTLI_READ_SIZE - 1); + +var kBitMask = new Uint32Array([ + 0, 1, 3, 7, 15, 31, 63, 127, 255, 511, 1023, 2047, 4095, 8191, 16383, 32767, + 65535, 131071, 262143, 524287, 1048575, 2097151, 4194303, 8388607, 16777215 +]); + +/* Input byte buffer, consist of a ringbuffer and a "slack" region where */ +/* bytes from the start of the ringbuffer are copied. */ +function BrotliBitReader(input) { + this.buf_ = new Uint8Array(BROTLI_IBUF_SIZE); + this.input_ = input; /* input callback */ + + this.reset(); +} + +BrotliBitReader.READ_SIZE = BROTLI_READ_SIZE; +BrotliBitReader.IBUF_MASK = BROTLI_IBUF_MASK; + +BrotliBitReader.prototype.reset = function() { + this.buf_ptr_ = 0; /* next input will write here */ + this.val_ = 0; /* pre-fetched bits */ + this.pos_ = 0; /* byte position in stream */ + this.bit_pos_ = 0; /* current bit-reading position in val_ */ + this.bit_end_pos_ = 0; /* bit-reading end position from LSB of val_ */ + this.eos_ = 0; /* input stream is finished */ + + this.readMoreInput(); + for (var i = 0; i < 4; i++) { + this.val_ |= this.buf_[this.pos_] << (8 * i); + ++this.pos_; + } + + return this.bit_end_pos_ > 0; +}; + +/* Fills up the input ringbuffer by calling the input callback. + + Does nothing if there are at least 32 bytes present after current position. + + Returns 0 if either: + - the input callback returned an error, or + - there is no more input and the position is past the end of the stream. + + After encountering the end of the input stream, 32 additional zero bytes are + copied to the ringbuffer, therefore it is safe to call this function after + every 32 bytes of input is read. +*/ +BrotliBitReader.prototype.readMoreInput = function() { + if (this.bit_end_pos_ > 256) { + return; + } else if (this.eos_) { + if (this.bit_pos_ > this.bit_end_pos_) + throw new Error('Unexpected end of input ' + this.bit_pos_ + ' ' + this.bit_end_pos_); + } else { + var dst = this.buf_ptr_; + var bytes_read = this.input_.read(this.buf_, dst, BROTLI_READ_SIZE); + if (bytes_read < 0) { + throw new Error('Unexpected end of input'); + } + + if (bytes_read < BROTLI_READ_SIZE) { + this.eos_ = 1; + /* Store 32 bytes of zero after the stream end. */ + for (var p = 0; p < 32; p++) + this.buf_[dst + bytes_read + p] = 0; + } + + if (dst === 0) { + /* Copy the head of the ringbuffer to the slack region. */ + for (var p = 0; p < 32; p++) + this.buf_[(BROTLI_READ_SIZE << 1) + p] = this.buf_[p]; + + this.buf_ptr_ = BROTLI_READ_SIZE; + } else { + this.buf_ptr_ = 0; + } + + this.bit_end_pos_ += bytes_read << 3; + } +}; + +/* Guarantees that there are at least 24 bits in the buffer. */ +BrotliBitReader.prototype.fillBitWindow = function() { + while (this.bit_pos_ >= 8) { + this.val_ >>>= 8; + this.val_ |= this.buf_[this.pos_ & BROTLI_IBUF_MASK] << 24; + ++this.pos_; + this.bit_pos_ = this.bit_pos_ - 8 >>> 0; + this.bit_end_pos_ = this.bit_end_pos_ - 8 >>> 0; + } +}; + +/* Reads the specified number of bits from Read Buffer. */ +BrotliBitReader.prototype.readBits = function(n_bits) { + if (32 - this.bit_pos_ < n_bits) { + this.fillBitWindow(); + } + + var val = ((this.val_ >>> this.bit_pos_) & kBitMask[n_bits]); + this.bit_pos_ += n_bits; + return val; +}; + +module.exports = BrotliBitReader; + + +/***/ }), + +/***/ 7080: +/***/ ((__unused_webpack_module, exports) => { + +/* Copyright 2013 Google Inc. All Rights Reserved. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + Lookup table to map the previous two bytes to a context id. + + There are four different context modeling modes defined here: + CONTEXT_LSB6: context id is the least significant 6 bits of the last byte, + CONTEXT_MSB6: context id is the most significant 6 bits of the last byte, + CONTEXT_UTF8: second-order context model tuned for UTF8-encoded text, + CONTEXT_SIGNED: second-order context model tuned for signed integers. + + The context id for the UTF8 context model is calculated as follows. If p1 + and p2 are the previous two bytes, we calcualte the context as + + context = kContextLookup[p1] | kContextLookup[p2 + 256]. + + If the previous two bytes are ASCII characters (i.e. < 128), this will be + equivalent to + + context = 4 * context1(p1) + context2(p2), + + where context1 is based on the previous byte in the following way: + + 0 : non-ASCII control + 1 : \t, \n, \r + 2 : space + 3 : other punctuation + 4 : " ' + 5 : % + 6 : ( < [ { + 7 : ) > ] } + 8 : , ; : + 9 : . + 10 : = + 11 : number + 12 : upper-case vowel + 13 : upper-case consonant + 14 : lower-case vowel + 15 : lower-case consonant + + and context2 is based on the second last byte: + + 0 : control, space + 1 : punctuation + 2 : upper-case letter, number + 3 : lower-case letter + + If the last byte is ASCII, and the second last byte is not (in a valid UTF8 + stream it will be a continuation byte, value between 128 and 191), the + context is the same as if the second last byte was an ASCII control or space. + + If the last byte is a UTF8 lead byte (value >= 192), then the next byte will + be a continuation byte and the context id is 2 or 3 depending on the LSB of + the last byte and to a lesser extent on the second last byte if it is ASCII. + + If the last byte is a UTF8 continuation byte, the second last byte can be: + - continuation byte: the next byte is probably ASCII or lead byte (assuming + 4-byte UTF8 characters are rare) and the context id is 0 or 1. + - lead byte (192 - 207): next byte is ASCII or lead byte, context is 0 or 1 + - lead byte (208 - 255): next byte is continuation byte, context is 2 or 3 + + The possible value combinations of the previous two bytes, the range of + context ids and the type of the next byte is summarized in the table below: + + |--------\-----------------------------------------------------------------| + | \ Last byte | + | Second \---------------------------------------------------------------| + | last byte \ ASCII | cont. byte | lead byte | + | \ (0-127) | (128-191) | (192-) | + |=============|===================|=====================|==================| + | ASCII | next: ASCII/lead | not valid | next: cont. | + | (0-127) | context: 4 - 63 | | context: 2 - 3 | + |-------------|-------------------|---------------------|------------------| + | cont. byte | next: ASCII/lead | next: ASCII/lead | next: cont. | + | (128-191) | context: 4 - 63 | context: 0 - 1 | context: 2 - 3 | + |-------------|-------------------|---------------------|------------------| + | lead byte | not valid | next: ASCII/lead | not valid | + | (192-207) | | context: 0 - 1 | | + |-------------|-------------------|---------------------|------------------| + | lead byte | not valid | next: cont. | not valid | + | (208-) | | context: 2 - 3 | | + |-------------|-------------------|---------------------|------------------| + + The context id for the signed context mode is calculated as: + + context = (kContextLookup[512 + p1] << 3) | kContextLookup[512 + p2]. + + For any context modeling modes, the context ids can be calculated by |-ing + together two lookups from one table using context model dependent offsets: + + context = kContextLookup[offset1 + p1] | kContextLookup[offset2 + p2]. + + where offset1 and offset2 are dependent on the context mode. +*/ + +var CONTEXT_LSB6 = 0; +var CONTEXT_MSB6 = 1; +var CONTEXT_UTF8 = 2; +var CONTEXT_SIGNED = 3; + +/* Common context lookup table for all context modes. */ +exports.lookup = new Uint8Array([ + /* CONTEXT_UTF8, last byte. */ + /* ASCII range. */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 0, 4, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 8, 12, 16, 12, 12, 20, 12, 16, 24, 28, 12, 12, 32, 12, 36, 12, + 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 32, 32, 24, 40, 28, 12, + 12, 48, 52, 52, 52, 48, 52, 52, 52, 48, 52, 52, 52, 52, 52, 48, + 52, 52, 52, 52, 52, 48, 52, 52, 52, 52, 52, 24, 12, 28, 12, 12, + 12, 56, 60, 60, 60, 56, 60, 60, 60, 56, 60, 60, 60, 60, 60, 56, + 60, 60, 60, 60, 60, 56, 60, 60, 60, 60, 60, 24, 12, 28, 12, 0, + /* UTF8 continuation byte range. */ + 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, + 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, + 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, + 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, + /* UTF8 lead byte range. */ + 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, + 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, + 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, + 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, + /* CONTEXT_UTF8 second last byte. */ + /* ASCII range. */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, + 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, + 1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 1, 1, 1, 1, 0, + /* UTF8 continuation byte range. */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* UTF8 lead byte range. */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + /* CONTEXT_SIGNED, second last byte. */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, + /* CONTEXT_SIGNED, last byte, same as the above values shifted by 3 bits. */ + 0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, + 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, + 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, + 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, + 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, + 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, + 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 56, + /* CONTEXT_LSB6, last byte. */ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + /* CONTEXT_MSB6, last byte. */ + 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, + 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, + 8, 8, 8, 8, 9, 9, 9, 9, 10, 10, 10, 10, 11, 11, 11, 11, + 12, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, + 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, 19, 19, 19, 19, + 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 23, 23, 23, 23, + 24, 24, 24, 24, 25, 25, 25, 25, 26, 26, 26, 26, 27, 27, 27, 27, + 28, 28, 28, 28, 29, 29, 29, 29, 30, 30, 30, 30, 31, 31, 31, 31, + 32, 32, 32, 32, 33, 33, 33, 33, 34, 34, 34, 34, 35, 35, 35, 35, + 36, 36, 36, 36, 37, 37, 37, 37, 38, 38, 38, 38, 39, 39, 39, 39, + 40, 40, 40, 40, 41, 41, 41, 41, 42, 42, 42, 42, 43, 43, 43, 43, + 44, 44, 44, 44, 45, 45, 45, 45, 46, 46, 46, 46, 47, 47, 47, 47, + 48, 48, 48, 48, 49, 49, 49, 49, 50, 50, 50, 50, 51, 51, 51, 51, + 52, 52, 52, 52, 53, 53, 53, 53, 54, 54, 54, 54, 55, 55, 55, 55, + 56, 56, 56, 56, 57, 57, 57, 57, 58, 58, 58, 58, 59, 59, 59, 59, + 60, 60, 60, 60, 61, 61, 61, 61, 62, 62, 62, 62, 63, 63, 63, 63, + /* CONTEXT_{M,L}SB6, second last byte, */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +]); + +exports.lookupOffsets = new Uint16Array([ + /* CONTEXT_LSB6 */ + 1024, 1536, + /* CONTEXT_MSB6 */ + 1280, 1536, + /* CONTEXT_UTF8 */ + 0, 256, + /* CONTEXT_SIGNED */ + 768, 512, +]); + + +/***/ }), + +/***/ 6450: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +var __webpack_unused_export__; +/* Copyright 2013 Google Inc. All Rights Reserved. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ + +var BrotliInput = (__webpack_require__(6154)/* .BrotliInput */ .g); +var BrotliOutput = (__webpack_require__(6154)/* .BrotliOutput */ .j); +var BrotliBitReader = __webpack_require__(4181); +var BrotliDictionary = __webpack_require__(5139); +var HuffmanCode = (__webpack_require__(966)/* .HuffmanCode */ .h); +var BrotliBuildHuffmanTable = (__webpack_require__(966)/* .BrotliBuildHuffmanTable */ .g); +var Context = __webpack_require__(7080); +var Prefix = __webpack_require__(8435); +var Transform = __webpack_require__(2973); + +var kDefaultCodeLength = 8; +var kCodeLengthRepeatCode = 16; +var kNumLiteralCodes = 256; +var kNumInsertAndCopyCodes = 704; +var kNumBlockLengthCodes = 26; +var kLiteralContextBits = 6; +var kDistanceContextBits = 2; + +var HUFFMAN_TABLE_BITS = 8; +var HUFFMAN_TABLE_MASK = 0xff; +/* Maximum possible Huffman table size for an alphabet size of 704, max code + * length 15 and root table bits 8. */ +var HUFFMAN_MAX_TABLE_SIZE = 1080; + +var CODE_LENGTH_CODES = 18; +var kCodeLengthCodeOrder = new Uint8Array([ + 1, 2, 3, 4, 0, 5, 17, 6, 16, 7, 8, 9, 10, 11, 12, 13, 14, 15, +]); + +var NUM_DISTANCE_SHORT_CODES = 16; +var kDistanceShortCodeIndexOffset = new Uint8Array([ + 3, 2, 1, 0, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2 +]); + +var kDistanceShortCodeValueOffset = new Int8Array([ + 0, 0, 0, 0, -1, 1, -2, 2, -3, 3, -1, 1, -2, 2, -3, 3 +]); + +var kMaxHuffmanTableSize = new Uint16Array([ + 256, 402, 436, 468, 500, 534, 566, 598, 630, 662, 694, 726, 758, 790, 822, + 854, 886, 920, 952, 984, 1016, 1048, 1080 +]); + +function DecodeWindowBits(br) { + var n; + if (br.readBits(1) === 0) { + return 16; + } + + n = br.readBits(3); + if (n > 0) { + return 17 + n; + } + + n = br.readBits(3); + if (n > 0) { + return 8 + n; + } + + return 17; +} + +/* Decodes a number in the range [0..255], by reading 1 - 11 bits. */ +function DecodeVarLenUint8(br) { + if (br.readBits(1)) { + var nbits = br.readBits(3); + if (nbits === 0) { + return 1; + } else { + return br.readBits(nbits) + (1 << nbits); + } + } + return 0; +} + +function MetaBlockLength() { + this.meta_block_length = 0; + this.input_end = 0; + this.is_uncompressed = 0; + this.is_metadata = false; +} + +function DecodeMetaBlockLength(br) { + var out = new MetaBlockLength; + var size_nibbles; + var size_bytes; + var i; + + out.input_end = br.readBits(1); + if (out.input_end && br.readBits(1)) { + return out; + } + + size_nibbles = br.readBits(2) + 4; + if (size_nibbles === 7) { + out.is_metadata = true; + + if (br.readBits(1) !== 0) + throw new Error('Invalid reserved bit'); + + size_bytes = br.readBits(2); + if (size_bytes === 0) + return out; + + for (i = 0; i < size_bytes; i++) { + var next_byte = br.readBits(8); + if (i + 1 === size_bytes && size_bytes > 1 && next_byte === 0) + throw new Error('Invalid size byte'); + + out.meta_block_length |= next_byte << (i * 8); + } + } else { + for (i = 0; i < size_nibbles; ++i) { + var next_nibble = br.readBits(4); + if (i + 1 === size_nibbles && size_nibbles > 4 && next_nibble === 0) + throw new Error('Invalid size nibble'); + + out.meta_block_length |= next_nibble << (i * 4); + } + } + + ++out.meta_block_length; + + if (!out.input_end && !out.is_metadata) { + out.is_uncompressed = br.readBits(1); + } + + return out; +} + +/* Decodes the next Huffman code from bit-stream. */ +function ReadSymbol(table, index, br) { + var start_index = index; + + var nbits; + br.fillBitWindow(); + index += (br.val_ >>> br.bit_pos_) & HUFFMAN_TABLE_MASK; + nbits = table[index].bits - HUFFMAN_TABLE_BITS; + if (nbits > 0) { + br.bit_pos_ += HUFFMAN_TABLE_BITS; + index += table[index].value; + index += (br.val_ >>> br.bit_pos_) & ((1 << nbits) - 1); + } + br.bit_pos_ += table[index].bits; + return table[index].value; +} + +function ReadHuffmanCodeLengths(code_length_code_lengths, num_symbols, code_lengths, br) { + var symbol = 0; + var prev_code_len = kDefaultCodeLength; + var repeat = 0; + var repeat_code_len = 0; + var space = 32768; + + var table = []; + for (var i = 0; i < 32; i++) + table.push(new HuffmanCode(0, 0)); + + BrotliBuildHuffmanTable(table, 0, 5, code_length_code_lengths, CODE_LENGTH_CODES); + + while (symbol < num_symbols && space > 0) { + var p = 0; + var code_len; + + br.readMoreInput(); + br.fillBitWindow(); + p += (br.val_ >>> br.bit_pos_) & 31; + br.bit_pos_ += table[p].bits; + code_len = table[p].value & 0xff; + if (code_len < kCodeLengthRepeatCode) { + repeat = 0; + code_lengths[symbol++] = code_len; + if (code_len !== 0) { + prev_code_len = code_len; + space -= 32768 >> code_len; + } + } else { + var extra_bits = code_len - 14; + var old_repeat; + var repeat_delta; + var new_len = 0; + if (code_len === kCodeLengthRepeatCode) { + new_len = prev_code_len; + } + if (repeat_code_len !== new_len) { + repeat = 0; + repeat_code_len = new_len; + } + old_repeat = repeat; + if (repeat > 0) { + repeat -= 2; + repeat <<= extra_bits; + } + repeat += br.readBits(extra_bits) + 3; + repeat_delta = repeat - old_repeat; + if (symbol + repeat_delta > num_symbols) { + throw new Error('[ReadHuffmanCodeLengths] symbol + repeat_delta > num_symbols'); + } + + for (var x = 0; x < repeat_delta; x++) + code_lengths[symbol + x] = repeat_code_len; + + symbol += repeat_delta; + + if (repeat_code_len !== 0) { + space -= repeat_delta << (15 - repeat_code_len); + } + } + } + if (space !== 0) { + throw new Error("[ReadHuffmanCodeLengths] space = " + space); + } + + for (; symbol < num_symbols; symbol++) + code_lengths[symbol] = 0; +} + +function ReadHuffmanCode(alphabet_size, tables, table, br) { + var table_size = 0; + var simple_code_or_skip; + var code_lengths = new Uint8Array(alphabet_size); + + br.readMoreInput(); + + /* simple_code_or_skip is used as follows: + 1 for simple code; + 0 for no skipping, 2 skips 2 code lengths, 3 skips 3 code lengths */ + simple_code_or_skip = br.readBits(2); + if (simple_code_or_skip === 1) { + /* Read symbols, codes & code lengths directly. */ + var i; + var max_bits_counter = alphabet_size - 1; + var max_bits = 0; + var symbols = new Int32Array(4); + var num_symbols = br.readBits(2) + 1; + while (max_bits_counter) { + max_bits_counter >>= 1; + ++max_bits; + } + + for (i = 0; i < num_symbols; ++i) { + symbols[i] = br.readBits(max_bits) % alphabet_size; + code_lengths[symbols[i]] = 2; + } + code_lengths[symbols[0]] = 1; + switch (num_symbols) { + case 1: + break; + case 3: + if ((symbols[0] === symbols[1]) || + (symbols[0] === symbols[2]) || + (symbols[1] === symbols[2])) { + throw new Error('[ReadHuffmanCode] invalid symbols'); + } + break; + case 2: + if (symbols[0] === symbols[1]) { + throw new Error('[ReadHuffmanCode] invalid symbols'); + } + + code_lengths[symbols[1]] = 1; + break; + case 4: + if ((symbols[0] === symbols[1]) || + (symbols[0] === symbols[2]) || + (symbols[0] === symbols[3]) || + (symbols[1] === symbols[2]) || + (symbols[1] === symbols[3]) || + (symbols[2] === symbols[3])) { + throw new Error('[ReadHuffmanCode] invalid symbols'); + } + + if (br.readBits(1)) { + code_lengths[symbols[2]] = 3; + code_lengths[symbols[3]] = 3; + } else { + code_lengths[symbols[0]] = 2; + } + break; + } + } else { /* Decode Huffman-coded code lengths. */ + var i; + var code_length_code_lengths = new Uint8Array(CODE_LENGTH_CODES); + var space = 32; + var num_codes = 0; + /* Static Huffman code for the code length code lengths */ + var huff = [ + new HuffmanCode(2, 0), new HuffmanCode(2, 4), new HuffmanCode(2, 3), new HuffmanCode(3, 2), + new HuffmanCode(2, 0), new HuffmanCode(2, 4), new HuffmanCode(2, 3), new HuffmanCode(4, 1), + new HuffmanCode(2, 0), new HuffmanCode(2, 4), new HuffmanCode(2, 3), new HuffmanCode(3, 2), + new HuffmanCode(2, 0), new HuffmanCode(2, 4), new HuffmanCode(2, 3), new HuffmanCode(4, 5) + ]; + for (i = simple_code_or_skip; i < CODE_LENGTH_CODES && space > 0; ++i) { + var code_len_idx = kCodeLengthCodeOrder[i]; + var p = 0; + var v; + br.fillBitWindow(); + p += (br.val_ >>> br.bit_pos_) & 15; + br.bit_pos_ += huff[p].bits; + v = huff[p].value; + code_length_code_lengths[code_len_idx] = v; + if (v !== 0) { + space -= (32 >> v); + ++num_codes; + } + } + + if (!(num_codes === 1 || space === 0)) + throw new Error('[ReadHuffmanCode] invalid num_codes or space'); + + ReadHuffmanCodeLengths(code_length_code_lengths, alphabet_size, code_lengths, br); + } + + table_size = BrotliBuildHuffmanTable(tables, table, HUFFMAN_TABLE_BITS, code_lengths, alphabet_size); + + if (table_size === 0) { + throw new Error("[ReadHuffmanCode] BuildHuffmanTable failed: "); + } + + return table_size; +} + +function ReadBlockLength(table, index, br) { + var code; + var nbits; + code = ReadSymbol(table, index, br); + nbits = Prefix.kBlockLengthPrefixCode[code].nbits; + return Prefix.kBlockLengthPrefixCode[code].offset + br.readBits(nbits); +} + +function TranslateShortCodes(code, ringbuffer, index) { + var val; + if (code < NUM_DISTANCE_SHORT_CODES) { + index += kDistanceShortCodeIndexOffset[code]; + index &= 3; + val = ringbuffer[index] + kDistanceShortCodeValueOffset[code]; + } else { + val = code - NUM_DISTANCE_SHORT_CODES + 1; + } + return val; +} + +function MoveToFront(v, index) { + var value = v[index]; + var i = index; + for (; i; --i) v[i] = v[i - 1]; + v[0] = value; +} + +function InverseMoveToFrontTransform(v, v_len) { + var mtf = new Uint8Array(256); + var i; + for (i = 0; i < 256; ++i) { + mtf[i] = i; + } + for (i = 0; i < v_len; ++i) { + var index = v[i]; + v[i] = mtf[index]; + if (index) MoveToFront(mtf, index); + } +} + +/* Contains a collection of huffman trees with the same alphabet size. */ +function HuffmanTreeGroup(alphabet_size, num_htrees) { + this.alphabet_size = alphabet_size; + this.num_htrees = num_htrees; + this.codes = new Array(num_htrees + num_htrees * kMaxHuffmanTableSize[(alphabet_size + 31) >>> 5]); + this.htrees = new Uint32Array(num_htrees); +} + +HuffmanTreeGroup.prototype.decode = function(br) { + var i; + var table_size; + var next = 0; + for (i = 0; i < this.num_htrees; ++i) { + this.htrees[i] = next; + table_size = ReadHuffmanCode(this.alphabet_size, this.codes, next, br); + next += table_size; + } +}; + +function DecodeContextMap(context_map_size, br) { + var out = { num_htrees: null, context_map: null }; + var use_rle_for_zeros; + var max_run_length_prefix = 0; + var table; + var i; + + br.readMoreInput(); + var num_htrees = out.num_htrees = DecodeVarLenUint8(br) + 1; + + var context_map = out.context_map = new Uint8Array(context_map_size); + if (num_htrees <= 1) { + return out; + } + + use_rle_for_zeros = br.readBits(1); + if (use_rle_for_zeros) { + max_run_length_prefix = br.readBits(4) + 1; + } + + table = []; + for (i = 0; i < HUFFMAN_MAX_TABLE_SIZE; i++) { + table[i] = new HuffmanCode(0, 0); + } + + ReadHuffmanCode(num_htrees + max_run_length_prefix, table, 0, br); + + for (i = 0; i < context_map_size;) { + var code; + + br.readMoreInput(); + code = ReadSymbol(table, 0, br); + if (code === 0) { + context_map[i] = 0; + ++i; + } else if (code <= max_run_length_prefix) { + var reps = 1 + (1 << code) + br.readBits(code); + while (--reps) { + if (i >= context_map_size) { + throw new Error("[DecodeContextMap] i >= context_map_size"); + } + context_map[i] = 0; + ++i; + } + } else { + context_map[i] = code - max_run_length_prefix; + ++i; + } + } + if (br.readBits(1)) { + InverseMoveToFrontTransform(context_map, context_map_size); + } + + return out; +} + +function DecodeBlockType(max_block_type, trees, tree_type, block_types, ringbuffers, indexes, br) { + var ringbuffer = tree_type * 2; + var index = tree_type; + var type_code = ReadSymbol(trees, tree_type * HUFFMAN_MAX_TABLE_SIZE, br); + var block_type; + if (type_code === 0) { + block_type = ringbuffers[ringbuffer + (indexes[index] & 1)]; + } else if (type_code === 1) { + block_type = ringbuffers[ringbuffer + ((indexes[index] - 1) & 1)] + 1; + } else { + block_type = type_code - 2; + } + if (block_type >= max_block_type) { + block_type -= max_block_type; + } + block_types[tree_type] = block_type; + ringbuffers[ringbuffer + (indexes[index] & 1)] = block_type; + ++indexes[index]; +} + +function CopyUncompressedBlockToOutput(output, len, pos, ringbuffer, ringbuffer_mask, br) { + var rb_size = ringbuffer_mask + 1; + var rb_pos = pos & ringbuffer_mask; + var br_pos = br.pos_ & BrotliBitReader.IBUF_MASK; + var nbytes; + + /* For short lengths copy byte-by-byte */ + if (len < 8 || br.bit_pos_ + (len << 3) < br.bit_end_pos_) { + while (len-- > 0) { + br.readMoreInput(); + ringbuffer[rb_pos++] = br.readBits(8); + if (rb_pos === rb_size) { + output.write(ringbuffer, rb_size); + rb_pos = 0; + } + } + return; + } + + if (br.bit_end_pos_ < 32) { + throw new Error('[CopyUncompressedBlockToOutput] br.bit_end_pos_ < 32'); + } + + /* Copy remaining 0-4 bytes from br.val_ to ringbuffer. */ + while (br.bit_pos_ < 32) { + ringbuffer[rb_pos] = (br.val_ >>> br.bit_pos_); + br.bit_pos_ += 8; + ++rb_pos; + --len; + } + + /* Copy remaining bytes from br.buf_ to ringbuffer. */ + nbytes = (br.bit_end_pos_ - br.bit_pos_) >> 3; + if (br_pos + nbytes > BrotliBitReader.IBUF_MASK) { + var tail = BrotliBitReader.IBUF_MASK + 1 - br_pos; + for (var x = 0; x < tail; x++) + ringbuffer[rb_pos + x] = br.buf_[br_pos + x]; + + nbytes -= tail; + rb_pos += tail; + len -= tail; + br_pos = 0; + } + + for (var x = 0; x < nbytes; x++) + ringbuffer[rb_pos + x] = br.buf_[br_pos + x]; + + rb_pos += nbytes; + len -= nbytes; + + /* If we wrote past the logical end of the ringbuffer, copy the tail of the + ringbuffer to its beginning and flush the ringbuffer to the output. */ + if (rb_pos >= rb_size) { + output.write(ringbuffer, rb_size); + rb_pos -= rb_size; + for (var x = 0; x < rb_pos; x++) + ringbuffer[x] = ringbuffer[rb_size + x]; + } + + /* If we have more to copy than the remaining size of the ringbuffer, then we + first fill the ringbuffer from the input and then flush the ringbuffer to + the output */ + while (rb_pos + len >= rb_size) { + nbytes = rb_size - rb_pos; + if (br.input_.read(ringbuffer, rb_pos, nbytes) < nbytes) { + throw new Error('[CopyUncompressedBlockToOutput] not enough bytes'); + } + output.write(ringbuffer, rb_size); + len -= nbytes; + rb_pos = 0; + } + + /* Copy straight from the input onto the ringbuffer. The ringbuffer will be + flushed to the output at a later time. */ + if (br.input_.read(ringbuffer, rb_pos, len) < len) { + throw new Error('[CopyUncompressedBlockToOutput] not enough bytes'); + } + + /* Restore the state of the bit reader. */ + br.reset(); +} + +/* Advances the bit reader position to the next byte boundary and verifies + that any skipped bits are set to zero. */ +function JumpToByteBoundary(br) { + var new_bit_pos = (br.bit_pos_ + 7) & ~7; + var pad_bits = br.readBits(new_bit_pos - br.bit_pos_); + return pad_bits == 0; +} + +function BrotliDecompressedSize(buffer) { + var input = new BrotliInput(buffer); + var br = new BrotliBitReader(input); + DecodeWindowBits(br); + var out = DecodeMetaBlockLength(br); + return out.meta_block_length; +} + +__webpack_unused_export__ = BrotliDecompressedSize; + +function BrotliDecompressBuffer(buffer, output_size) { + var input = new BrotliInput(buffer); + + if (output_size == null) { + output_size = BrotliDecompressedSize(buffer); + } + + var output_buffer = new Uint8Array(output_size); + var output = new BrotliOutput(output_buffer); + + BrotliDecompress(input, output); + + if (output.pos < output.buffer.length) { + output.buffer = output.buffer.subarray(0, output.pos); + } + + return output.buffer; +} + +exports.BrotliDecompressBuffer = BrotliDecompressBuffer; + +function BrotliDecompress(input, output) { + var i; + var pos = 0; + var input_end = 0; + var window_bits = 0; + var max_backward_distance; + var max_distance = 0; + var ringbuffer_size; + var ringbuffer_mask; + var ringbuffer; + var ringbuffer_end; + /* This ring buffer holds a few past copy distances that will be used by */ + /* some special distance codes. */ + var dist_rb = [ 16, 15, 11, 4 ]; + var dist_rb_idx = 0; + /* The previous 2 bytes used for context. */ + var prev_byte1 = 0; + var prev_byte2 = 0; + var hgroup = [new HuffmanTreeGroup(0, 0), new HuffmanTreeGroup(0, 0), new HuffmanTreeGroup(0, 0)]; + var block_type_trees; + var block_len_trees; + var br; + + /* We need the slack region for the following reasons: + - always doing two 8-byte copies for fast backward copying + - transforms + - flushing the input ringbuffer when decoding uncompressed blocks */ + var kRingBufferWriteAheadSlack = 128 + BrotliBitReader.READ_SIZE; + + br = new BrotliBitReader(input); + + /* Decode window size. */ + window_bits = DecodeWindowBits(br); + max_backward_distance = (1 << window_bits) - 16; + + ringbuffer_size = 1 << window_bits; + ringbuffer_mask = ringbuffer_size - 1; + ringbuffer = new Uint8Array(ringbuffer_size + kRingBufferWriteAheadSlack + BrotliDictionary.maxDictionaryWordLength); + ringbuffer_end = ringbuffer_size; + + block_type_trees = []; + block_len_trees = []; + for (var x = 0; x < 3 * HUFFMAN_MAX_TABLE_SIZE; x++) { + block_type_trees[x] = new HuffmanCode(0, 0); + block_len_trees[x] = new HuffmanCode(0, 0); + } + + while (!input_end) { + var meta_block_remaining_len = 0; + var is_uncompressed; + var block_length = [ 1 << 28, 1 << 28, 1 << 28 ]; + var block_type = [ 0 ]; + var num_block_types = [ 1, 1, 1 ]; + var block_type_rb = [ 0, 1, 0, 1, 0, 1 ]; + var block_type_rb_index = [ 0 ]; + var distance_postfix_bits; + var num_direct_distance_codes; + var distance_postfix_mask; + var num_distance_codes; + var context_map = null; + var context_modes = null; + var num_literal_htrees; + var dist_context_map = null; + var num_dist_htrees; + var context_offset = 0; + var context_map_slice = null; + var literal_htree_index = 0; + var dist_context_offset = 0; + var dist_context_map_slice = null; + var dist_htree_index = 0; + var context_lookup_offset1 = 0; + var context_lookup_offset2 = 0; + var context_mode; + var htree_command; + + for (i = 0; i < 3; ++i) { + hgroup[i].codes = null; + hgroup[i].htrees = null; + } + + br.readMoreInput(); + + var _out = DecodeMetaBlockLength(br); + meta_block_remaining_len = _out.meta_block_length; + if (pos + meta_block_remaining_len > output.buffer.length) { + /* We need to grow the output buffer to fit the additional data. */ + var tmp = new Uint8Array( pos + meta_block_remaining_len ); + tmp.set( output.buffer ); + output.buffer = tmp; + } + input_end = _out.input_end; + is_uncompressed = _out.is_uncompressed; + + if (_out.is_metadata) { + JumpToByteBoundary(br); + + for (; meta_block_remaining_len > 0; --meta_block_remaining_len) { + br.readMoreInput(); + /* Read one byte and ignore it. */ + br.readBits(8); + } + + continue; + } + + if (meta_block_remaining_len === 0) { + continue; + } + + if (is_uncompressed) { + br.bit_pos_ = (br.bit_pos_ + 7) & ~7; + CopyUncompressedBlockToOutput(output, meta_block_remaining_len, pos, + ringbuffer, ringbuffer_mask, br); + pos += meta_block_remaining_len; + continue; + } + + for (i = 0; i < 3; ++i) { + num_block_types[i] = DecodeVarLenUint8(br) + 1; + if (num_block_types[i] >= 2) { + ReadHuffmanCode(num_block_types[i] + 2, block_type_trees, i * HUFFMAN_MAX_TABLE_SIZE, br); + ReadHuffmanCode(kNumBlockLengthCodes, block_len_trees, i * HUFFMAN_MAX_TABLE_SIZE, br); + block_length[i] = ReadBlockLength(block_len_trees, i * HUFFMAN_MAX_TABLE_SIZE, br); + block_type_rb_index[i] = 1; + } + } + + br.readMoreInput(); + + distance_postfix_bits = br.readBits(2); + num_direct_distance_codes = NUM_DISTANCE_SHORT_CODES + (br.readBits(4) << distance_postfix_bits); + distance_postfix_mask = (1 << distance_postfix_bits) - 1; + num_distance_codes = (num_direct_distance_codes + (48 << distance_postfix_bits)); + context_modes = new Uint8Array(num_block_types[0]); + + for (i = 0; i < num_block_types[0]; ++i) { + br.readMoreInput(); + context_modes[i] = (br.readBits(2) << 1); + } + + var _o1 = DecodeContextMap(num_block_types[0] << kLiteralContextBits, br); + num_literal_htrees = _o1.num_htrees; + context_map = _o1.context_map; + + var _o2 = DecodeContextMap(num_block_types[2] << kDistanceContextBits, br); + num_dist_htrees = _o2.num_htrees; + dist_context_map = _o2.context_map; + + hgroup[0] = new HuffmanTreeGroup(kNumLiteralCodes, num_literal_htrees); + hgroup[1] = new HuffmanTreeGroup(kNumInsertAndCopyCodes, num_block_types[1]); + hgroup[2] = new HuffmanTreeGroup(num_distance_codes, num_dist_htrees); + + for (i = 0; i < 3; ++i) { + hgroup[i].decode(br); + } + + context_map_slice = 0; + dist_context_map_slice = 0; + context_mode = context_modes[block_type[0]]; + context_lookup_offset1 = Context.lookupOffsets[context_mode]; + context_lookup_offset2 = Context.lookupOffsets[context_mode + 1]; + htree_command = hgroup[1].htrees[0]; + + while (meta_block_remaining_len > 0) { + var cmd_code; + var range_idx; + var insert_code; + var copy_code; + var insert_length; + var copy_length; + var distance_code; + var distance; + var context; + var j; + var copy_dst; + + br.readMoreInput(); + + if (block_length[1] === 0) { + DecodeBlockType(num_block_types[1], + block_type_trees, 1, block_type, block_type_rb, + block_type_rb_index, br); + block_length[1] = ReadBlockLength(block_len_trees, HUFFMAN_MAX_TABLE_SIZE, br); + htree_command = hgroup[1].htrees[block_type[1]]; + } + --block_length[1]; + cmd_code = ReadSymbol(hgroup[1].codes, htree_command, br); + range_idx = cmd_code >> 6; + if (range_idx >= 2) { + range_idx -= 2; + distance_code = -1; + } else { + distance_code = 0; + } + insert_code = Prefix.kInsertRangeLut[range_idx] + ((cmd_code >> 3) & 7); + copy_code = Prefix.kCopyRangeLut[range_idx] + (cmd_code & 7); + insert_length = Prefix.kInsertLengthPrefixCode[insert_code].offset + + br.readBits(Prefix.kInsertLengthPrefixCode[insert_code].nbits); + copy_length = Prefix.kCopyLengthPrefixCode[copy_code].offset + + br.readBits(Prefix.kCopyLengthPrefixCode[copy_code].nbits); + prev_byte1 = ringbuffer[pos-1 & ringbuffer_mask]; + prev_byte2 = ringbuffer[pos-2 & ringbuffer_mask]; + for (j = 0; j < insert_length; ++j) { + br.readMoreInput(); + + if (block_length[0] === 0) { + DecodeBlockType(num_block_types[0], + block_type_trees, 0, block_type, block_type_rb, + block_type_rb_index, br); + block_length[0] = ReadBlockLength(block_len_trees, 0, br); + context_offset = block_type[0] << kLiteralContextBits; + context_map_slice = context_offset; + context_mode = context_modes[block_type[0]]; + context_lookup_offset1 = Context.lookupOffsets[context_mode]; + context_lookup_offset2 = Context.lookupOffsets[context_mode + 1]; + } + context = (Context.lookup[context_lookup_offset1 + prev_byte1] | + Context.lookup[context_lookup_offset2 + prev_byte2]); + literal_htree_index = context_map[context_map_slice + context]; + --block_length[0]; + prev_byte2 = prev_byte1; + prev_byte1 = ReadSymbol(hgroup[0].codes, hgroup[0].htrees[literal_htree_index], br); + ringbuffer[pos & ringbuffer_mask] = prev_byte1; + if ((pos & ringbuffer_mask) === ringbuffer_mask) { + output.write(ringbuffer, ringbuffer_size); + } + ++pos; + } + meta_block_remaining_len -= insert_length; + if (meta_block_remaining_len <= 0) break; + + if (distance_code < 0) { + var context; + + br.readMoreInput(); + if (block_length[2] === 0) { + DecodeBlockType(num_block_types[2], + block_type_trees, 2, block_type, block_type_rb, + block_type_rb_index, br); + block_length[2] = ReadBlockLength(block_len_trees, 2 * HUFFMAN_MAX_TABLE_SIZE, br); + dist_context_offset = block_type[2] << kDistanceContextBits; + dist_context_map_slice = dist_context_offset; + } + --block_length[2]; + context = (copy_length > 4 ? 3 : copy_length - 2) & 0xff; + dist_htree_index = dist_context_map[dist_context_map_slice + context]; + distance_code = ReadSymbol(hgroup[2].codes, hgroup[2].htrees[dist_htree_index], br); + if (distance_code >= num_direct_distance_codes) { + var nbits; + var postfix; + var offset; + distance_code -= num_direct_distance_codes; + postfix = distance_code & distance_postfix_mask; + distance_code >>= distance_postfix_bits; + nbits = (distance_code >> 1) + 1; + offset = ((2 + (distance_code & 1)) << nbits) - 4; + distance_code = num_direct_distance_codes + + ((offset + br.readBits(nbits)) << + distance_postfix_bits) + postfix; + } + } + + /* Convert the distance code to the actual distance by possibly looking */ + /* up past distnaces from the ringbuffer. */ + distance = TranslateShortCodes(distance_code, dist_rb, dist_rb_idx); + if (distance < 0) { + throw new Error('[BrotliDecompress] invalid distance'); + } + + if (pos < max_backward_distance && + max_distance !== max_backward_distance) { + max_distance = pos; + } else { + max_distance = max_backward_distance; + } + + copy_dst = pos & ringbuffer_mask; + + if (distance > max_distance) { + if (copy_length >= BrotliDictionary.minDictionaryWordLength && + copy_length <= BrotliDictionary.maxDictionaryWordLength) { + var offset = BrotliDictionary.offsetsByLength[copy_length]; + var word_id = distance - max_distance - 1; + var shift = BrotliDictionary.sizeBitsByLength[copy_length]; + var mask = (1 << shift) - 1; + var word_idx = word_id & mask; + var transform_idx = word_id >> shift; + offset += word_idx * copy_length; + if (transform_idx < Transform.kNumTransforms) { + var len = Transform.transformDictionaryWord(ringbuffer, copy_dst, offset, copy_length, transform_idx); + copy_dst += len; + pos += len; + meta_block_remaining_len -= len; + if (copy_dst >= ringbuffer_end) { + output.write(ringbuffer, ringbuffer_size); + + for (var _x = 0; _x < (copy_dst - ringbuffer_end); _x++) + ringbuffer[_x] = ringbuffer[ringbuffer_end + _x]; + } + } else { + throw new Error("Invalid backward reference. pos: " + pos + " distance: " + distance + + " len: " + copy_length + " bytes left: " + meta_block_remaining_len); + } + } else { + throw new Error("Invalid backward reference. pos: " + pos + " distance: " + distance + + " len: " + copy_length + " bytes left: " + meta_block_remaining_len); + } + } else { + if (distance_code > 0) { + dist_rb[dist_rb_idx & 3] = distance; + ++dist_rb_idx; + } + + if (copy_length > meta_block_remaining_len) { + throw new Error("Invalid backward reference. pos: " + pos + " distance: " + distance + + " len: " + copy_length + " bytes left: " + meta_block_remaining_len); + } + + for (j = 0; j < copy_length; ++j) { + ringbuffer[pos & ringbuffer_mask] = ringbuffer[(pos - distance) & ringbuffer_mask]; + if ((pos & ringbuffer_mask) === ringbuffer_mask) { + output.write(ringbuffer, ringbuffer_size); + } + ++pos; + --meta_block_remaining_len; + } + } + + /* When we get here, we must have inserted at least one literal and */ + /* made a copy of at least length two, therefore accessing the last 2 */ + /* bytes is valid. */ + prev_byte1 = ringbuffer[(pos - 1) & ringbuffer_mask]; + prev_byte2 = ringbuffer[(pos - 2) & ringbuffer_mask]; + } + + /* Protect pos from overflow, wrap it around at every GB of input data */ + pos &= 0x3fffffff; + } + + output.write(ringbuffer, pos & ringbuffer_mask); +} + +__webpack_unused_export__ = BrotliDecompress; + +BrotliDictionary.init(); + + +/***/ }), + +/***/ 5340: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +var base64 = __webpack_require__(9742); + +/** + * The normal dictionary-data.js is quite large, which makes it + * unsuitable for browser usage. In order to make it smaller, + * we read dictionary.bin, which is a compressed version of + * the dictionary, and on initial load, Brotli decompresses + * it's own dictionary. 😜 + */ +exports.init = function() { + var BrotliDecompressBuffer = (__webpack_require__(6450).BrotliDecompressBuffer); + var compressed = base64.toByteArray(__webpack_require__(2722)); + return BrotliDecompressBuffer(compressed); +}; + + +/***/ }), + +/***/ 2722: +/***/ ((module) => { + +module.exports="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"; + + +/***/ }), + +/***/ 5139: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +/* Copyright 2013 Google Inc. All Rights Reserved. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + Collection of static dictionary words. +*/ + +var data = __webpack_require__(5340); +exports.init = function() { + exports.dictionary = data.init(); +}; + +exports.offsetsByLength = new Uint32Array([ + 0, 0, 0, 0, 0, 4096, 9216, 21504, 35840, 44032, + 53248, 63488, 74752, 87040, 93696, 100864, 104704, 106752, 108928, 113536, + 115968, 118528, 119872, 121280, 122016, +]); + +exports.sizeBitsByLength = new Uint8Array([ + 0, 0, 0, 0, 10, 10, 11, 11, 10, 10, + 10, 10, 10, 9, 9, 8, 7, 7, 8, 7, + 7, 6, 6, 5, 5, +]); + +exports.minDictionaryWordLength = 4; +exports.maxDictionaryWordLength = 24; + + +/***/ }), + +/***/ 966: +/***/ ((__unused_webpack_module, exports) => { + +function HuffmanCode(bits, value) { + this.bits = bits; /* number of bits used for this symbol */ + this.value = value; /* symbol value or table offset */ +} + +exports.h = HuffmanCode; + +var MAX_LENGTH = 15; + +/* Returns reverse(reverse(key, len) + 1, len), where reverse(key, len) is the + bit-wise reversal of the len least significant bits of key. */ +function GetNextKey(key, len) { + var step = 1 << (len - 1); + while (key & step) { + step >>= 1; + } + return (key & (step - 1)) + step; +} + +/* Stores code in table[0], table[step], table[2*step], ..., table[end] */ +/* Assumes that end is an integer multiple of step */ +function ReplicateValue(table, i, step, end, code) { + do { + end -= step; + table[i + end] = new HuffmanCode(code.bits, code.value); + } while (end > 0); +} + +/* Returns the table width of the next 2nd level table. count is the histogram + of bit lengths for the remaining symbols, len is the code length of the next + processed symbol */ +function NextTableBitSize(count, len, root_bits) { + var left = 1 << (len - root_bits); + while (len < MAX_LENGTH) { + left -= count[len]; + if (left <= 0) break; + ++len; + left <<= 1; + } + return len - root_bits; +} + +exports.g = function(root_table, table, root_bits, code_lengths, code_lengths_size) { + var start_table = table; + var code; /* current table entry */ + var len; /* current code length */ + var symbol; /* symbol index in original or sorted table */ + var key; /* reversed prefix code */ + var step; /* step size to replicate values in current table */ + var low; /* low bits for current root entry */ + var mask; /* mask for low bits */ + var table_bits; /* key length of current table */ + var table_size; /* size of current table */ + var total_size; /* sum of root table size and 2nd level table sizes */ + var sorted; /* symbols sorted by code length */ + var count = new Int32Array(MAX_LENGTH + 1); /* number of codes of each length */ + var offset = new Int32Array(MAX_LENGTH + 1); /* offsets in sorted table for each length */ + + sorted = new Int32Array(code_lengths_size); + + /* build histogram of code lengths */ + for (symbol = 0; symbol < code_lengths_size; symbol++) { + count[code_lengths[symbol]]++; + } + + /* generate offsets into sorted symbol table by code length */ + offset[1] = 0; + for (len = 1; len < MAX_LENGTH; len++) { + offset[len + 1] = offset[len] + count[len]; + } + + /* sort symbols by length, by symbol order within each length */ + for (symbol = 0; symbol < code_lengths_size; symbol++) { + if (code_lengths[symbol] !== 0) { + sorted[offset[code_lengths[symbol]]++] = symbol; + } + } + + table_bits = root_bits; + table_size = 1 << table_bits; + total_size = table_size; + + /* special case code with only one value */ + if (offset[MAX_LENGTH] === 1) { + for (key = 0; key < total_size; ++key) { + root_table[table + key] = new HuffmanCode(0, sorted[0] & 0xffff); + } + + return total_size; + } + + /* fill in root table */ + key = 0; + symbol = 0; + for (len = 1, step = 2; len <= root_bits; ++len, step <<= 1) { + for (; count[len] > 0; --count[len]) { + code = new HuffmanCode(len & 0xff, sorted[symbol++] & 0xffff); + ReplicateValue(root_table, table + key, step, table_size, code); + key = GetNextKey(key, len); + } + } + + /* fill in 2nd level tables and add pointers to root table */ + mask = total_size - 1; + low = -1; + for (len = root_bits + 1, step = 2; len <= MAX_LENGTH; ++len, step <<= 1) { + for (; count[len] > 0; --count[len]) { + if ((key & mask) !== low) { + table += table_size; + table_bits = NextTableBitSize(count, len, root_bits); + table_size = 1 << table_bits; + total_size += table_size; + low = key & mask; + root_table[start_table + low] = new HuffmanCode((table_bits + root_bits) & 0xff, ((table - start_table) - low) & 0xffff); + } + code = new HuffmanCode((len - root_bits) & 0xff, sorted[symbol++] & 0xffff); + ReplicateValue(root_table, table + (key >> root_bits), step, table_size, code); + key = GetNextKey(key, len); + } + } + + return total_size; +} + + +/***/ }), + +/***/ 8435: +/***/ ((__unused_webpack_module, exports) => { + +/* Copyright 2013 Google Inc. All Rights Reserved. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + Lookup tables to map prefix codes to value ranges. This is used during + decoding of the block lengths, literal insertion lengths and copy lengths. +*/ + +/* Represents the range of values belonging to a prefix code: */ +/* [offset, offset + 2^nbits) */ +function PrefixCodeRange(offset, nbits) { + this.offset = offset; + this.nbits = nbits; +} + +exports.kBlockLengthPrefixCode = [ + new PrefixCodeRange(1, 2), new PrefixCodeRange(5, 2), new PrefixCodeRange(9, 2), new PrefixCodeRange(13, 2), + new PrefixCodeRange(17, 3), new PrefixCodeRange(25, 3), new PrefixCodeRange(33, 3), new PrefixCodeRange(41, 3), + new PrefixCodeRange(49, 4), new PrefixCodeRange(65, 4), new PrefixCodeRange(81, 4), new PrefixCodeRange(97, 4), + new PrefixCodeRange(113, 5), new PrefixCodeRange(145, 5), new PrefixCodeRange(177, 5), new PrefixCodeRange(209, 5), + new PrefixCodeRange(241, 6), new PrefixCodeRange(305, 6), new PrefixCodeRange(369, 7), new PrefixCodeRange(497, 8), + new PrefixCodeRange(753, 9), new PrefixCodeRange(1265, 10), new PrefixCodeRange(2289, 11), new PrefixCodeRange(4337, 12), + new PrefixCodeRange(8433, 13), new PrefixCodeRange(16625, 24) +]; + +exports.kInsertLengthPrefixCode = [ + new PrefixCodeRange(0, 0), new PrefixCodeRange(1, 0), new PrefixCodeRange(2, 0), new PrefixCodeRange(3, 0), + new PrefixCodeRange(4, 0), new PrefixCodeRange(5, 0), new PrefixCodeRange(6, 1), new PrefixCodeRange(8, 1), + new PrefixCodeRange(10, 2), new PrefixCodeRange(14, 2), new PrefixCodeRange(18, 3), new PrefixCodeRange(26, 3), + new PrefixCodeRange(34, 4), new PrefixCodeRange(50, 4), new PrefixCodeRange(66, 5), new PrefixCodeRange(98, 5), + new PrefixCodeRange(130, 6), new PrefixCodeRange(194, 7), new PrefixCodeRange(322, 8), new PrefixCodeRange(578, 9), + new PrefixCodeRange(1090, 10), new PrefixCodeRange(2114, 12), new PrefixCodeRange(6210, 14), new PrefixCodeRange(22594, 24), +]; + +exports.kCopyLengthPrefixCode = [ + new PrefixCodeRange(2, 0), new PrefixCodeRange(3, 0), new PrefixCodeRange(4, 0), new PrefixCodeRange(5, 0), + new PrefixCodeRange(6, 0), new PrefixCodeRange(7, 0), new PrefixCodeRange(8, 0), new PrefixCodeRange(9, 0), + new PrefixCodeRange(10, 1), new PrefixCodeRange(12, 1), new PrefixCodeRange(14, 2), new PrefixCodeRange(18, 2), + new PrefixCodeRange(22, 3), new PrefixCodeRange(30, 3), new PrefixCodeRange(38, 4), new PrefixCodeRange(54, 4), + new PrefixCodeRange(70, 5), new PrefixCodeRange(102, 5), new PrefixCodeRange(134, 6), new PrefixCodeRange(198, 7), + new PrefixCodeRange(326, 8), new PrefixCodeRange(582, 9), new PrefixCodeRange(1094, 10), new PrefixCodeRange(2118, 24), +]; + +exports.kInsertRangeLut = [ + 0, 0, 8, 8, 0, 16, 8, 16, 16, +]; + +exports.kCopyRangeLut = [ + 0, 8, 0, 8, 16, 0, 16, 8, 16, +]; + + +/***/ }), + +/***/ 6154: +/***/ ((__unused_webpack_module, exports) => { + +function BrotliInput(buffer) { + this.buffer = buffer; + this.pos = 0; +} + +BrotliInput.prototype.read = function(buf, i, count) { + if (this.pos + count > this.buffer.length) { + count = this.buffer.length - this.pos; + } + + for (var p = 0; p < count; p++) + buf[i + p] = this.buffer[this.pos + p]; + + this.pos += count; + return count; +} + +exports.g = BrotliInput; + +function BrotliOutput(buf) { + this.buffer = buf; + this.pos = 0; +} + +BrotliOutput.prototype.write = function(buf, count) { + if (this.pos + count > this.buffer.length) + throw new Error('Output buffer is not large enough'); + + this.buffer.set(buf.subarray(0, count), this.pos); + this.pos += count; + return count; +}; + +exports.j = BrotliOutput; + + +/***/ }), + +/***/ 2973: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +/* Copyright 2013 Google Inc. All Rights Reserved. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + Transformations on dictionary words. +*/ + +var BrotliDictionary = __webpack_require__(5139); + +var kIdentity = 0; +var kOmitLast1 = 1; +var kOmitLast2 = 2; +var kOmitLast3 = 3; +var kOmitLast4 = 4; +var kOmitLast5 = 5; +var kOmitLast6 = 6; +var kOmitLast7 = 7; +var kOmitLast8 = 8; +var kOmitLast9 = 9; +var kUppercaseFirst = 10; +var kUppercaseAll = 11; +var kOmitFirst1 = 12; +var kOmitFirst2 = 13; +var kOmitFirst3 = 14; +var kOmitFirst4 = 15; +var kOmitFirst5 = 16; +var kOmitFirst6 = 17; +var kOmitFirst7 = 18; +var kOmitFirst8 = 19; +var kOmitFirst9 = 20; + +function Transform(prefix, transform, suffix) { + this.prefix = new Uint8Array(prefix.length); + this.transform = transform; + this.suffix = new Uint8Array(suffix.length); + + for (var i = 0; i < prefix.length; i++) + this.prefix[i] = prefix.charCodeAt(i); + + for (var i = 0; i < suffix.length; i++) + this.suffix[i] = suffix.charCodeAt(i); +} + +var kTransforms = [ + new Transform( "", kIdentity, "" ), + new Transform( "", kIdentity, " " ), + new Transform( " ", kIdentity, " " ), + new Transform( "", kOmitFirst1, "" ), + new Transform( "", kUppercaseFirst, " " ), + new Transform( "", kIdentity, " the " ), + new Transform( " ", kIdentity, "" ), + new Transform( "s ", kIdentity, " " ), + new Transform( "", kIdentity, " of " ), + new Transform( "", kUppercaseFirst, "" ), + new Transform( "", kIdentity, " and " ), + new Transform( "", kOmitFirst2, "" ), + new Transform( "", kOmitLast1, "" ), + new Transform( ", ", kIdentity, " " ), + new Transform( "", kIdentity, ", " ), + new Transform( " ", kUppercaseFirst, " " ), + new Transform( "", kIdentity, " in " ), + new Transform( "", kIdentity, " to " ), + new Transform( "e ", kIdentity, " " ), + new Transform( "", kIdentity, "\"" ), + new Transform( "", kIdentity, "." ), + new Transform( "", kIdentity, "\">" ), + new Transform( "", kIdentity, "\n" ), + new Transform( "", kOmitLast3, "" ), + new Transform( "", kIdentity, "]" ), + new Transform( "", kIdentity, " for " ), + new Transform( "", kOmitFirst3, "" ), + new Transform( "", kOmitLast2, "" ), + new Transform( "", kIdentity, " a " ), + new Transform( "", kIdentity, " that " ), + new Transform( " ", kUppercaseFirst, "" ), + new Transform( "", kIdentity, ". " ), + new Transform( ".", kIdentity, "" ), + new Transform( " ", kIdentity, ", " ), + new Transform( "", kOmitFirst4, "" ), + new Transform( "", kIdentity, " with " ), + new Transform( "", kIdentity, "'" ), + new Transform( "", kIdentity, " from " ), + new Transform( "", kIdentity, " by " ), + new Transform( "", kOmitFirst5, "" ), + new Transform( "", kOmitFirst6, "" ), + new Transform( " the ", kIdentity, "" ), + new Transform( "", kOmitLast4, "" ), + new Transform( "", kIdentity, ". The " ), + new Transform( "", kUppercaseAll, "" ), + new Transform( "", kIdentity, " on " ), + new Transform( "", kIdentity, " as " ), + new Transform( "", kIdentity, " is " ), + new Transform( "", kOmitLast7, "" ), + new Transform( "", kOmitLast1, "ing " ), + new Transform( "", kIdentity, "\n\t" ), + new Transform( "", kIdentity, ":" ), + new Transform( " ", kIdentity, ". " ), + new Transform( "", kIdentity, "ed " ), + new Transform( "", kOmitFirst9, "" ), + new Transform( "", kOmitFirst7, "" ), + new Transform( "", kOmitLast6, "" ), + new Transform( "", kIdentity, "(" ), + new Transform( "", kUppercaseFirst, ", " ), + new Transform( "", kOmitLast8, "" ), + new Transform( "", kIdentity, " at " ), + new Transform( "", kIdentity, "ly " ), + new Transform( " the ", kIdentity, " of " ), + new Transform( "", kOmitLast5, "" ), + new Transform( "", kOmitLast9, "" ), + new Transform( " ", kUppercaseFirst, ", " ), + new Transform( "", kUppercaseFirst, "\"" ), + new Transform( ".", kIdentity, "(" ), + new Transform( "", kUppercaseAll, " " ), + new Transform( "", kUppercaseFirst, "\">" ), + new Transform( "", kIdentity, "=\"" ), + new Transform( " ", kIdentity, "." ), + new Transform( ".com/", kIdentity, "" ), + new Transform( " the ", kIdentity, " of the " ), + new Transform( "", kUppercaseFirst, "'" ), + new Transform( "", kIdentity, ". This " ), + new Transform( "", kIdentity, "," ), + new Transform( ".", kIdentity, " " ), + new Transform( "", kUppercaseFirst, "(" ), + new Transform( "", kUppercaseFirst, "." ), + new Transform( "", kIdentity, " not " ), + new Transform( " ", kIdentity, "=\"" ), + new Transform( "", kIdentity, "er " ), + new Transform( " ", kUppercaseAll, " " ), + new Transform( "", kIdentity, "al " ), + new Transform( " ", kUppercaseAll, "" ), + new Transform( "", kIdentity, "='" ), + new Transform( "", kUppercaseAll, "\"" ), + new Transform( "", kUppercaseFirst, ". " ), + new Transform( " ", kIdentity, "(" ), + new Transform( "", kIdentity, "ful " ), + new Transform( " ", kUppercaseFirst, ". " ), + new Transform( "", kIdentity, "ive " ), + new Transform( "", kIdentity, "less " ), + new Transform( "", kUppercaseAll, "'" ), + new Transform( "", kIdentity, "est " ), + new Transform( " ", kUppercaseFirst, "." ), + new Transform( "", kUppercaseAll, "\">" ), + new Transform( " ", kIdentity, "='" ), + new Transform( "", kUppercaseFirst, "," ), + new Transform( "", kIdentity, "ize " ), + new Transform( "", kUppercaseAll, "." ), + new Transform( "\xc2\xa0", kIdentity, "" ), + new Transform( " ", kIdentity, "," ), + new Transform( "", kUppercaseFirst, "=\"" ), + new Transform( "", kUppercaseAll, "=\"" ), + new Transform( "", kIdentity, "ous " ), + new Transform( "", kUppercaseAll, ", " ), + new Transform( "", kUppercaseFirst, "='" ), + new Transform( " ", kUppercaseFirst, "," ), + new Transform( " ", kUppercaseAll, "=\"" ), + new Transform( " ", kUppercaseAll, ", " ), + new Transform( "", kUppercaseAll, "," ), + new Transform( "", kUppercaseAll, "(" ), + new Transform( "", kUppercaseAll, ". " ), + new Transform( " ", kUppercaseAll, "." ), + new Transform( "", kUppercaseAll, "='" ), + new Transform( " ", kUppercaseAll, ". " ), + new Transform( " ", kUppercaseFirst, "=\"" ), + new Transform( " ", kUppercaseAll, "='" ), + new Transform( " ", kUppercaseFirst, "='" ) +]; + +exports.kTransforms = kTransforms; +exports.kNumTransforms = kTransforms.length; + +function ToUpperCase(p, i) { + if (p[i] < 0xc0) { + if (p[i] >= 97 && p[i] <= 122) { + p[i] ^= 32; + } + return 1; + } + + /* An overly simplified uppercasing model for utf-8. */ + if (p[i] < 0xe0) { + p[i + 1] ^= 32; + return 2; + } + + /* An arbitrary transform for three byte characters. */ + p[i + 2] ^= 5; + return 3; +} + +exports.transformDictionaryWord = function(dst, idx, word, len, transform) { + var prefix = kTransforms[transform].prefix; + var suffix = kTransforms[transform].suffix; + var t = kTransforms[transform].transform; + var skip = t < kOmitFirst1 ? 0 : t - (kOmitFirst1 - 1); + var i = 0; + var start_idx = idx; + var uppercase; + + if (skip > len) { + skip = len; + } + + var prefix_pos = 0; + while (prefix_pos < prefix.length) { + dst[idx++] = prefix[prefix_pos++]; + } + + word += skip; + len -= skip; + + if (t <= kOmitLast9) { + len -= t; + } + + for (i = 0; i < len; i++) { + dst[idx++] = BrotliDictionary.dictionary[word + i]; + } + + uppercase = idx - len; + + if (t === kUppercaseFirst) { + ToUpperCase(dst, uppercase); + } else if (t === kUppercaseAll) { + while (len > 0) { + var step = ToUpperCase(dst, uppercase); + uppercase += step; + len -= step; + } + } + + var suffix_pos = 0; + while (suffix_pos < suffix.length) { + dst[idx++] = suffix[suffix_pos++]; + } + + return idx - start_idx; +} + + +/***/ }), + +/***/ 7709: +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +module.exports = __webpack_require__(6450).BrotliDecompressBuffer; + + +/***/ }), + +/***/ 8764: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; +/*! + * The buffer module from node.js, for the browser. + * + * @author Feross Aboukhadijeh + * @license MIT + */ +/* eslint-disable no-proto */ + + + +const base64 = __webpack_require__(9742) +const ieee754 = __webpack_require__(645) +const customInspectSymbol = + (typeof Symbol === 'function' && typeof Symbol['for'] === 'function') // eslint-disable-line dot-notation + ? Symbol['for']('nodejs.util.inspect.custom') // eslint-disable-line dot-notation + : null + +exports.Buffer = Buffer +exports.SlowBuffer = SlowBuffer +exports.INSPECT_MAX_BYTES = 50 + +const K_MAX_LENGTH = 0x7fffffff +exports.kMaxLength = K_MAX_LENGTH + +/** + * If `Buffer.TYPED_ARRAY_SUPPORT`: + * === true Use Uint8Array implementation (fastest) + * === false Print warning and recommend using `buffer` v4.x which has an Object + * implementation (most compatible, even IE6) + * + * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+, + * Opera 11.6+, iOS 4.2+. + * + * We report that the browser does not support typed arrays if the are not subclassable + * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array` + * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support + * for __proto__ and has a buggy typed array implementation. + */ +Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport() + +if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' && + typeof console.error === 'function') { + console.error( + 'This browser lacks typed array (Uint8Array) support which is required by ' + + '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.' + ) +} + +function typedArraySupport () { + // Can typed array instances can be augmented? + try { + const arr = new Uint8Array(1) + const proto = { foo: function () { return 42 } } + Object.setPrototypeOf(proto, Uint8Array.prototype) + Object.setPrototypeOf(arr, proto) + return arr.foo() === 42 + } catch (e) { + return false + } +} + +Object.defineProperty(Buffer.prototype, 'parent', { + enumerable: true, + get: function () { + if (!Buffer.isBuffer(this)) return undefined + return this.buffer + } +}) + +Object.defineProperty(Buffer.prototype, 'offset', { + enumerable: true, + get: function () { + if (!Buffer.isBuffer(this)) return undefined + return this.byteOffset + } +}) + +function createBuffer (length) { + if (length > K_MAX_LENGTH) { + throw new RangeError('The value "' + length + '" is invalid for option "size"') + } + // Return an augmented `Uint8Array` instance + const buf = new Uint8Array(length) + Object.setPrototypeOf(buf, Buffer.prototype) + return buf +} + +/** + * The Buffer constructor returns instances of `Uint8Array` that have their + * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of + * `Uint8Array`, so the returned instances will have all the node `Buffer` methods + * and the `Uint8Array` methods. Square bracket notation works as expected -- it + * returns a single octet. + * + * The `Uint8Array` prototype remains unmodified. + */ + +function Buffer (arg, encodingOrOffset, length) { + // Common case. + if (typeof arg === 'number') { + if (typeof encodingOrOffset === 'string') { + throw new TypeError( + 'The "string" argument must be of type string. Received type number' + ) + } + return allocUnsafe(arg) + } + return from(arg, encodingOrOffset, length) +} + +Buffer.poolSize = 8192 // not used by this implementation + +function from (value, encodingOrOffset, length) { + if (typeof value === 'string') { + return fromString(value, encodingOrOffset) + } + + if (ArrayBuffer.isView(value)) { + return fromArrayView(value) + } + + if (value == null) { + throw new TypeError( + 'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' + + 'or Array-like Object. Received type ' + (typeof value) + ) + } + + if (isInstance(value, ArrayBuffer) || + (value && isInstance(value.buffer, ArrayBuffer))) { + return fromArrayBuffer(value, encodingOrOffset, length) + } + + if (typeof SharedArrayBuffer !== 'undefined' && + (isInstance(value, SharedArrayBuffer) || + (value && isInstance(value.buffer, SharedArrayBuffer)))) { + return fromArrayBuffer(value, encodingOrOffset, length) + } + + if (typeof value === 'number') { + throw new TypeError( + 'The "value" argument must not be of type number. Received type number' + ) + } + + const valueOf = value.valueOf && value.valueOf() + if (valueOf != null && valueOf !== value) { + return Buffer.from(valueOf, encodingOrOffset, length) + } + + const b = fromObject(value) + if (b) return b + + if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null && + typeof value[Symbol.toPrimitive] === 'function') { + return Buffer.from(value[Symbol.toPrimitive]('string'), encodingOrOffset, length) + } + + throw new TypeError( + 'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' + + 'or Array-like Object. Received type ' + (typeof value) + ) +} + +/** + * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError + * if value is a number. + * Buffer.from(str[, encoding]) + * Buffer.from(array) + * Buffer.from(buffer) + * Buffer.from(arrayBuffer[, byteOffset[, length]]) + **/ +Buffer.from = function (value, encodingOrOffset, length) { + return from(value, encodingOrOffset, length) +} + +// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug: +// https://github.com/feross/buffer/pull/148 +Object.setPrototypeOf(Buffer.prototype, Uint8Array.prototype) +Object.setPrototypeOf(Buffer, Uint8Array) + +function assertSize (size) { + if (typeof size !== 'number') { + throw new TypeError('"size" argument must be of type number') + } else if (size < 0) { + throw new RangeError('The value "' + size + '" is invalid for option "size"') + } +} + +function alloc (size, fill, encoding) { + assertSize(size) + if (size <= 0) { + return createBuffer(size) + } + if (fill !== undefined) { + // Only pay attention to encoding if it's a string. This + // prevents accidentally sending in a number that would + // be interpreted as a start offset. + return typeof encoding === 'string' + ? createBuffer(size).fill(fill, encoding) + : createBuffer(size).fill(fill) + } + return createBuffer(size) +} + +/** + * Creates a new filled Buffer instance. + * alloc(size[, fill[, encoding]]) + **/ +Buffer.alloc = function (size, fill, encoding) { + return alloc(size, fill, encoding) +} + +function allocUnsafe (size) { + assertSize(size) + return createBuffer(size < 0 ? 0 : checked(size) | 0) +} + +/** + * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance. + * */ +Buffer.allocUnsafe = function (size) { + return allocUnsafe(size) +} +/** + * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance. + */ +Buffer.allocUnsafeSlow = function (size) { + return allocUnsafe(size) +} + +function fromString (string, encoding) { + if (typeof encoding !== 'string' || encoding === '') { + encoding = 'utf8' + } + + if (!Buffer.isEncoding(encoding)) { + throw new TypeError('Unknown encoding: ' + encoding) + } + + const length = byteLength(string, encoding) | 0 + let buf = createBuffer(length) + + const actual = buf.write(string, encoding) + + if (actual !== length) { + // Writing a hex string, for example, that contains invalid characters will + // cause everything after the first invalid character to be ignored. (e.g. + // 'abxxcd' will be treated as 'ab') + buf = buf.slice(0, actual) + } + + return buf +} + +function fromArrayLike (array) { + const length = array.length < 0 ? 0 : checked(array.length) | 0 + const buf = createBuffer(length) + for (let i = 0; i < length; i += 1) { + buf[i] = array[i] & 255 + } + return buf +} + +function fromArrayView (arrayView) { + if (isInstance(arrayView, Uint8Array)) { + const copy = new Uint8Array(arrayView) + return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength) + } + return fromArrayLike(arrayView) +} + +function fromArrayBuffer (array, byteOffset, length) { + if (byteOffset < 0 || array.byteLength < byteOffset) { + throw new RangeError('"offset" is outside of buffer bounds') + } + + if (array.byteLength < byteOffset + (length || 0)) { + throw new RangeError('"length" is outside of buffer bounds') + } + + let buf + if (byteOffset === undefined && length === undefined) { + buf = new Uint8Array(array) + } else if (length === undefined) { + buf = new Uint8Array(array, byteOffset) + } else { + buf = new Uint8Array(array, byteOffset, length) + } + + // Return an augmented `Uint8Array` instance + Object.setPrototypeOf(buf, Buffer.prototype) + + return buf +} + +function fromObject (obj) { + if (Buffer.isBuffer(obj)) { + const len = checked(obj.length) | 0 + const buf = createBuffer(len) + + if (buf.length === 0) { + return buf + } + + obj.copy(buf, 0, 0, len) + return buf + } + + if (obj.length !== undefined) { + if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) { + return createBuffer(0) + } + return fromArrayLike(obj) + } + + if (obj.type === 'Buffer' && Array.isArray(obj.data)) { + return fromArrayLike(obj.data) + } +} + +function checked (length) { + // Note: cannot use `length < K_MAX_LENGTH` here because that fails when + // length is NaN (which is otherwise coerced to zero.) + if (length >= K_MAX_LENGTH) { + throw new RangeError('Attempt to allocate Buffer larger than maximum ' + + 'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes') + } + return length | 0 +} + +function SlowBuffer (length) { + if (+length != length) { // eslint-disable-line eqeqeq + length = 0 + } + return Buffer.alloc(+length) +} + +Buffer.isBuffer = function isBuffer (b) { + return b != null && b._isBuffer === true && + b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false +} + +Buffer.compare = function compare (a, b) { + if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength) + if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength) + if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) { + throw new TypeError( + 'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array' + ) + } + + if (a === b) return 0 + + let x = a.length + let y = b.length + + for (let i = 0, len = Math.min(x, y); i < len; ++i) { + if (a[i] !== b[i]) { + x = a[i] + y = b[i] + break + } + } + + if (x < y) return -1 + if (y < x) return 1 + return 0 +} + +Buffer.isEncoding = function isEncoding (encoding) { + switch (String(encoding).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 true + default: + return false + } +} + +Buffer.concat = function concat (list, length) { + if (!Array.isArray(list)) { + throw new TypeError('"list" argument must be an Array of Buffers') + } + + if (list.length === 0) { + return Buffer.alloc(0) + } + + let i + if (length === undefined) { + length = 0 + for (i = 0; i < list.length; ++i) { + length += list[i].length + } + } + + const buffer = Buffer.allocUnsafe(length) + let pos = 0 + for (i = 0; i < list.length; ++i) { + let buf = list[i] + if (isInstance(buf, Uint8Array)) { + if (pos + buf.length > buffer.length) { + if (!Buffer.isBuffer(buf)) buf = Buffer.from(buf) + buf.copy(buffer, pos) + } else { + Uint8Array.prototype.set.call( + buffer, + buf, + pos + ) + } + } else if (!Buffer.isBuffer(buf)) { + throw new TypeError('"list" argument must be an Array of Buffers') + } else { + buf.copy(buffer, pos) + } + pos += buf.length + } + return buffer +} + +function byteLength (string, encoding) { + if (Buffer.isBuffer(string)) { + return string.length + } + if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) { + return string.byteLength + } + if (typeof string !== 'string') { + throw new TypeError( + 'The "string" argument must be one of type string, Buffer, or ArrayBuffer. ' + + 'Received type ' + typeof string + ) + } + + const len = string.length + const mustMatch = (arguments.length > 2 && arguments[2] === true) + if (!mustMatch && len === 0) return 0 + + // Use a for loop to avoid recursion + let loweredCase = false + for (;;) { + switch (encoding) { + case 'ascii': + case 'latin1': + case 'binary': + return len + case 'utf8': + case 'utf-8': + return utf8ToBytes(string).length + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + return len * 2 + case 'hex': + return len >>> 1 + case 'base64': + return base64ToBytes(string).length + default: + if (loweredCase) { + return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8 + } + encoding = ('' + encoding).toLowerCase() + loweredCase = true + } + } +} +Buffer.byteLength = byteLength + +function slowToString (encoding, start, end) { + let loweredCase = false + + // No need to verify that "this.length <= MAX_UINT32" since it's a read-only + // property of a typed array. + + // This behaves neither like String nor Uint8Array in that we set start/end + // to their upper/lower bounds if the value passed is out of range. + // undefined is handled specially as per ECMA-262 6th Edition, + // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization. + if (start === undefined || start < 0) { + start = 0 + } + // Return early if start > this.length. Done here to prevent potential uint32 + // coercion fail below. + if (start > this.length) { + return '' + } + + if (end === undefined || end > this.length) { + end = this.length + } + + if (end <= 0) { + return '' + } + + // Force coercion to uint32. This will also coerce falsey/NaN values to 0. + end >>>= 0 + start >>>= 0 + + if (end <= start) { + return '' + } + + if (!encoding) encoding = 'utf8' + + while (true) { + switch (encoding) { + case 'hex': + return hexSlice(this, start, end) + + case 'utf8': + case 'utf-8': + return utf8Slice(this, start, end) + + case 'ascii': + return asciiSlice(this, start, end) + + case 'latin1': + case 'binary': + return latin1Slice(this, start, end) + + case 'base64': + return base64Slice(this, start, end) + + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + return utf16leSlice(this, start, end) + + default: + if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) + encoding = (encoding + '').toLowerCase() + loweredCase = true + } + } +} + +// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package) +// to detect a Buffer instance. It's not possible to use `instanceof Buffer` +// reliably in a browserify context because there could be multiple different +// copies of the 'buffer' package in use. This method works even for Buffer +// instances that were created from another copy of the `buffer` package. +// See: https://github.com/feross/buffer/issues/154 +Buffer.prototype._isBuffer = true + +function swap (b, n, m) { + const i = b[n] + b[n] = b[m] + b[m] = i +} + +Buffer.prototype.swap16 = function swap16 () { + const len = this.length + if (len % 2 !== 0) { + throw new RangeError('Buffer size must be a multiple of 16-bits') + } + for (let i = 0; i < len; i += 2) { + swap(this, i, i + 1) + } + return this +} + +Buffer.prototype.swap32 = function swap32 () { + const len = this.length + if (len % 4 !== 0) { + throw new RangeError('Buffer size must be a multiple of 32-bits') + } + for (let i = 0; i < len; i += 4) { + swap(this, i, i + 3) + swap(this, i + 1, i + 2) + } + return this +} + +Buffer.prototype.swap64 = function swap64 () { + const len = this.length + if (len % 8 !== 0) { + throw new RangeError('Buffer size must be a multiple of 64-bits') + } + for (let i = 0; i < len; i += 8) { + swap(this, i, i + 7) + swap(this, i + 1, i + 6) + swap(this, i + 2, i + 5) + swap(this, i + 3, i + 4) + } + return this +} + +Buffer.prototype.toString = function toString () { + const length = this.length + if (length === 0) return '' + if (arguments.length === 0) return utf8Slice(this, 0, length) + return slowToString.apply(this, arguments) +} + +Buffer.prototype.toLocaleString = Buffer.prototype.toString + +Buffer.prototype.equals = function equals (b) { + if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer') + if (this === b) return true + return Buffer.compare(this, b) === 0 +} + +Buffer.prototype.inspect = function inspect () { + let str = '' + const max = exports.INSPECT_MAX_BYTES + str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim() + if (this.length > max) str += ' ... ' + return '' +} +if (customInspectSymbol) { + Buffer.prototype[customInspectSymbol] = Buffer.prototype.inspect +} + +Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) { + if (isInstance(target, Uint8Array)) { + target = Buffer.from(target, target.offset, target.byteLength) + } + if (!Buffer.isBuffer(target)) { + throw new TypeError( + 'The "target" argument must be one of type Buffer or Uint8Array. ' + + 'Received type ' + (typeof target) + ) + } + + if (start === undefined) { + start = 0 + } + if (end === undefined) { + end = target ? target.length : 0 + } + if (thisStart === undefined) { + thisStart = 0 + } + if (thisEnd === undefined) { + thisEnd = this.length + } + + if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) { + throw new RangeError('out of range index') + } + + if (thisStart >= thisEnd && start >= end) { + return 0 + } + if (thisStart >= thisEnd) { + return -1 + } + if (start >= end) { + return 1 + } + + start >>>= 0 + end >>>= 0 + thisStart >>>= 0 + thisEnd >>>= 0 + + if (this === target) return 0 + + let x = thisEnd - thisStart + let y = end - start + const len = Math.min(x, y) + + const thisCopy = this.slice(thisStart, thisEnd) + const targetCopy = target.slice(start, end) + + for (let i = 0; i < len; ++i) { + if (thisCopy[i] !== targetCopy[i]) { + x = thisCopy[i] + y = targetCopy[i] + break + } + } + + if (x < y) return -1 + if (y < x) return 1 + return 0 +} + +// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`, +// OR the last index of `val` in `buffer` at offset <= `byteOffset`. +// +// Arguments: +// - buffer - a Buffer to search +// - val - a string, Buffer, or number +// - byteOffset - an index into `buffer`; will be clamped to an int32 +// - encoding - an optional encoding, relevant is val is a string +// - dir - true for indexOf, false for lastIndexOf +function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) { + // Empty buffer means no match + if (buffer.length === 0) return -1 + + // Normalize byteOffset + if (typeof byteOffset === 'string') { + encoding = byteOffset + byteOffset = 0 + } else if (byteOffset > 0x7fffffff) { + byteOffset = 0x7fffffff + } else if (byteOffset < -0x80000000) { + byteOffset = -0x80000000 + } + byteOffset = +byteOffset // Coerce to Number. + if (numberIsNaN(byteOffset)) { + // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer + byteOffset = dir ? 0 : (buffer.length - 1) + } + + // Normalize byteOffset: negative offsets start from the end of the buffer + if (byteOffset < 0) byteOffset = buffer.length + byteOffset + if (byteOffset >= buffer.length) { + if (dir) return -1 + else byteOffset = buffer.length - 1 + } else if (byteOffset < 0) { + if (dir) byteOffset = 0 + else return -1 + } + + // Normalize val + if (typeof val === 'string') { + val = Buffer.from(val, encoding) + } + + // Finally, search either indexOf (if dir is true) or lastIndexOf + if (Buffer.isBuffer(val)) { + // Special case: looking for empty string/buffer always fails + if (val.length === 0) { + return -1 + } + return arrayIndexOf(buffer, val, byteOffset, encoding, dir) + } else if (typeof val === 'number') { + val = val & 0xFF // Search for a byte value [0-255] + if (typeof Uint8Array.prototype.indexOf === 'function') { + if (dir) { + return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset) + } else { + return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset) + } + } + return arrayIndexOf(buffer, [val], byteOffset, encoding, dir) + } + + throw new TypeError('val must be string, number or Buffer') +} + +function arrayIndexOf (arr, val, byteOffset, encoding, dir) { + let indexSize = 1 + let arrLength = arr.length + let valLength = val.length + + if (encoding !== undefined) { + encoding = String(encoding).toLowerCase() + if (encoding === 'ucs2' || encoding === 'ucs-2' || + encoding === 'utf16le' || encoding === 'utf-16le') { + if (arr.length < 2 || val.length < 2) { + return -1 + } + indexSize = 2 + arrLength /= 2 + valLength /= 2 + byteOffset /= 2 + } + } + + function read (buf, i) { + if (indexSize === 1) { + return buf[i] + } else { + return buf.readUInt16BE(i * indexSize) + } + } + + let i + if (dir) { + let foundIndex = -1 + for (i = byteOffset; i < arrLength; i++) { + if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) { + if (foundIndex === -1) foundIndex = i + if (i - foundIndex + 1 === valLength) return foundIndex * indexSize + } else { + if (foundIndex !== -1) i -= i - foundIndex + foundIndex = -1 + } + } + } else { + if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength + for (i = byteOffset; i >= 0; i--) { + let found = true + for (let j = 0; j < valLength; j++) { + if (read(arr, i + j) !== read(val, j)) { + found = false + break + } + } + if (found) return i + } + } + + return -1 +} + +Buffer.prototype.includes = function includes (val, byteOffset, encoding) { + return this.indexOf(val, byteOffset, encoding) !== -1 +} + +Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) { + return bidirectionalIndexOf(this, val, byteOffset, encoding, true) +} + +Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) { + return bidirectionalIndexOf(this, val, byteOffset, encoding, false) +} + +function hexWrite (buf, string, offset, length) { + offset = Number(offset) || 0 + const remaining = buf.length - offset + if (!length) { + length = remaining + } else { + length = Number(length) + if (length > remaining) { + length = remaining + } + } + + const strLen = string.length + + if (length > strLen / 2) { + length = strLen / 2 + } + let i + for (i = 0; i < length; ++i) { + const parsed = parseInt(string.substr(i * 2, 2), 16) + if (numberIsNaN(parsed)) return i + buf[offset + i] = parsed + } + return i +} + +function utf8Write (buf, string, offset, length) { + return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length) +} + +function asciiWrite (buf, string, offset, length) { + return blitBuffer(asciiToBytes(string), buf, offset, length) +} + +function base64Write (buf, string, offset, length) { + return blitBuffer(base64ToBytes(string), buf, offset, length) +} + +function ucs2Write (buf, string, offset, length) { + return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length) +} + +Buffer.prototype.write = function write (string, offset, length, encoding) { + // Buffer#write(string) + if (offset === undefined) { + encoding = 'utf8' + length = this.length + offset = 0 + // Buffer#write(string, encoding) + } else if (length === undefined && typeof offset === 'string') { + encoding = offset + length = this.length + offset = 0 + // Buffer#write(string, offset[, length][, encoding]) + } else if (isFinite(offset)) { + offset = offset >>> 0 + if (isFinite(length)) { + length = length >>> 0 + if (encoding === undefined) encoding = 'utf8' + } else { + encoding = length + length = undefined + } + } else { + throw new Error( + 'Buffer.write(string, encoding, offset[, length]) is no longer supported' + ) + } + + const remaining = this.length - offset + if (length === undefined || length > remaining) length = remaining + + if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) { + throw new RangeError('Attempt to write outside buffer bounds') + } + + if (!encoding) encoding = 'utf8' + + let loweredCase = false + for (;;) { + switch (encoding) { + case 'hex': + return hexWrite(this, string, offset, length) + + case 'utf8': + case 'utf-8': + return utf8Write(this, string, offset, length) + + case 'ascii': + case 'latin1': + case 'binary': + return asciiWrite(this, string, offset, length) + + case 'base64': + // Warning: maxLength not taken into account in base64Write + return base64Write(this, string, offset, length) + + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + return ucs2Write(this, string, offset, length) + + default: + if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) + encoding = ('' + encoding).toLowerCase() + loweredCase = true + } + } +} + +Buffer.prototype.toJSON = function toJSON () { + return { + type: 'Buffer', + data: Array.prototype.slice.call(this._arr || this, 0) + } +} + +function base64Slice (buf, start, end) { + if (start === 0 && end === buf.length) { + return base64.fromByteArray(buf) + } else { + return base64.fromByteArray(buf.slice(start, end)) + } +} + +function utf8Slice (buf, start, end) { + end = Math.min(buf.length, end) + const res = [] + + let i = start + while (i < end) { + const firstByte = buf[i] + let codePoint = null + let bytesPerSequence = (firstByte > 0xEF) + ? 4 + : (firstByte > 0xDF) + ? 3 + : (firstByte > 0xBF) + ? 2 + : 1 + + if (i + bytesPerSequence <= end) { + let secondByte, thirdByte, fourthByte, tempCodePoint + + switch (bytesPerSequence) { + case 1: + if (firstByte < 0x80) { + codePoint = firstByte + } + break + case 2: + secondByte = buf[i + 1] + if ((secondByte & 0xC0) === 0x80) { + tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F) + if (tempCodePoint > 0x7F) { + codePoint = tempCodePoint + } + } + break + case 3: + secondByte = buf[i + 1] + thirdByte = buf[i + 2] + if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) { + tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F) + if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) { + codePoint = tempCodePoint + } + } + break + case 4: + secondByte = buf[i + 1] + thirdByte = buf[i + 2] + fourthByte = buf[i + 3] + if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) { + tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F) + if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) { + codePoint = tempCodePoint + } + } + } + } + + if (codePoint === null) { + // we did not generate a valid codePoint so insert a + // replacement char (U+FFFD) and advance only 1 byte + codePoint = 0xFFFD + bytesPerSequence = 1 + } else if (codePoint > 0xFFFF) { + // encode to utf16 (surrogate pair dance) + codePoint -= 0x10000 + res.push(codePoint >>> 10 & 0x3FF | 0xD800) + codePoint = 0xDC00 | codePoint & 0x3FF + } + + res.push(codePoint) + i += bytesPerSequence + } + + return decodeCodePointsArray(res) +} + +// Based on http://stackoverflow.com/a/22747272/680742, the browser with +// the lowest limit is Chrome, with 0x10000 args. +// We go 1 magnitude less, for safety +const MAX_ARGUMENTS_LENGTH = 0x1000 + +function decodeCodePointsArray (codePoints) { + const len = codePoints.length + if (len <= MAX_ARGUMENTS_LENGTH) { + return String.fromCharCode.apply(String, codePoints) // avoid extra slice() + } + + // Decode in chunks to avoid "call stack size exceeded". + let res = '' + let i = 0 + while (i < len) { + res += String.fromCharCode.apply( + String, + codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH) + ) + } + return res +} + +function asciiSlice (buf, start, end) { + let ret = '' + end = Math.min(buf.length, end) + + for (let i = start; i < end; ++i) { + ret += String.fromCharCode(buf[i] & 0x7F) + } + return ret +} + +function latin1Slice (buf, start, end) { + let ret = '' + end = Math.min(buf.length, end) + + for (let i = start; i < end; ++i) { + ret += String.fromCharCode(buf[i]) + } + return ret +} + +function hexSlice (buf, start, end) { + const len = buf.length + + if (!start || start < 0) start = 0 + if (!end || end < 0 || end > len) end = len + + let out = '' + for (let i = start; i < end; ++i) { + out += hexSliceLookupTable[buf[i]] + } + return out +} + +function utf16leSlice (buf, start, end) { + const bytes = buf.slice(start, end) + let res = '' + // If bytes.length is odd, the last 8 bits must be ignored (same as node.js) + for (let i = 0; i < bytes.length - 1; i += 2) { + res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256)) + } + return res +} + +Buffer.prototype.slice = function slice (start, end) { + const len = this.length + start = ~~start + end = end === undefined ? len : ~~end + + if (start < 0) { + start += len + if (start < 0) start = 0 + } else if (start > len) { + start = len + } + + if (end < 0) { + end += len + if (end < 0) end = 0 + } else if (end > len) { + end = len + } + + if (end < start) end = start + + const newBuf = this.subarray(start, end) + // Return an augmented `Uint8Array` instance + Object.setPrototypeOf(newBuf, Buffer.prototype) + + return newBuf +} + +/* + * Need to make sure that buffer isn't trying to write out of bounds. + */ +function checkOffset (offset, ext, length) { + if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint') + if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length') +} + +Buffer.prototype.readUintLE = +Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) { + offset = offset >>> 0 + byteLength = byteLength >>> 0 + if (!noAssert) checkOffset(offset, byteLength, this.length) + + let val = this[offset] + let mul = 1 + let i = 0 + while (++i < byteLength && (mul *= 0x100)) { + val += this[offset + i] * mul + } + + return val +} + +Buffer.prototype.readUintBE = +Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) { + offset = offset >>> 0 + byteLength = byteLength >>> 0 + if (!noAssert) { + checkOffset(offset, byteLength, this.length) + } + + let val = this[offset + --byteLength] + let mul = 1 + while (byteLength > 0 && (mul *= 0x100)) { + val += this[offset + --byteLength] * mul + } + + return val +} + +Buffer.prototype.readUint8 = +Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 1, this.length) + return this[offset] +} + +Buffer.prototype.readUint16LE = +Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 2, this.length) + return this[offset] | (this[offset + 1] << 8) +} + +Buffer.prototype.readUint16BE = +Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 2, this.length) + return (this[offset] << 8) | this[offset + 1] +} + +Buffer.prototype.readUint32LE = +Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 4, this.length) + + return ((this[offset]) | + (this[offset + 1] << 8) | + (this[offset + 2] << 16)) + + (this[offset + 3] * 0x1000000) +} + +Buffer.prototype.readUint32BE = +Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 4, this.length) + + return (this[offset] * 0x1000000) + + ((this[offset + 1] << 16) | + (this[offset + 2] << 8) | + this[offset + 3]) +} + +Buffer.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE (offset) { + offset = offset >>> 0 + validateNumber(offset, 'offset') + const first = this[offset] + const last = this[offset + 7] + if (first === undefined || last === undefined) { + boundsError(offset, this.length - 8) + } + + const lo = first + + this[++offset] * 2 ** 8 + + this[++offset] * 2 ** 16 + + this[++offset] * 2 ** 24 + + const hi = this[++offset] + + this[++offset] * 2 ** 8 + + this[++offset] * 2 ** 16 + + last * 2 ** 24 + + return BigInt(lo) + (BigInt(hi) << BigInt(32)) +}) + +Buffer.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE (offset) { + offset = offset >>> 0 + validateNumber(offset, 'offset') + const first = this[offset] + const last = this[offset + 7] + if (first === undefined || last === undefined) { + boundsError(offset, this.length - 8) + } + + const hi = first * 2 ** 24 + + this[++offset] * 2 ** 16 + + this[++offset] * 2 ** 8 + + this[++offset] + + const lo = this[++offset] * 2 ** 24 + + this[++offset] * 2 ** 16 + + this[++offset] * 2 ** 8 + + last + + return (BigInt(hi) << BigInt(32)) + BigInt(lo) +}) + +Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) { + offset = offset >>> 0 + byteLength = byteLength >>> 0 + if (!noAssert) checkOffset(offset, byteLength, this.length) + + let val = this[offset] + let mul = 1 + let i = 0 + while (++i < byteLength && (mul *= 0x100)) { + val += this[offset + i] * mul + } + mul *= 0x80 + + if (val >= mul) val -= Math.pow(2, 8 * byteLength) + + return val +} + +Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) { + offset = offset >>> 0 + byteLength = byteLength >>> 0 + if (!noAssert) checkOffset(offset, byteLength, this.length) + + let i = byteLength + let mul = 1 + let val = this[offset + --i] + while (i > 0 && (mul *= 0x100)) { + val += this[offset + --i] * mul + } + mul *= 0x80 + + if (val >= mul) val -= Math.pow(2, 8 * byteLength) + + return val +} + +Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 1, this.length) + if (!(this[offset] & 0x80)) return (this[offset]) + return ((0xff - this[offset] + 1) * -1) +} + +Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 2, this.length) + const val = this[offset] | (this[offset + 1] << 8) + return (val & 0x8000) ? val | 0xFFFF0000 : val +} + +Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 2, this.length) + const val = this[offset + 1] | (this[offset] << 8) + return (val & 0x8000) ? val | 0xFFFF0000 : val +} + +Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 4, this.length) + + return (this[offset]) | + (this[offset + 1] << 8) | + (this[offset + 2] << 16) | + (this[offset + 3] << 24) +} + +Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 4, this.length) + + return (this[offset] << 24) | + (this[offset + 1] << 16) | + (this[offset + 2] << 8) | + (this[offset + 3]) +} + +Buffer.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE (offset) { + offset = offset >>> 0 + validateNumber(offset, 'offset') + const first = this[offset] + const last = this[offset + 7] + if (first === undefined || last === undefined) { + boundsError(offset, this.length - 8) + } + + const val = this[offset + 4] + + this[offset + 5] * 2 ** 8 + + this[offset + 6] * 2 ** 16 + + (last << 24) // Overflow + + return (BigInt(val) << BigInt(32)) + + BigInt(first + + this[++offset] * 2 ** 8 + + this[++offset] * 2 ** 16 + + this[++offset] * 2 ** 24) +}) + +Buffer.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE (offset) { + offset = offset >>> 0 + validateNumber(offset, 'offset') + const first = this[offset] + const last = this[offset + 7] + if (first === undefined || last === undefined) { + boundsError(offset, this.length - 8) + } + + const val = (first << 24) + // Overflow + this[++offset] * 2 ** 16 + + this[++offset] * 2 ** 8 + + this[++offset] + + return (BigInt(val) << BigInt(32)) + + BigInt(this[++offset] * 2 ** 24 + + this[++offset] * 2 ** 16 + + this[++offset] * 2 ** 8 + + last) +}) + +Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 4, this.length) + return ieee754.read(this, offset, true, 23, 4) +} + +Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 4, this.length) + return ieee754.read(this, offset, false, 23, 4) +} + +Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 8, this.length) + return ieee754.read(this, offset, true, 52, 8) +} + +Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 8, this.length) + return ieee754.read(this, offset, false, 52, 8) +} + +function checkInt (buf, value, offset, ext, max, min) { + if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance') + if (value > max || value < min) throw new RangeError('"value" argument is out of bounds') + if (offset + ext > buf.length) throw new RangeError('Index out of range') +} + +Buffer.prototype.writeUintLE = +Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) { + value = +value + offset = offset >>> 0 + byteLength = byteLength >>> 0 + if (!noAssert) { + const maxBytes = Math.pow(2, 8 * byteLength) - 1 + checkInt(this, value, offset, byteLength, maxBytes, 0) + } + + let mul = 1 + let i = 0 + this[offset] = value & 0xFF + while (++i < byteLength && (mul *= 0x100)) { + this[offset + i] = (value / mul) & 0xFF + } + + return offset + byteLength +} + +Buffer.prototype.writeUintBE = +Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) { + value = +value + offset = offset >>> 0 + byteLength = byteLength >>> 0 + if (!noAssert) { + const maxBytes = Math.pow(2, 8 * byteLength) - 1 + checkInt(this, value, offset, byteLength, maxBytes, 0) + } + + let i = byteLength - 1 + let mul = 1 + this[offset + i] = value & 0xFF + while (--i >= 0 && (mul *= 0x100)) { + this[offset + i] = (value / mul) & 0xFF + } + + return offset + byteLength +} + +Buffer.prototype.writeUint8 = +Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0) + this[offset] = (value & 0xff) + return offset + 1 +} + +Buffer.prototype.writeUint16LE = +Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) + this[offset] = (value & 0xff) + this[offset + 1] = (value >>> 8) + return offset + 2 +} + +Buffer.prototype.writeUint16BE = +Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) + this[offset] = (value >>> 8) + this[offset + 1] = (value & 0xff) + return offset + 2 +} + +Buffer.prototype.writeUint32LE = +Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) + this[offset + 3] = (value >>> 24) + this[offset + 2] = (value >>> 16) + this[offset + 1] = (value >>> 8) + this[offset] = (value & 0xff) + return offset + 4 +} + +Buffer.prototype.writeUint32BE = +Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) + this[offset] = (value >>> 24) + this[offset + 1] = (value >>> 16) + this[offset + 2] = (value >>> 8) + this[offset + 3] = (value & 0xff) + return offset + 4 +} + +function wrtBigUInt64LE (buf, value, offset, min, max) { + checkIntBI(value, min, max, buf, offset, 7) + + let lo = Number(value & BigInt(0xffffffff)) + buf[offset++] = lo + lo = lo >> 8 + buf[offset++] = lo + lo = lo >> 8 + buf[offset++] = lo + lo = lo >> 8 + buf[offset++] = lo + let hi = Number(value >> BigInt(32) & BigInt(0xffffffff)) + buf[offset++] = hi + hi = hi >> 8 + buf[offset++] = hi + hi = hi >> 8 + buf[offset++] = hi + hi = hi >> 8 + buf[offset++] = hi + return offset +} + +function wrtBigUInt64BE (buf, value, offset, min, max) { + checkIntBI(value, min, max, buf, offset, 7) + + let lo = Number(value & BigInt(0xffffffff)) + buf[offset + 7] = lo + lo = lo >> 8 + buf[offset + 6] = lo + lo = lo >> 8 + buf[offset + 5] = lo + lo = lo >> 8 + buf[offset + 4] = lo + let hi = Number(value >> BigInt(32) & BigInt(0xffffffff)) + buf[offset + 3] = hi + hi = hi >> 8 + buf[offset + 2] = hi + hi = hi >> 8 + buf[offset + 1] = hi + hi = hi >> 8 + buf[offset] = hi + return offset + 8 +} + +Buffer.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE (value, offset = 0) { + return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt('0xffffffffffffffff')) +}) + +Buffer.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE (value, offset = 0) { + return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt('0xffffffffffffffff')) +}) + +Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) { + const limit = Math.pow(2, (8 * byteLength) - 1) + + checkInt(this, value, offset, byteLength, limit - 1, -limit) + } + + let i = 0 + let mul = 1 + let sub = 0 + this[offset] = value & 0xFF + while (++i < byteLength && (mul *= 0x100)) { + if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) { + sub = 1 + } + this[offset + i] = ((value / mul) >> 0) - sub & 0xFF + } + + return offset + byteLength +} + +Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) { + const limit = Math.pow(2, (8 * byteLength) - 1) + + checkInt(this, value, offset, byteLength, limit - 1, -limit) + } + + let i = byteLength - 1 + let mul = 1 + let sub = 0 + this[offset + i] = value & 0xFF + while (--i >= 0 && (mul *= 0x100)) { + if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) { + sub = 1 + } + this[offset + i] = ((value / mul) >> 0) - sub & 0xFF + } + + return offset + byteLength +} + +Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80) + if (value < 0) value = 0xff + value + 1 + this[offset] = (value & 0xff) + return offset + 1 +} + +Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000) + this[offset] = (value & 0xff) + this[offset + 1] = (value >>> 8) + return offset + 2 +} + +Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000) + this[offset] = (value >>> 8) + this[offset + 1] = (value & 0xff) + return offset + 2 +} + +Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) + this[offset] = (value & 0xff) + this[offset + 1] = (value >>> 8) + this[offset + 2] = (value >>> 16) + this[offset + 3] = (value >>> 24) + return offset + 4 +} + +Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) + if (value < 0) value = 0xffffffff + value + 1 + this[offset] = (value >>> 24) + this[offset + 1] = (value >>> 16) + this[offset + 2] = (value >>> 8) + this[offset + 3] = (value & 0xff) + return offset + 4 +} + +Buffer.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE (value, offset = 0) { + return wrtBigUInt64LE(this, value, offset, -BigInt('0x8000000000000000'), BigInt('0x7fffffffffffffff')) +}) + +Buffer.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE (value, offset = 0) { + return wrtBigUInt64BE(this, value, offset, -BigInt('0x8000000000000000'), BigInt('0x7fffffffffffffff')) +}) + +function checkIEEE754 (buf, value, offset, ext, max, min) { + if (offset + ext > buf.length) throw new RangeError('Index out of range') + if (offset < 0) throw new RangeError('Index out of range') +} + +function writeFloat (buf, value, offset, littleEndian, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) { + checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38) + } + ieee754.write(buf, value, offset, littleEndian, 23, 4) + return offset + 4 +} + +Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) { + return writeFloat(this, value, offset, true, noAssert) +} + +Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) { + return writeFloat(this, value, offset, false, noAssert) +} + +function writeDouble (buf, value, offset, littleEndian, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) { + checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308) + } + ieee754.write(buf, value, offset, littleEndian, 52, 8) + return offset + 8 +} + +Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) { + return writeDouble(this, value, offset, true, noAssert) +} + +Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) { + return writeDouble(this, value, offset, false, noAssert) +} + +// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length) +Buffer.prototype.copy = function copy (target, targetStart, start, end) { + if (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer') + if (!start) start = 0 + if (!end && end !== 0) end = this.length + if (targetStart >= target.length) targetStart = target.length + if (!targetStart) targetStart = 0 + if (end > 0 && end < start) end = start + + // Copy 0 bytes; we're done + if (end === start) return 0 + if (target.length === 0 || this.length === 0) return 0 + + // Fatal error conditions + if (targetStart < 0) { + throw new RangeError('targetStart out of bounds') + } + if (start < 0 || start >= this.length) throw new RangeError('Index out of range') + if (end < 0) throw new RangeError('sourceEnd out of bounds') + + // Are we oob? + if (end > this.length) end = this.length + if (target.length - targetStart < end - start) { + end = target.length - targetStart + start + } + + const len = end - start + + if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') { + // Use built-in when available, missing from IE11 + this.copyWithin(targetStart, start, end) + } else { + Uint8Array.prototype.set.call( + target, + this.subarray(start, end), + targetStart + ) + } + + return len +} + +// Usage: +// buffer.fill(number[, offset[, end]]) +// buffer.fill(buffer[, offset[, end]]) +// buffer.fill(string[, offset[, end]][, encoding]) +Buffer.prototype.fill = function fill (val, start, end, encoding) { + // Handle string cases: + if (typeof val === 'string') { + if (typeof start === 'string') { + encoding = start + start = 0 + end = this.length + } else if (typeof end === 'string') { + encoding = end + end = this.length + } + if (encoding !== undefined && typeof encoding !== 'string') { + throw new TypeError('encoding must be a string') + } + if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) { + throw new TypeError('Unknown encoding: ' + encoding) + } + if (val.length === 1) { + const code = val.charCodeAt(0) + if ((encoding === 'utf8' && code < 128) || + encoding === 'latin1') { + // Fast path: If `val` fits into a single byte, use that numeric value. + val = code + } + } + } else if (typeof val === 'number') { + val = val & 255 + } else if (typeof val === 'boolean') { + val = Number(val) + } + + // Invalid ranges are not set to a default, so can range check early. + if (start < 0 || this.length < start || this.length < end) { + throw new RangeError('Out of range index') + } + + if (end <= start) { + return this + } + + start = start >>> 0 + end = end === undefined ? this.length : end >>> 0 + + if (!val) val = 0 + + let i + if (typeof val === 'number') { + for (i = start; i < end; ++i) { + this[i] = val + } + } else { + const bytes = Buffer.isBuffer(val) + ? val + : Buffer.from(val, encoding) + const len = bytes.length + if (len === 0) { + throw new TypeError('The value "' + val + + '" is invalid for argument "value"') + } + for (i = 0; i < end - start; ++i) { + this[i + start] = bytes[i % len] + } + } + + return this +} + +// CUSTOM ERRORS +// ============= + +// Simplified versions from Node, changed for Buffer-only usage +const errors = {} +function E (sym, getMessage, Base) { + errors[sym] = class NodeError extends Base { + constructor () { + super() + + Object.defineProperty(this, 'message', { + value: getMessage.apply(this, arguments), + writable: true, + configurable: true + }) + + // Add the error code to the name to include it in the stack trace. + this.name = `${this.name} [${sym}]` + // Access the stack to generate the error message including the error code + // from the name. + this.stack // eslint-disable-line no-unused-expressions + // Reset the name to the actual name. + delete this.name + } + + get code () { + return sym + } + + set code (value) { + Object.defineProperty(this, 'code', { + configurable: true, + enumerable: true, + value, + writable: true + }) + } + + toString () { + return `${this.name} [${sym}]: ${this.message}` + } + } +} + +E('ERR_BUFFER_OUT_OF_BOUNDS', + function (name) { + if (name) { + return `${name} is outside of buffer bounds` + } + + return 'Attempt to access memory outside buffer bounds' + }, RangeError) +E('ERR_INVALID_ARG_TYPE', + function (name, actual) { + return `The "${name}" argument must be of type number. Received type ${typeof actual}` + }, TypeError) +E('ERR_OUT_OF_RANGE', + function (str, range, input) { + let msg = `The value of "${str}" is out of range.` + let received = input + if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) { + received = addNumericalSeparator(String(input)) + } else if (typeof input === 'bigint') { + received = String(input) + if (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) { + received = addNumericalSeparator(received) + } + received += 'n' + } + msg += ` It must be ${range}. Received ${received}` + return msg + }, RangeError) + +function addNumericalSeparator (val) { + let res = '' + let i = val.length + const start = val[0] === '-' ? 1 : 0 + for (; i >= start + 4; i -= 3) { + res = `_${val.slice(i - 3, i)}${res}` + } + return `${val.slice(0, i)}${res}` +} + +// CHECK FUNCTIONS +// =============== + +function checkBounds (buf, offset, byteLength) { + validateNumber(offset, 'offset') + if (buf[offset] === undefined || buf[offset + byteLength] === undefined) { + boundsError(offset, buf.length - (byteLength + 1)) + } +} + +function checkIntBI (value, min, max, buf, offset, byteLength) { + if (value > max || value < min) { + const n = typeof min === 'bigint' ? 'n' : '' + let range + if (byteLength > 3) { + if (min === 0 || min === BigInt(0)) { + range = `>= 0${n} and < 2${n} ** ${(byteLength + 1) * 8}${n}` + } else { + range = `>= -(2${n} ** ${(byteLength + 1) * 8 - 1}${n}) and < 2 ** ` + + `${(byteLength + 1) * 8 - 1}${n}` + } + } else { + range = `>= ${min}${n} and <= ${max}${n}` + } + throw new errors.ERR_OUT_OF_RANGE('value', range, value) + } + checkBounds(buf, offset, byteLength) +} + +function validateNumber (value, name) { + if (typeof value !== 'number') { + throw new errors.ERR_INVALID_ARG_TYPE(name, 'number', value) + } +} + +function boundsError (value, length, type) { + if (Math.floor(value) !== value) { + validateNumber(value, type) + throw new errors.ERR_OUT_OF_RANGE(type || 'offset', 'an integer', value) + } + + if (length < 0) { + throw new errors.ERR_BUFFER_OUT_OF_BOUNDS() + } + + throw new errors.ERR_OUT_OF_RANGE(type || 'offset', + `>= ${type ? 1 : 0} and <= ${length}`, + value) +} + +// HELPER FUNCTIONS +// ================ + +const INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g + +function base64clean (str) { + // Node takes equal signs as end of the Base64 encoding + str = str.split('=')[0] + // Node strips out invalid characters like \n and \t from the string, base64-js does not + str = str.trim().replace(INVALID_BASE64_RE, '') + // Node converts strings with length < 2 to '' + if (str.length < 2) return '' + // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not + while (str.length % 4 !== 0) { + str = str + '=' + } + return str +} + +function utf8ToBytes (string, units) { + units = units || Infinity + let codePoint + const length = string.length + let leadSurrogate = null + const bytes = [] + + for (let i = 0; i < length; ++i) { + codePoint = string.charCodeAt(i) + + // is surrogate component + if (codePoint > 0xD7FF && codePoint < 0xE000) { + // last char was a lead + if (!leadSurrogate) { + // no lead yet + if (codePoint > 0xDBFF) { + // unexpected trail + if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) + continue + } else if (i + 1 === length) { + // unpaired lead + if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) + continue + } + + // valid lead + leadSurrogate = codePoint + + continue + } + + // 2 leads in a row + if (codePoint < 0xDC00) { + if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) + leadSurrogate = codePoint + continue + } + + // valid surrogate pair + codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000 + } else if (leadSurrogate) { + // valid bmp char, but last char was a lead + if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) + } + + leadSurrogate = null + + // encode utf8 + if (codePoint < 0x80) { + if ((units -= 1) < 0) break + bytes.push(codePoint) + } else if (codePoint < 0x800) { + if ((units -= 2) < 0) break + bytes.push( + codePoint >> 0x6 | 0xC0, + codePoint & 0x3F | 0x80 + ) + } else if (codePoint < 0x10000) { + if ((units -= 3) < 0) break + bytes.push( + codePoint >> 0xC | 0xE0, + codePoint >> 0x6 & 0x3F | 0x80, + codePoint & 0x3F | 0x80 + ) + } else if (codePoint < 0x110000) { + if ((units -= 4) < 0) break + bytes.push( + codePoint >> 0x12 | 0xF0, + codePoint >> 0xC & 0x3F | 0x80, + codePoint >> 0x6 & 0x3F | 0x80, + codePoint & 0x3F | 0x80 + ) + } else { + throw new Error('Invalid code point') + } + } + + return bytes +} + +function asciiToBytes (str) { + const byteArray = [] + for (let i = 0; i < str.length; ++i) { + // Node's code seems to be doing this and not & 0x7F.. + byteArray.push(str.charCodeAt(i) & 0xFF) + } + return byteArray +} + +function utf16leToBytes (str, units) { + let c, hi, lo + const byteArray = [] + for (let i = 0; i < str.length; ++i) { + if ((units -= 2) < 0) break + + c = str.charCodeAt(i) + hi = c >> 8 + lo = c % 256 + byteArray.push(lo) + byteArray.push(hi) + } + + return byteArray +} + +function base64ToBytes (str) { + return base64.toByteArray(base64clean(str)) +} + +function blitBuffer (src, dst, offset, length) { + let i + for (i = 0; i < length; ++i) { + if ((i + offset >= dst.length) || (i >= src.length)) break + dst[i + offset] = src[i] + } + return i +} + +// ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass +// the `instanceof` check but they should be treated as of that type. +// See: https://github.com/feross/buffer/issues/166 +function isInstance (obj, type) { + return obj instanceof type || + (obj != null && obj.constructor != null && obj.constructor.name != null && + obj.constructor.name === type.name) +} +function numberIsNaN (obj) { + // For IE11 support + return obj !== obj // eslint-disable-line no-self-compare +} + +// Create lookup table for `toString('hex')` +// See: https://github.com/feross/buffer/issues/219 +const hexSliceLookupTable = (function () { + const alphabet = '0123456789abcdef' + const table = new Array(256) + for (let i = 0; i < 16; ++i) { + const i16 = i * 16 + for (let j = 0; j < 16; ++j) { + table[i16 + j] = alphabet[i] + alphabet[j] + } + } + return table +})() + +// Return not function with Error if BigInt not supported +function defineBigIntMethod (fn) { + return typeof BigInt === 'undefined' ? BufferBigIntNotDefined : fn +} + +function BufferBigIntNotDefined () { + throw new Error('BigInt not supported') +} + + +/***/ }), + +/***/ 7187: +/***/ ((module) => { + +"use strict"; +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + + + +var R = typeof Reflect === 'object' ? Reflect : null +var ReflectApply = R && typeof R.apply === 'function' + ? R.apply + : function ReflectApply(target, receiver, args) { + return Function.prototype.apply.call(target, receiver, args); + } + +var ReflectOwnKeys +if (R && typeof R.ownKeys === 'function') { + ReflectOwnKeys = R.ownKeys +} else if (Object.getOwnPropertySymbols) { + ReflectOwnKeys = function ReflectOwnKeys(target) { + return Object.getOwnPropertyNames(target) + .concat(Object.getOwnPropertySymbols(target)); + }; +} else { + ReflectOwnKeys = function ReflectOwnKeys(target) { + return Object.getOwnPropertyNames(target); + }; +} + +function ProcessEmitWarning(warning) { + if (console && console.warn) console.warn(warning); +} + +var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) { + return value !== value; +} + +function EventEmitter() { + EventEmitter.init.call(this); +} +module.exports = EventEmitter; +module.exports.once = once; + +// Backwards-compat with node 0.10.x +EventEmitter.EventEmitter = EventEmitter; + +EventEmitter.prototype._events = undefined; +EventEmitter.prototype._eventsCount = 0; +EventEmitter.prototype._maxListeners = undefined; + +// By default EventEmitters will print a warning if more than 10 listeners are +// added to it. This is a useful default which helps finding memory leaks. +var defaultMaxListeners = 10; + +function checkListener(listener) { + if (typeof listener !== 'function') { + throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener); + } +} + +Object.defineProperty(EventEmitter, 'defaultMaxListeners', { + enumerable: true, + get: function() { + return defaultMaxListeners; + }, + set: function(arg) { + if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) { + throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.'); + } + defaultMaxListeners = arg; + } +}); + +EventEmitter.init = function() { + + if (this._events === undefined || + this._events === Object.getPrototypeOf(this)._events) { + this._events = Object.create(null); + this._eventsCount = 0; + } + + this._maxListeners = this._maxListeners || undefined; +}; + +// Obviously not all Emitters should be limited to 10. This function allows +// that to be increased. Set to zero for unlimited. +EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) { + if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) { + throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.'); + } + this._maxListeners = n; + return this; +}; + +function _getMaxListeners(that) { + if (that._maxListeners === undefined) + return EventEmitter.defaultMaxListeners; + return that._maxListeners; +} + +EventEmitter.prototype.getMaxListeners = function getMaxListeners() { + return _getMaxListeners(this); +}; + +EventEmitter.prototype.emit = function emit(type) { + var args = []; + for (var i = 1; i < arguments.length; i++) args.push(arguments[i]); + var doError = (type === 'error'); + + var events = this._events; + if (events !== undefined) + doError = (doError && events.error === undefined); + else if (!doError) + return false; + + // If there is no 'error' event listener then throw. + if (doError) { + var er; + if (args.length > 0) + er = args[0]; + if (er instanceof Error) { + // Note: The comments on the `throw` lines are intentional, they show + // up in Node's output if this results in an unhandled exception. + throw er; // Unhandled 'error' event + } + // At least give some kind of context to the user + var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : '')); + err.context = er; + throw err; // Unhandled 'error' event + } + + var handler = events[type]; + + if (handler === undefined) + return false; + + if (typeof handler === 'function') { + ReflectApply(handler, this, args); + } else { + var len = handler.length; + var listeners = arrayClone(handler, len); + for (var i = 0; i < len; ++i) + ReflectApply(listeners[i], this, args); + } + + return true; +}; + +function _addListener(target, type, listener, prepend) { + var m; + var events; + var existing; + + checkListener(listener); + + events = target._events; + if (events === undefined) { + events = target._events = Object.create(null); + target._eventsCount = 0; + } else { + // To avoid recursion in the case that type === "newListener"! Before + // adding it to the listeners, first emit "newListener". + if (events.newListener !== undefined) { + target.emit('newListener', type, + listener.listener ? listener.listener : listener); + + // Re-assign `events` because a newListener handler could have caused the + // this._events to be assigned to a new object + events = target._events; + } + existing = events[type]; + } + + if (existing === undefined) { + // Optimize the case of one listener. Don't need the extra array object. + existing = events[type] = listener; + ++target._eventsCount; + } else { + if (typeof existing === 'function') { + // Adding the second element, need to change to array. + existing = events[type] = + prepend ? [listener, existing] : [existing, listener]; + // If we've already got an array, just append. + } else if (prepend) { + existing.unshift(listener); + } else { + existing.push(listener); + } + + // Check for listener leak + m = _getMaxListeners(target); + if (m > 0 && existing.length > m && !existing.warned) { + existing.warned = true; + // No error code for this since it is a Warning + // eslint-disable-next-line no-restricted-syntax + var w = new Error('Possible EventEmitter memory leak detected. ' + + existing.length + ' ' + String(type) + ' listeners ' + + 'added. Use emitter.setMaxListeners() to ' + + 'increase limit'); + w.name = 'MaxListenersExceededWarning'; + w.emitter = target; + w.type = type; + w.count = existing.length; + ProcessEmitWarning(w); + } + } + + return target; +} + +EventEmitter.prototype.addListener = function addListener(type, listener) { + return _addListener(this, type, listener, false); +}; + +EventEmitter.prototype.on = EventEmitter.prototype.addListener; + +EventEmitter.prototype.prependListener = + function prependListener(type, listener) { + return _addListener(this, type, listener, true); + }; + +function onceWrapper() { + if (!this.fired) { + this.target.removeListener(this.type, this.wrapFn); + this.fired = true; + if (arguments.length === 0) + return this.listener.call(this.target); + return this.listener.apply(this.target, arguments); + } +} + +function _onceWrap(target, type, listener) { + var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener }; + var wrapped = onceWrapper.bind(state); + wrapped.listener = listener; + state.wrapFn = wrapped; + return wrapped; +} + +EventEmitter.prototype.once = function once(type, listener) { + checkListener(listener); + this.on(type, _onceWrap(this, type, listener)); + return this; +}; + +EventEmitter.prototype.prependOnceListener = + function prependOnceListener(type, listener) { + checkListener(listener); + this.prependListener(type, _onceWrap(this, type, listener)); + return this; + }; + +// Emits a 'removeListener' event if and only if the listener was removed. +EventEmitter.prototype.removeListener = + function removeListener(type, listener) { + var list, events, position, i, originalListener; + + checkListener(listener); + + events = this._events; + if (events === undefined) + return this; + + list = events[type]; + if (list === undefined) + return this; + + if (list === listener || list.listener === listener) { + if (--this._eventsCount === 0) + this._events = Object.create(null); + else { + delete events[type]; + if (events.removeListener) + this.emit('removeListener', type, list.listener || listener); + } + } else if (typeof list !== 'function') { + position = -1; + + for (i = list.length - 1; i >= 0; i--) { + if (list[i] === listener || list[i].listener === listener) { + originalListener = list[i].listener; + position = i; + break; + } + } + + if (position < 0) + return this; + + if (position === 0) + list.shift(); + else { + spliceOne(list, position); + } + + if (list.length === 1) + events[type] = list[0]; + + if (events.removeListener !== undefined) + this.emit('removeListener', type, originalListener || listener); + } + + return this; + }; + +EventEmitter.prototype.off = EventEmitter.prototype.removeListener; + +EventEmitter.prototype.removeAllListeners = + function removeAllListeners(type) { + var listeners, events, i; + + events = this._events; + if (events === undefined) + return this; + + // not listening for removeListener, no need to emit + if (events.removeListener === undefined) { + if (arguments.length === 0) { + this._events = Object.create(null); + this._eventsCount = 0; + } else if (events[type] !== undefined) { + if (--this._eventsCount === 0) + this._events = Object.create(null); + else + delete events[type]; + } + return this; + } + + // emit removeListener for all listeners on all events + if (arguments.length === 0) { + var keys = Object.keys(events); + var key; + for (i = 0; i < keys.length; ++i) { + key = keys[i]; + if (key === 'removeListener') continue; + this.removeAllListeners(key); + } + this.removeAllListeners('removeListener'); + this._events = Object.create(null); + this._eventsCount = 0; + return this; + } + + listeners = events[type]; + + if (typeof listeners === 'function') { + this.removeListener(type, listeners); + } else if (listeners !== undefined) { + // LIFO order + for (i = listeners.length - 1; i >= 0; i--) { + this.removeListener(type, listeners[i]); + } + } + + return this; + }; + +function _listeners(target, type, unwrap) { + var events = target._events; + + if (events === undefined) + return []; + + var evlistener = events[type]; + if (evlistener === undefined) + return []; + + if (typeof evlistener === 'function') + return unwrap ? [evlistener.listener || evlistener] : [evlistener]; + + return unwrap ? + unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length); +} + +EventEmitter.prototype.listeners = function listeners(type) { + return _listeners(this, type, true); +}; + +EventEmitter.prototype.rawListeners = function rawListeners(type) { + return _listeners(this, type, false); +}; + +EventEmitter.listenerCount = function(emitter, type) { + if (typeof emitter.listenerCount === 'function') { + return emitter.listenerCount(type); + } else { + return listenerCount.call(emitter, type); + } +}; + +EventEmitter.prototype.listenerCount = listenerCount; +function listenerCount(type) { + var events = this._events; + + if (events !== undefined) { + var evlistener = events[type]; + + if (typeof evlistener === 'function') { + return 1; + } else if (evlistener !== undefined) { + return evlistener.length; + } + } + + return 0; +} + +EventEmitter.prototype.eventNames = function eventNames() { + return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : []; +}; + +function arrayClone(arr, n) { + var copy = new Array(n); + for (var i = 0; i < n; ++i) + copy[i] = arr[i]; + return copy; +} + +function spliceOne(list, index) { + for (; index + 1 < list.length; index++) + list[index] = list[index + 1]; + list.pop(); +} + +function unwrapListeners(arr) { + var ret = new Array(arr.length); + for (var i = 0; i < ret.length; ++i) { + ret[i] = arr[i].listener || arr[i]; + } + return ret; +} + +function once(emitter, name) { + return new Promise(function (resolve, reject) { + function errorListener(err) { + emitter.removeListener(name, resolver); + reject(err); + } + + function resolver() { + if (typeof emitter.removeListener === 'function') { + emitter.removeListener('error', errorListener); + } + resolve([].slice.call(arguments)); + }; + + eventTargetAgnosticAddListener(emitter, name, resolver, { once: true }); + if (name !== 'error') { + addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true }); + } + }); +} + +function addErrorHandlerIfEventEmitter(emitter, handler, flags) { + if (typeof emitter.on === 'function') { + eventTargetAgnosticAddListener(emitter, 'error', handler, flags); + } +} + +function eventTargetAgnosticAddListener(emitter, name, listener, flags) { + if (typeof emitter.on === 'function') { + if (flags.once) { + emitter.once(name, listener); + } else { + emitter.on(name, listener); + } + } else if (typeof emitter.addEventListener === 'function') { + // EventTarget does not have `error` event semantics like Node + // EventEmitters, we do not listen for `error` events here. + emitter.addEventListener(name, function wrapListener(arg) { + // IE does not have builtin `{ once: true }` support so we + // have to do it manually. + if (flags.once) { + emitter.removeEventListener(name, wrapListener); + } + listener(arg); + }); + } else { + throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter); + } +} + + +/***/ }), + +/***/ 259: +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +"use strict"; + +//parse Empty Node as self closing node +const buildOptions = (__webpack_require__(7849).buildOptions); + +const defaultOptions = { + attributeNamePrefix: '@_', + attrNodeName: false, + textNodeName: '#text', + ignoreAttributes: true, + cdataTagName: false, + cdataPositionChar: '\\c', + format: false, + indentBy: ' ', + supressEmptyNode: false, + tagValueProcessor: function(a) { + return a; + }, + attrValueProcessor: function(a) { + return a; + }, +}; + +const props = [ + 'attributeNamePrefix', + 'attrNodeName', + 'textNodeName', + 'ignoreAttributes', + 'cdataTagName', + 'cdataPositionChar', + 'format', + 'indentBy', + 'supressEmptyNode', + 'tagValueProcessor', + 'attrValueProcessor', + 'rootNodeName', //when array as root +]; + +function Parser(options) { + this.options = buildOptions(options, defaultOptions, props); + if (this.options.ignoreAttributes || this.options.attrNodeName) { + this.isAttribute = function(/*a*/) { + return false; + }; + } else { + this.attrPrefixLen = this.options.attributeNamePrefix.length; + this.isAttribute = isAttribute; + } + if (this.options.cdataTagName) { + this.isCDATA = isCDATA; + } else { + this.isCDATA = function(/*a*/) { + return false; + }; + } + this.replaceCDATAstr = replaceCDATAstr; + this.replaceCDATAarr = replaceCDATAarr; + + this.processTextOrObjNode = processTextOrObjNode + + if (this.options.format) { + this.indentate = indentate; + this.tagEndChar = '>\n'; + this.newLine = '\n'; + } else { + this.indentate = function() { + return ''; + }; + this.tagEndChar = '>'; + this.newLine = ''; + } + + if (this.options.supressEmptyNode) { + this.buildTextNode = buildEmptyTextNode; + this.buildObjNode = buildEmptyObjNode; + } else { + this.buildTextNode = buildTextValNode; + this.buildObjNode = buildObjectNode; + } + + this.buildTextValNode = buildTextValNode; + this.buildObjectNode = buildObjectNode; +} + +Parser.prototype.parse = function(jObj) { + if(Array.isArray(jObj) && this.options.rootNodeName && this.options.rootNodeName.length > 1){ + jObj = { + [this.options.rootNodeName] : jObj + } + } + return this.j2x(jObj, 0).val; +}; + +Parser.prototype.j2x = function(jObj, level) { + let attrStr = ''; + let val = ''; + for (let key in jObj) { + if (typeof jObj[key] === 'undefined') { + // supress undefined node + } else if (jObj[key] === null) { + val += this.indentate(level) + '<' + key + '/' + this.tagEndChar; + } else if (jObj[key] instanceof Date) { + val += this.buildTextNode(jObj[key], key, '', level); + } else if (typeof jObj[key] !== 'object') { + //premitive type + const attr = this.isAttribute(key); + if (attr) { + attrStr += ' ' + attr + '="' + this.options.attrValueProcessor('' + jObj[key]) + '"'; + } else if (this.isCDATA(key)) { + if (jObj[this.options.textNodeName]) { + val += this.replaceCDATAstr(jObj[this.options.textNodeName], jObj[key]); + } else { + val += this.replaceCDATAstr('', jObj[key]); + } + } else { + //tag value + if (key === this.options.textNodeName) { + if (jObj[this.options.cdataTagName]) { + //value will added while processing cdata + } else { + val += this.options.tagValueProcessor('' + jObj[key]); + } + } else { + val += this.buildTextNode(jObj[key], key, '', level); + } + } + } else if (Array.isArray(jObj[key])) { + //repeated nodes + if (this.isCDATA(key)) { + val += this.indentate(level); + if (jObj[this.options.textNodeName]) { + val += this.replaceCDATAarr(jObj[this.options.textNodeName], jObj[key]); + } else { + val += this.replaceCDATAarr('', jObj[key]); + } + } else { + //nested nodes + const arrLen = jObj[key].length; + for (let j = 0; j < arrLen; j++) { + const item = jObj[key][j]; + if (typeof item === 'undefined') { + // supress undefined node + } else if (item === null) { + val += this.indentate(level) + '<' + key + '/' + this.tagEndChar; + } else if (typeof item === 'object') { + val += this.processTextOrObjNode(item, key, level) + } else { + val += this.buildTextNode(item, key, '', level); + } + } + } + } else { + //nested node + if (this.options.attrNodeName && key === this.options.attrNodeName) { + const Ks = Object.keys(jObj[key]); + const L = Ks.length; + for (let j = 0; j < L; j++) { + attrStr += ' ' + Ks[j] + '="' + this.options.attrValueProcessor('' + jObj[key][Ks[j]]) + '"'; + } + } else { + val += this.processTextOrObjNode(jObj[key], key, level) + } + } + } + return {attrStr: attrStr, val: val}; +}; + +function processTextOrObjNode (object, key, level) { + const result = this.j2x(object, level + 1); + if (object[this.options.textNodeName] !== undefined && Object.keys(object).length === 1) { + return this.buildTextNode(result.val, key, result.attrStr, level); + } else { + return this.buildObjNode(result.val, key, result.attrStr, level); + } +} + +function replaceCDATAstr(str, cdata) { + str = this.options.tagValueProcessor('' + str); + if (this.options.cdataPositionChar === '' || str === '') { + return str + ''); + } + return str + this.newLine; + } +} + +function buildObjectNode(val, key, attrStr, level) { + if (attrStr && val.indexOf('<') === -1) { + return ( + this.indentate(level) + + '<' + + key + + attrStr + + '>' + + val + + //+ this.newLine + // + this.indentate(level) + '' + + this.options.tagValueProcessor(val) + + ' { + +"use strict"; + +const char = function(a) { + return String.fromCharCode(a); +}; + +const chars = { + nilChar: char(176), + missingChar: char(201), + nilPremitive: char(175), + missingPremitive: char(200), + + emptyChar: char(178), + emptyValue: char(177), //empty Premitive + + boundryChar: char(179), + + objStart: char(198), + arrStart: char(204), + arrayEnd: char(185), +}; + +const charsArr = [ + chars.nilChar, + chars.nilPremitive, + chars.missingChar, + chars.missingPremitive, + chars.boundryChar, + chars.emptyChar, + chars.emptyValue, + chars.arrayEnd, + chars.objStart, + chars.arrStart, +]; + +const _e = function(node, e_schema, options) { + if (typeof e_schema === 'string') { + //premitive + if (node && node[0] && node[0].val !== undefined) { + return getValue(node[0].val, e_schema); + } else { + return getValue(node, e_schema); + } + } else { + const hasValidData = hasData(node); + if (hasValidData === true) { + let str = ''; + if (Array.isArray(e_schema)) { + //attributes can't be repeated. hence check in children tags only + str += chars.arrStart; + const itemSchema = e_schema[0]; + //const itemSchemaType = itemSchema; + const arr_len = node.length; + + if (typeof itemSchema === 'string') { + for (let arr_i = 0; arr_i < arr_len; arr_i++) { + const r = getValue(node[arr_i].val, itemSchema); + str = processValue(str, r); + } + } else { + for (let arr_i = 0; arr_i < arr_len; arr_i++) { + const r = _e(node[arr_i], itemSchema, options); + str = processValue(str, r); + } + } + str += chars.arrayEnd; //indicates that next item is not array item + } else { + //object + str += chars.objStart; + const keys = Object.keys(e_schema); + if (Array.isArray(node)) { + node = node[0]; + } + for (let i in keys) { + const key = keys[i]; + //a property defined in schema can be present either in attrsMap or children tags + //options.textNodeName will not present in both maps, take it's value from val + //options.attrNodeName will be present in attrsMap + let r; + if (!options.ignoreAttributes && node.attrsMap && node.attrsMap[key]) { + r = _e(node.attrsMap[key], e_schema[key], options); + } else if (key === options.textNodeName) { + r = _e(node.val, e_schema[key], options); + } else { + r = _e(node.child[key], e_schema[key], options); + } + str = processValue(str, r); + } + } + return str; + } else { + return hasValidData; + } + } +}; + +const getValue = function(a /*, type*/) { + switch (a) { + case undefined: + return chars.missingPremitive; + case null: + return chars.nilPremitive; + case '': + return chars.emptyValue; + default: + return a; + } +}; + +const processValue = function(str, r) { + if (!isAppChar(r[0]) && !isAppChar(str[str.length - 1])) { + str += chars.boundryChar; + } + return str + r; +}; + +const isAppChar = function(ch) { + return charsArr.indexOf(ch) !== -1; +}; + +function hasData(jObj) { + if (jObj === undefined) { + return chars.missingChar; + } else if (jObj === null) { + return chars.nilChar; + } else if ( + jObj.child && + Object.keys(jObj.child).length === 0 && + (!jObj.attrsMap || Object.keys(jObj.attrsMap).length === 0) + ) { + return chars.emptyChar; + } else { + return true; + } +} + +const x2j = __webpack_require__(3543); +const buildOptions = (__webpack_require__(7849).buildOptions); + +const convert2nimn = function(node, e_schema, options) { + options = buildOptions(options, x2j.defaultOptions, x2j.props); + return _e(node, e_schema, options); +}; + +exports.convert2nimn = convert2nimn; + + +/***/ }), + +/***/ 284: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + + +const util = __webpack_require__(7849); + +const convertToJson = function(node, options, parentTagName) { + const jObj = {}; + + // when no child node or attr is present + if (!options.alwaysCreateTextNode && (!node.child || util.isEmptyObject(node.child)) && (!node.attrsMap || util.isEmptyObject(node.attrsMap))) { + return util.isExist(node.val) ? node.val : ''; + } + + // otherwise create a textnode if node has some text + if (util.isExist(node.val) && !(typeof node.val === 'string' && (node.val === '' || node.val === options.cdataPositionChar))) { + const asArray = util.isTagNameInArrayMode(node.tagname, options.arrayMode, parentTagName) + jObj[options.textNodeName] = asArray ? [node.val] : node.val; + } + + util.merge(jObj, node.attrsMap, options.arrayMode); + + const keys = Object.keys(node.child); + for (let index = 0; index < keys.length; index++) { + const tagName = keys[index]; + if (node.child[tagName] && node.child[tagName].length > 1) { + jObj[tagName] = []; + for (let tag in node.child[tagName]) { + if (node.child[tagName].hasOwnProperty(tag)) { + jObj[tagName].push(convertToJson(node.child[tagName][tag], options, tagName)); + } + } + } else { + const result = convertToJson(node.child[tagName][0], options, tagName); + const asArray = (options.arrayMode === true && typeof result === 'object') || util.isTagNameInArrayMode(tagName, options.arrayMode, parentTagName); + jObj[tagName] = asArray ? [result] : result; + } + } + + //add value + return jObj; +}; + +exports.convertToJson = convertToJson; + + +/***/ }), + +/***/ 7702: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + + +const util = __webpack_require__(7849); +const buildOptions = (__webpack_require__(7849).buildOptions); +const x2j = __webpack_require__(3543); + +//TODO: do it later +const convertToJsonString = function(node, options) { + options = buildOptions(options, x2j.defaultOptions, x2j.props); + + options.indentBy = options.indentBy || ''; + return _cToJsonStr(node, options, 0); +}; + +const _cToJsonStr = function(node, options, level) { + let jObj = '{'; + + //traver through all the children + const keys = Object.keys(node.child); + + for (let index = 0; index < keys.length; index++) { + const tagname = keys[index]; + if (node.child[tagname] && node.child[tagname].length > 1) { + jObj += '"' + tagname + '" : [ '; + for (let tag in node.child[tagname]) { + jObj += _cToJsonStr(node.child[tagname][tag], options) + ' , '; + } + jObj = jObj.substr(0, jObj.length - 1) + ' ] '; //remove extra comma in last + } else { + jObj += '"' + tagname + '" : ' + _cToJsonStr(node.child[tagname][0], options) + ' ,'; + } + } + util.merge(jObj, node.attrsMap); + //add attrsMap as new children + if (util.isEmptyObject(jObj)) { + return util.isExist(node.val) ? node.val : ''; + } else { + if (util.isExist(node.val)) { + if (!(typeof node.val === 'string' && (node.val === '' || node.val === options.cdataPositionChar))) { + jObj += '"' + options.textNodeName + '" : ' + stringval(node.val); + } + } + } + //add value + if (jObj[jObj.length - 1] === ',') { + jObj = jObj.substr(0, jObj.length - 2); + } + return jObj + '}'; +}; + +function stringval(v) { + if (v === true || v === false || !isNaN(v)) { + return v; + } else { + return '"' + v + '"'; + } +} + +function indentate(options, level) { + return options.indentBy.repeat(level); +} + +exports.convertToJsonString = convertToJsonString; + + +/***/ }), + +/***/ 6965: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + + +const nodeToJson = __webpack_require__(284); +const xmlToNodeobj = __webpack_require__(3543); +const x2xmlnode = __webpack_require__(3543); +const buildOptions = (__webpack_require__(7849).buildOptions); +const validator = __webpack_require__(8501); + +exports.parse = function(xmlData, givenOptions = {}, validationOption) { + if( validationOption){ + if(validationOption === true) validationOption = {} + + const result = validator.validate(xmlData, validationOption); + if (result !== true) { + throw Error( result.err.msg) + } + } + if(givenOptions.parseTrueNumberOnly + && givenOptions.parseNodeValue !== false + && !givenOptions.numParseOptions){ + + givenOptions.numParseOptions = { + leadingZeros: false, + } + } + let options = buildOptions(givenOptions, x2xmlnode.defaultOptions, x2xmlnode.props); + + const traversableObj = xmlToNodeobj.getTraversalObj(xmlData, options) + //print(traversableObj, " "); + return nodeToJson.convertToJson(traversableObj, options); +}; +exports.convertTonimn = __webpack_require__(8398).convert2nimn; +exports.getTraversalObj = xmlToNodeobj.getTraversalObj; +exports.convertToJson = nodeToJson.convertToJson; +exports.convertToJsonString = __webpack_require__(7702).convertToJsonString; +exports.validate = validator.validate; +exports.j2xParser = __webpack_require__(259); +exports.parseToNimn = function(xmlData, schema, options) { + return exports.convertTonimn(exports.getTraversalObj(xmlData, options), schema, options); +}; + + +function print(xmlNode, indentation){ + if(xmlNode){ + console.log(indentation + "{") + console.log(indentation + " \"tagName\": \"" + xmlNode.tagname + "\", "); + if(xmlNode.parent){ + console.log(indentation + " \"parent\": \"" + xmlNode.parent.tagname + "\", "); + } + console.log(indentation + " \"val\": \"" + xmlNode.val + "\", "); + console.log(indentation + " \"attrs\": " + JSON.stringify(xmlNode.attrsMap,null,4) + ", "); + + if(xmlNode.child){ + console.log(indentation + "\"child\": {") + const indentation2 = indentation + indentation; + Object.keys(xmlNode.child).forEach( function(key) { + const node = xmlNode.child[key]; + + if(Array.isArray(node)){ + console.log(indentation + "\""+key+"\" :[") + node.forEach( function(item,index) { + //console.log(indentation + " \""+index+"\" : [") + print(item, indentation2); + }) + console.log(indentation + "],") + }else{ + console.log(indentation + " \""+key+"\" : {") + print(node, indentation2); + console.log(indentation + "},") + } + }); + console.log(indentation + "},") + } + console.log(indentation + "},") + } +} + + +/***/ }), + +/***/ 7849: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + + +const nameStartChar = ':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'; +const nameChar = nameStartChar + '\\-.\\d\\u00B7\\u0300-\\u036F\\u203F-\\u2040'; +const nameRegexp = '[' + nameStartChar + '][' + nameChar + ']*' +const regexName = new RegExp('^' + nameRegexp + '$'); + +const getAllMatches = function(string, regex) { + const matches = []; + let match = regex.exec(string); + while (match) { + const allmatches = []; + allmatches.startIndex = regex.lastIndex - match[0].length; + const len = match.length; + for (let index = 0; index < len; index++) { + allmatches.push(match[index]); + } + matches.push(allmatches); + match = regex.exec(string); + } + return matches; +}; + +const isName = function(string) { + const match = regexName.exec(string); + return !(match === null || typeof match === 'undefined'); +}; + +exports.isExist = function(v) { + return typeof v !== 'undefined'; +}; + +exports.isEmptyObject = function(obj) { + return Object.keys(obj).length === 0; +}; + +/** + * Copy all the properties of a into b. + * @param {*} target + * @param {*} a + */ +exports.merge = function(target, a, arrayMode) { + if (a) { + const keys = Object.keys(a); // will return an array of own properties + const len = keys.length; //don't make it inline + for (let i = 0; i < len; i++) { + if (arrayMode === 'strict') { + target[keys[i]] = [ a[keys[i]] ]; + } else { + target[keys[i]] = a[keys[i]]; + } + } + } +}; +/* exports.merge =function (b,a){ + return Object.assign(b,a); +} */ + +exports.getValue = function(v) { + if (exports.isExist(v)) { + return v; + } else { + return ''; + } +}; + +// const fakeCall = function(a) {return a;}; +// const fakeCallNoReturn = function() {}; + +exports.buildOptions = function(options, defaultOptions, props) { + let newOptions = {}; + if (!options) { + return defaultOptions; //if there are not options + } + + for (let i = 0; i < props.length; i++) { + if (options[props[i]] !== undefined) { + newOptions[props[i]] = options[props[i]]; + } else { + newOptions[props[i]] = defaultOptions[props[i]]; + } + } + return newOptions; +}; + +/** + * Check if a tag name should be treated as array + * + * @param tagName the node tagname + * @param arrayMode the array mode option + * @param parentTagName the parent tag name + * @returns {boolean} true if node should be parsed as array + */ +exports.isTagNameInArrayMode = function (tagName, arrayMode, parentTagName) { + if (arrayMode === false) { + return false; + } else if (arrayMode instanceof RegExp) { + return arrayMode.test(tagName); + } else if (typeof arrayMode === 'function') { + return !!arrayMode(tagName, parentTagName); + } + + return arrayMode === "strict"; +} + +exports.isName = isName; +exports.getAllMatches = getAllMatches; +exports.nameRegexp = nameRegexp; + + +/***/ }), + +/***/ 8501: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + + +const util = __webpack_require__(7849); + +const defaultOptions = { + allowBooleanAttributes: false, //A tag can have attributes without any value +}; + +const props = ['allowBooleanAttributes']; + +//const tagsPattern = new RegExp("<\\/?([\\w:\\-_\.]+)\\s*\/?>","g"); +exports.validate = function (xmlData, options) { + options = util.buildOptions(options, defaultOptions, props); + + //xmlData = xmlData.replace(/(\r\n|\n|\r)/gm,"");//make it single line + //xmlData = xmlData.replace(/(^\s*<\?xml.*?\?>)/g,"");//Remove XML starting tag + //xmlData = xmlData.replace(/()/g,"");//Remove DOCTYPE + const tags = []; + let tagFound = false; + + //indicates that the root tag has been closed (aka. depth 0 has been reached) + let reachedRoot = false; + + if (xmlData[0] === '\ufeff') { + // check for byte order mark (BOM) + xmlData = xmlData.substr(1); + } + + for (let i = 0; i < xmlData.length; i++) { + + if (xmlData[i] === '<' && xmlData[i+1] === '?') { + i+=2; + i = readPI(xmlData,i); + if (i.err) return i; + }else if (xmlData[i] === '<') { + //starting of tag + //read until you reach to '>' avoiding any '>' in attribute value + let tagStartPos = i; + i++; + + if (xmlData[i] === '!') { + i = readCommentAndCDATA(xmlData, i); + continue; + } else { + let closingTag = false; + if (xmlData[i] === '/') { + //closing tag + closingTag = true; + i++; + } + //read tagname + let tagName = ''; + for (; i < xmlData.length && + xmlData[i] !== '>' && + xmlData[i] !== ' ' && + xmlData[i] !== '\t' && + xmlData[i] !== '\n' && + xmlData[i] !== '\r'; i++ + ) { + tagName += xmlData[i]; + } + tagName = tagName.trim(); + //console.log(tagName); + + if (tagName[tagName.length - 1] === '/') { + //self closing tag without attributes + tagName = tagName.substring(0, tagName.length - 1); + //continue; + i--; + } + if (!validateTagName(tagName)) { + let msg; + if (tagName.trim().length === 0) { + msg = "Invalid space after '<'."; + } else { + msg = "Tag '"+tagName+"' is an invalid name."; + } + return getErrorObject('InvalidTag', msg, getLineNumberForPosition(xmlData, i)); + } + + const result = readAttributeStr(xmlData, i); + if (result === false) { + return getErrorObject('InvalidAttr', "Attributes for '"+tagName+"' have open quote.", getLineNumberForPosition(xmlData, i)); + } + let attrStr = result.value; + i = result.index; + + if (attrStr[attrStr.length - 1] === '/') { + //self closing tag + const attrStrStart = i - attrStr.length; + attrStr = attrStr.substring(0, attrStr.length - 1); + const isValid = validateAttributeString(attrStr, options); + if (isValid === true) { + tagFound = true; + //continue; //text may presents after self closing tag + } else { + //the result from the nested function returns the position of the error within the attribute + //in order to get the 'true' error line, we need to calculate the position where the attribute begins (i - attrStr.length) and then add the position within the attribute + //this gives us the absolute index in the entire xml, which we can use to find the line at last + return getErrorObject(isValid.err.code, isValid.err.msg, getLineNumberForPosition(xmlData, attrStrStart + isValid.err.line)); + } + } else if (closingTag) { + if (!result.tagClosed) { + return getErrorObject('InvalidTag', "Closing tag '"+tagName+"' doesn't have proper closing.", getLineNumberForPosition(xmlData, i)); + } else if (attrStr.trim().length > 0) { + return getErrorObject('InvalidTag', "Closing tag '"+tagName+"' can't have attributes or invalid starting.", getLineNumberForPosition(xmlData, tagStartPos)); + } else { + const otg = tags.pop(); + if (tagName !== otg.tagName) { + let openPos = getLineNumberForPosition(xmlData, otg.tagStartPos); + return getErrorObject('InvalidTag', + "Expected closing tag '"+otg.tagName+"' (opened in line "+openPos.line+", col "+openPos.col+") instead of closing tag '"+tagName+"'.", + getLineNumberForPosition(xmlData, tagStartPos)); + } + + //when there are no more tags, we reached the root level. + if (tags.length == 0) { + reachedRoot = true; + } + } + } else { + const isValid = validateAttributeString(attrStr, options); + if (isValid !== true) { + //the result from the nested function returns the position of the error within the attribute + //in order to get the 'true' error line, we need to calculate the position where the attribute begins (i - attrStr.length) and then add the position within the attribute + //this gives us the absolute index in the entire xml, which we can use to find the line at last + return getErrorObject(isValid.err.code, isValid.err.msg, getLineNumberForPosition(xmlData, i - attrStr.length + isValid.err.line)); + } + + //if the root level has been reached before ... + if (reachedRoot === true) { + return getErrorObject('InvalidXml', 'Multiple possible root nodes found.', getLineNumberForPosition(xmlData, i)); + } else { + tags.push({tagName, tagStartPos}); + } + tagFound = true; + } + + //skip tag text value + //It may include comments and CDATA value + for (i++; i < xmlData.length; i++) { + if (xmlData[i] === '<') { + if (xmlData[i + 1] === '!') { + //comment or CADATA + i++; + i = readCommentAndCDATA(xmlData, i); + continue; + } else if (xmlData[i+1] === '?') { + i = readPI(xmlData, ++i); + if (i.err) return i; + } else{ + break; + } + } else if (xmlData[i] === '&') { + const afterAmp = validateAmpersand(xmlData, i); + if (afterAmp == -1) + return getErrorObject('InvalidChar', "char '&' is not expected.", getLineNumberForPosition(xmlData, i)); + i = afterAmp; + } + } //end of reading tag text value + if (xmlData[i] === '<') { + i--; + } + } + } else { + if (xmlData[i] === ' ' || xmlData[i] === '\t' || xmlData[i] === '\n' || xmlData[i] === '\r') { + continue; + } + return getErrorObject('InvalidChar', "char '"+xmlData[i]+"' is not expected.", getLineNumberForPosition(xmlData, i)); + } + } + + if (!tagFound) { + return getErrorObject('InvalidXml', 'Start tag expected.', 1); + }else if (tags.length == 1) { + return getErrorObject('InvalidTag', "Unclosed tag '"+tags[0].tagName+"'.", getLineNumberForPosition(xmlData, tags[0].tagStartPos)); + }else if (tags.length > 0) { + return getErrorObject('InvalidXml', "Invalid '"+ + JSON.stringify(tags.map(t => t.tagName), null, 4).replace(/\r?\n/g, '')+ + "' found.", {line: 1, col: 1}); + } + + return true; +}; + +/** + * Read Processing insstructions and skip + * @param {*} xmlData + * @param {*} i + */ +function readPI(xmlData, i) { + const start = i; + for (; i < xmlData.length; i++) { + if (xmlData[i] == '?' || xmlData[i] == ' ') { + //tagname + const tagname = xmlData.substr(start, i - start); + if (i > 5 && tagname === 'xml') { + return getErrorObject('InvalidXml', 'XML declaration allowed only at the start of the document.', getLineNumberForPosition(xmlData, i)); + } else if (xmlData[i] == '?' && xmlData[i + 1] == '>') { + //check if valid attribut string + i++; + break; + } else { + continue; + } + } + } + return i; +} + +function readCommentAndCDATA(xmlData, i) { + if (xmlData.length > i + 5 && xmlData[i + 1] === '-' && xmlData[i + 2] === '-') { + //comment + for (i += 3; i < xmlData.length; i++) { + if (xmlData[i] === '-' && xmlData[i + 1] === '-' && xmlData[i + 2] === '>') { + i += 2; + break; + } + } + } else if ( + xmlData.length > i + 8 && + xmlData[i + 1] === 'D' && + xmlData[i + 2] === 'O' && + xmlData[i + 3] === 'C' && + xmlData[i + 4] === 'T' && + xmlData[i + 5] === 'Y' && + xmlData[i + 6] === 'P' && + xmlData[i + 7] === 'E' + ) { + let angleBracketsCount = 1; + for (i += 8; i < xmlData.length; i++) { + if (xmlData[i] === '<') { + angleBracketsCount++; + } else if (xmlData[i] === '>') { + angleBracketsCount--; + if (angleBracketsCount === 0) { + break; + } + } + } + } else if ( + xmlData.length > i + 9 && + xmlData[i + 1] === '[' && + xmlData[i + 2] === 'C' && + xmlData[i + 3] === 'D' && + xmlData[i + 4] === 'A' && + xmlData[i + 5] === 'T' && + xmlData[i + 6] === 'A' && + xmlData[i + 7] === '[' + ) { + for (i += 8; i < xmlData.length; i++) { + if (xmlData[i] === ']' && xmlData[i + 1] === ']' && xmlData[i + 2] === '>') { + i += 2; + break; + } + } + } + + return i; +} + +const doubleQuote = '"'; +const singleQuote = "'"; + +/** + * Keep reading xmlData until '<' is found outside the attribute value. + * @param {string} xmlData + * @param {number} i + */ +function readAttributeStr(xmlData, i) { + let attrStr = ''; + let startChar = ''; + let tagClosed = false; + for (; i < xmlData.length; i++) { + if (xmlData[i] === doubleQuote || xmlData[i] === singleQuote) { + if (startChar === '') { + startChar = xmlData[i]; + } else if (startChar !== xmlData[i]) { + //if vaue is enclosed with double quote then single quotes are allowed inside the value and vice versa + } else { + startChar = ''; + } + } else if (xmlData[i] === '>') { + if (startChar === '') { + tagClosed = true; + break; + } + } + attrStr += xmlData[i]; + } + if (startChar !== '') { + return false; + } + + return { + value: attrStr, + index: i, + tagClosed: tagClosed + }; +} + +/** + * Select all the attributes whether valid or invalid. + */ +const validAttrStrRegxp = new RegExp('(\\s*)([^\\s=]+)(\\s*=)?(\\s*([\'"])(([\\s\\S])*?)\\5)?', 'g'); + +//attr, ="sd", a="amit's", a="sd"b="saf", ab cd="" + +function validateAttributeString(attrStr, options) { + //console.log("start:"+attrStr+":end"); + + //if(attrStr.trim().length === 0) return true; //empty string + + const matches = util.getAllMatches(attrStr, validAttrStrRegxp); + const attrNames = {}; + + for (let i = 0; i < matches.length; i++) { + if (matches[i][1].length === 0) { + //nospace before attribute name: a="sd"b="saf" + return getErrorObject('InvalidAttr', "Attribute '"+matches[i][2]+"' has no space in starting.", getPositionFromMatch(matches[i])) + } else if (matches[i][3] === undefined && !options.allowBooleanAttributes) { + //independent attribute: ab + return getErrorObject('InvalidAttr', "boolean attribute '"+matches[i][2]+"' is not allowed.", getPositionFromMatch(matches[i])); + } + /* else if(matches[i][6] === undefined){//attribute without value: ab= + return { err: { code:"InvalidAttr",msg:"attribute " + matches[i][2] + " has no value assigned."}}; + } */ + const attrName = matches[i][2]; + if (!validateAttrName(attrName)) { + return getErrorObject('InvalidAttr', "Attribute '"+attrName+"' is an invalid name.", getPositionFromMatch(matches[i])); + } + if (!attrNames.hasOwnProperty(attrName)) { + //check for duplicate attribute. + attrNames[attrName] = 1; + } else { + return getErrorObject('InvalidAttr', "Attribute '"+attrName+"' is repeated.", getPositionFromMatch(matches[i])); + } + } + + return true; +} + +function validateNumberAmpersand(xmlData, i) { + let re = /\d/; + if (xmlData[i] === 'x') { + i++; + re = /[\da-fA-F]/; + } + for (; i < xmlData.length; i++) { + if (xmlData[i] === ';') + return i; + if (!xmlData[i].match(re)) + break; + } + return -1; +} + +function validateAmpersand(xmlData, i) { + // https://www.w3.org/TR/xml/#dt-charref + i++; + if (xmlData[i] === ';') + return -1; + if (xmlData[i] === '#') { + i++; + return validateNumberAmpersand(xmlData, i); + } + let count = 0; + for (; i < xmlData.length; i++, count++) { + if (xmlData[i].match(/\w/) && count < 20) + continue; + if (xmlData[i] === ';') + break; + return -1; + } + return i; +} + +function getErrorObject(code, message, lineNumber) { + return { + err: { + code: code, + msg: message, + line: lineNumber.line || lineNumber, + col: lineNumber.col, + }, + }; +} + +function validateAttrName(attrName) { + return util.isName(attrName); +} + +// const startsWithXML = /^xml/i; + +function validateTagName(tagname) { + return util.isName(tagname) /* && !tagname.match(startsWithXML) */; +} + +//this function returns the line number for the character at the given index +function getLineNumberForPosition(xmlData, index) { + const lines = xmlData.substring(0, index).split(/\r?\n/); + return { + line: lines.length, + + // column number is last line's length + 1, because column numbering starts at 1: + col: lines[lines.length - 1].length + 1 + }; +} + +//this function returns the position of the first character of match within attrStr +function getPositionFromMatch(match) { + return match.startIndex + match[1].length; +} + + +/***/ }), + +/***/ 6468: +/***/ ((module) => { + +"use strict"; + + +module.exports = function(tagname, parent, val) { + this.tagname = tagname; + this.parent = parent; + this.child = {}; //child tags + this.attrsMap = {}; //attributes map + this.val = val; //text only + this.addChild = function(child) { + if (Array.isArray(this.child[child.tagname])) { + //already presents + this.child[child.tagname].push(child); + } else { + this.child[child.tagname] = [child]; + } + }; +}; + + +/***/ }), + +/***/ 3543: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + + +const util = __webpack_require__(7849); +const buildOptions = (__webpack_require__(7849).buildOptions); +const xmlNode = __webpack_require__(6468); +const toNumber = __webpack_require__(4153); + +const regx = + '<((!\\[CDATA\\[([\\s\\S]*?)(]]>))|((NAME:)?(NAME))([^>]*)>|((\\/)(NAME)\\s*>))([^<]*)' + .replace(/NAME/g, util.nameRegexp); + +//const tagsRegx = new RegExp("<(\\/?[\\w:\\-\._]+)([^>]*)>(\\s*"+cdataRegx+")*([^<]+)?","g"); +//const tagsRegx = new RegExp("<(\\/?)((\\w*:)?([\\w:\\-\._]+))([^>]*)>([^<]*)("+cdataRegx+"([^<]*))*([^<]+)?","g"); + +//polyfill +if (!Number.parseInt && window.parseInt) { + Number.parseInt = window.parseInt; +} +if (!Number.parseFloat && window.parseFloat) { + Number.parseFloat = window.parseFloat; +} + +const defaultOptions = { + attributeNamePrefix: '@_', + attrNodeName: false, + textNodeName: '#text', + ignoreAttributes: true, + ignoreNameSpace: false, + allowBooleanAttributes: false, //a tag can have attributes without any value + //ignoreRootElement : false, + parseNodeValue: true, + parseAttributeValue: false, + arrayMode: false, + trimValues: true, //Trim string values of tag and attributes + cdataTagName: false, + cdataPositionChar: '\\c', + numParseOptions: { + hex: true, + leadingZeros: true + }, + tagValueProcessor: function(a, tagName) { + return a; + }, + attrValueProcessor: function(a, attrName) { + return a; + }, + stopNodes: [], + alwaysCreateTextNode: false + //decodeStrict: false, +}; + +exports.defaultOptions = defaultOptions; + +const props = [ + 'attributeNamePrefix', + 'attrNodeName', + 'textNodeName', + 'ignoreAttributes', + 'ignoreNameSpace', + 'allowBooleanAttributes', + 'parseNodeValue', + 'parseAttributeValue', + 'arrayMode', + 'trimValues', + 'cdataTagName', + 'cdataPositionChar', + 'tagValueProcessor', + 'attrValueProcessor', + 'parseTrueNumberOnly', + 'numParseOptions', + 'stopNodes', + 'alwaysCreateTextNode' +]; +exports.props = props; + +/** + * Trim -> valueProcessor -> parse value + * @param {string} tagName + * @param {string} val + * @param {object} options + */ +function processTagValue(tagName, val, options) { + if (val) { + if (options.trimValues) { + val = val.trim(); + } + val = options.tagValueProcessor(val, tagName); + val = parseValue(val, options.parseNodeValue, options.numParseOptions); + } + + return val; +} + +function resolveNameSpace(tagname, options) { + if (options.ignoreNameSpace) { + const tags = tagname.split(':'); + const prefix = tagname.charAt(0) === '/' ? '/' : ''; + if (tags[0] === 'xmlns') { + return ''; + } + if (tags.length === 2) { + tagname = prefix + tags[1]; + } + } + return tagname; +} + +function parseValue(val, shouldParse, options) { + if (shouldParse && typeof val === 'string') { + //console.log(options) + const newval = val.trim(); + if(newval === 'true' ) return true; + else if(newval === 'false' ) return false; + else return toNumber(val, options); + } else { + if (util.isExist(val)) { + return val; + } else { + return ''; + } + } +} + +//TODO: change regex to capture NS +//const attrsRegx = new RegExp("([\\w\\-\\.\\:]+)\\s*=\\s*(['\"])((.|\n)*?)\\2","gm"); +const attrsRegx = new RegExp('([^\\s=]+)\\s*(=\\s*([\'"])(.*?)\\3)?', 'g'); + +function buildAttributesMap(attrStr, options) { + if (!options.ignoreAttributes && typeof attrStr === 'string') { + attrStr = attrStr.replace(/\r?\n/g, ' '); + //attrStr = attrStr || attrStr.trim(); + + const matches = util.getAllMatches(attrStr, attrsRegx); + const len = matches.length; //don't make it inline + const attrs = {}; + for (let i = 0; i < len; i++) { + const attrName = resolveNameSpace(matches[i][1], options); + if (attrName.length) { + if (matches[i][4] !== undefined) { + if (options.trimValues) { + matches[i][4] = matches[i][4].trim(); + } + matches[i][4] = options.attrValueProcessor(matches[i][4], attrName); + attrs[options.attributeNamePrefix + attrName] = parseValue( + matches[i][4], + options.parseAttributeValue, + options.numParseOptions + ); + } else if (options.allowBooleanAttributes) { + attrs[options.attributeNamePrefix + attrName] = true; + } + } + } + if (!Object.keys(attrs).length) { + return; + } + if (options.attrNodeName) { + const attrCollection = {}; + attrCollection[options.attrNodeName] = attrs; + return attrCollection; + } + return attrs; + } +} + +const getTraversalObj = function(xmlData, options) { + xmlData = xmlData.replace(/\r\n?/g, "\n"); + options = buildOptions(options, defaultOptions, props); + const xmlObj = new xmlNode('!xml'); + let currentNode = xmlObj; + let textData = ""; + +//function match(xmlData){ + for(let i=0; i< xmlData.length; i++){ + const ch = xmlData[i]; + if(ch === '<'){ + if( xmlData[i+1] === '/') {//Closing Tag + const closeIndex = findClosingIndex(xmlData, ">", i, "Closing Tag is not closed.") + let tagName = xmlData.substring(i+2,closeIndex).trim(); + + if(options.ignoreNameSpace){ + const colonIndex = tagName.indexOf(":"); + if(colonIndex !== -1){ + tagName = tagName.substr(colonIndex+1); + } + } + + /* if (currentNode.parent) { + currentNode.parent.val = util.getValue(currentNode.parent.val) + '' + processTagValue2(tagName, textData , options); + } */ + if(currentNode){ + if(currentNode.val){ + currentNode.val = util.getValue(currentNode.val) + '' + processTagValue(tagName, textData , options); + }else{ + currentNode.val = processTagValue(tagName, textData , options); + } + } + + if (options.stopNodes.length && options.stopNodes.includes(currentNode.tagname)) { + currentNode.child = [] + if (currentNode.attrsMap == undefined) { currentNode.attrsMap = {}} + currentNode.val = xmlData.substr(currentNode.startIndex + 1, i - currentNode.startIndex - 1) + } + currentNode = currentNode.parent; + textData = ""; + i = closeIndex; + } else if( xmlData[i+1] === '?') { + i = findClosingIndex(xmlData, "?>", i, "Pi Tag is not closed.") + } else if(xmlData.substr(i + 1, 3) === '!--') { + i = findClosingIndex(xmlData, "-->", i, "Comment is not closed.") + } else if( xmlData.substr(i + 1, 2) === '!D') { + const closeIndex = findClosingIndex(xmlData, ">", i, "DOCTYPE is not closed.") + const tagExp = xmlData.substring(i, closeIndex); + if(tagExp.indexOf("[") >= 0){ + i = xmlData.indexOf("]>", i) + 1; + }else{ + i = closeIndex; + } + }else if(xmlData.substr(i + 1, 2) === '![') { + const closeIndex = findClosingIndex(xmlData, "]]>", i, "CDATA is not closed.") - 2 + const tagExp = xmlData.substring(i + 9,closeIndex); + + //considerations + //1. CDATA will always have parent node + //2. A tag with CDATA is not a leaf node so it's value would be string type. + if(textData){ + currentNode.val = util.getValue(currentNode.val) + '' + processTagValue(currentNode.tagname, textData , options); + textData = ""; + } + + if (options.cdataTagName) { + //add cdata node + const childNode = new xmlNode(options.cdataTagName, currentNode, tagExp); + currentNode.addChild(childNode); + //for backtracking + currentNode.val = util.getValue(currentNode.val) + options.cdataPositionChar; + //add rest value to parent node + if (tagExp) { + childNode.val = tagExp; + } + } else { + currentNode.val = (currentNode.val || '') + (tagExp || ''); + } + + i = closeIndex + 2; + }else {//Opening tag + const result = closingIndexForOpeningTag(xmlData, i+1) + let tagExp = result.data; + const closeIndex = result.index; + const separatorIndex = tagExp.indexOf(" "); + let tagName = tagExp; + let shouldBuildAttributesMap = true; + if(separatorIndex !== -1){ + tagName = tagExp.substr(0, separatorIndex).replace(/\s\s*$/, ''); + tagExp = tagExp.substr(separatorIndex + 1); + } + + if(options.ignoreNameSpace){ + const colonIndex = tagName.indexOf(":"); + if(colonIndex !== -1){ + tagName = tagName.substr(colonIndex+1); + shouldBuildAttributesMap = tagName !== result.data.substr(colonIndex + 1); + } + } + + //save text to parent node + if (currentNode && textData) { + if(currentNode.tagname !== '!xml'){ + currentNode.val = util.getValue(currentNode.val) + '' + processTagValue( currentNode.tagname, textData, options); + } + } + + if(tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1){//selfClosing tag + + if(tagName[tagName.length - 1] === "/"){ //remove trailing '/' + tagName = tagName.substr(0, tagName.length - 1); + tagExp = tagName; + }else{ + tagExp = tagExp.substr(0, tagExp.length - 1); + } + + const childNode = new xmlNode(tagName, currentNode, ''); + if(tagName !== tagExp){ + childNode.attrsMap = buildAttributesMap(tagExp, options); + } + currentNode.addChild(childNode); + }else{//opening tag + + const childNode = new xmlNode( tagName, currentNode ); + if (options.stopNodes.length && options.stopNodes.includes(childNode.tagname)) { + childNode.startIndex=closeIndex; + } + if(tagName !== tagExp && shouldBuildAttributesMap){ + childNode.attrsMap = buildAttributesMap(tagExp, options); + } + currentNode.addChild(childNode); + currentNode = childNode; + } + textData = ""; + i = closeIndex; + } + }else{ + textData += xmlData[i]; + } + } + return xmlObj; +} + +function closingIndexForOpeningTag(data, i){ + let attrBoundary; + let tagExp = ""; + for (let index = i; index < data.length; index++) { + let ch = data[index]; + if (attrBoundary) { + if (ch === attrBoundary) attrBoundary = "";//reset + } else if (ch === '"' || ch === "'") { + attrBoundary = ch; + } else if (ch === '>') { + return { + data: tagExp, + index: index + } + } else if (ch === '\t') { + ch = " " + } + tagExp += ch; + } +} + +function findClosingIndex(xmlData, str, i, errMsg){ + const closingIndex = xmlData.indexOf(str, i); + if(closingIndex === -1){ + throw new Error(errMsg) + }else{ + return closingIndex + str.length - 1; + } +} + +exports.getTraversalObj = getTraversalObj; + + +/***/ }), + +/***/ 2475: +/***/ ((module) => { + +"use strict"; + + +var COMPATIBLE_ENCODING_PATTERN = /^utf-?8|ascii|utf-?16-?le|ucs-?2|base-?64|latin-?1$/i +var WS_TRIM_PATTERN = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g +var WS_CHAR_PATTERN = /\s|\uFEFF|\xA0/ +var WS_FOLD_PATTERN = /\r?\n[\x20\x09]+/g +var DELIMITER_PATTERN = /[;,"]/ +var WS_DELIMITER_PATTERN = /[;,"]|\s/ + +/** + * Token character pattern + * @type {RegExp} + * @see https://tools.ietf.org/html/rfc7230#section-3.2.6 + */ +var TOKEN_PATTERN = /^[!#$%&'*+\-\.^_`|~\da-zA-Z]+$/ + +var STATE = { + IDLE: 1 << 0, + URI: 1 << 1, + ATTR: 1 << 2, +} + +function trim( value ) { + return value.replace( WS_TRIM_PATTERN, '' ) +} + +function hasWhitespace( value ) { + return WS_CHAR_PATTERN.test( value ) +} + +function skipWhitespace( value, offset ) { + while( hasWhitespace( value[offset] ) ) { + offset++ + } + return offset +} + +function needsQuotes( value ) { + return WS_DELIMITER_PATTERN.test( value ) || + !TOKEN_PATTERN.test( value ) +} + +/** + * Shallow compares two objects to check if their properties match. + * @param {object} object1 First object to compare. + * @param {object} object2 Second object to compare. + * @returns {boolean} Do the objects have matching properties. + */ +function shallowCompareObjects( object1, object2 ) { + return ( + Object.keys( object1 ).length === Object.keys( object2 ).length && + Object.keys( object1 ).every( + ( key ) => key in object2 && object1[ key ] === object2[ key ] + ) + ); +} + +class Link { + + /** + * Link + * @constructor + * @param {String} [value] + * @returns {Link} + */ + constructor( value ) { + + /** @type {Array} URI references */ + this.refs = [] + + if( value ) { + this.parse( value ) + } + + } + + /** + * Get refs with given relation type + * @param {String} value + * @returns {Array} + */ + rel( value ) { + + var links = [] + var type = value.toLowerCase() + + for( var i = 0; i < this.refs.length; i++ ) { + if( this.refs[ i ].rel.toLowerCase() === type ) { + links.push( this.refs[ i ] ) + } + } + + return links + + } + + /** + * Get refs where given attribute has a given value + * @param {String} attr + * @param {String} value + * @returns {Array} + */ + get( attr, value ) { + + attr = attr.toLowerCase() + + var links = [] + + for( var i = 0; i < this.refs.length; i++ ) { + if( this.refs[ i ][ attr ] === value ) { + links.push( this.refs[ i ] ) + } + } + + return links + + } + + /** Sets a reference. */ + set( link ) { + this.refs.push( link ) + return this + } + + /** + * Sets a reference if a reference with similar properties isn’t already set. + */ + setUnique( link ) { + + if( !this.refs.some(( ref ) => shallowCompareObjects( ref, link )) ) { + this.refs.push( link ) + } + + return this + + } + + has( attr, value ) { + + attr = attr.toLowerCase() + + for( var i = 0; i < this.refs.length; i++ ) { + if( this.refs[ i ][ attr ] === value ) { + return true + } + } + + return false + + } + + parse( value, offset ) { + + offset = offset || 0 + value = offset ? value.slice( offset ) : value + + // Trim & unfold folded lines + value = trim( value ).replace( WS_FOLD_PATTERN, '' ) + + var state = STATE.IDLE + var length = value.length + var offset = 0 + var ref = null + + while( offset < length ) { + if( state === STATE.IDLE ) { + if( hasWhitespace( value[offset] ) ) { + offset++ + continue + } else if( value[offset] === '<' ) { + if( ref != null ) { + ref.rel != null ? + this.refs.push( ...Link.expandRelations( ref ) ) : + this.refs.push( ref ) + } + var end = value.indexOf( '>', offset ) + if( end === -1 ) throw new Error( 'Expected end of URI delimiter at offset ' + offset ) + ref = { uri: value.slice( offset + 1, end ) } + // this.refs.push( ref ) + offset = end + state = STATE.URI + } else { + throw new Error( 'Unexpected character "' + value[offset] + '" at offset ' + offset ) + } + offset++ + } else if( state === STATE.URI ) { + if( hasWhitespace( value[offset] ) ) { + offset++ + continue + } else if( value[offset] === ';' ) { + state = STATE.ATTR + offset++ + } else if( value[offset] === ',' ) { + state = STATE.IDLE + offset++ + } else { + throw new Error( 'Unexpected character "' + value[offset] + '" at offset ' + offset ) + } + } else if( state === STATE.ATTR ) { + if( value[offset] ===';' || hasWhitespace( value[offset] ) ) { + offset++ + continue + } + var end = value.indexOf( '=', offset ) + if( end === -1 ) end = value.indexOf( ';', offset ) + if( end === -1 ) end = value.length + var attr = trim( value.slice( offset, end ) ).toLowerCase() + var attrValue = '' + offset = end + 1 + offset = skipWhitespace( value, offset ) + if( value[offset] === '"' ) { + offset++ + while( offset < length ) { + if( value[offset] === '"' ) { + offset++; break + } + if( value[offset] === '\\' ) { + offset++ + } + attrValue += value[offset] + offset++ + } + } else { + var end = offset + 1 + while( !DELIMITER_PATTERN.test( value[end] ) && end < length ) { + end++ + } + attrValue = value.slice( offset, end ) + offset = end + } + if( ref[ attr ] && Link.isSingleOccurenceAttr( attr ) ) { + // Ignore multiples of attributes which may only appear once + } else if( attr[ attr.length - 1 ] === '*' ) { + ref[ attr ] = Link.parseExtendedValue( attrValue ) + } else { + attrValue = attr === 'type' ? + attrValue.toLowerCase() : attrValue + if( ref[ attr ] != null ) { + if( Array.isArray( ref[ attr ] ) ) { + ref[ attr ].push( attrValue ) + } else { + ref[ attr ] = [ ref[ attr ], attrValue ] + } + } else { + ref[ attr ] = attrValue + } + } + switch( value[offset] ) { + case ',': state = STATE.IDLE; break + case ';': state = STATE.ATTR; break + } + offset++ + } else { + throw new Error( 'Unknown parser state "' + state + '"' ) + } + } + + if( ref != null ) { + ref.rel != null ? + this.refs.push( ...Link.expandRelations( ref ) ) : + this.refs.push( ref ) + } + + ref = null + + return this + + } + + toString() { + + var refs = [] + var link = '' + var ref = null + + for( var i = 0; i < this.refs.length; i++ ) { + ref = this.refs[i] + link = Object.keys( this.refs[i] ).reduce( function( link, attr ) { + if( attr === 'uri' ) return link + return link + '; ' + Link.formatAttribute( attr, ref[ attr ] ) + }, '<' + ref.uri + '>' ) + refs.push( link ) + } + + return refs.join( ', ' ) + + } + +} + +/** + * Determines whether an encoding can be + * natively handled with a `Buffer` + * @param {String} value + * @returns {Boolean} + */ +Link.isCompatibleEncoding = function( value ) { + return COMPATIBLE_ENCODING_PATTERN.test( value ) +} + +Link.parse = function( value, offset ) { + return new Link().parse( value, offset ) +} + +Link.isSingleOccurenceAttr = function( attr ) { + return attr === 'rel' || attr === 'type' || attr === 'media' || + attr === 'title' || attr === 'title*' +} + +Link.isTokenAttr = function( attr ) { + return attr === 'rel' || attr === 'type' || attr === 'anchor' +} + +Link.escapeQuotes = function( value ) { + return value.replace( /"/g, '\\"' ) +} + +Link.expandRelations = function( ref ) { + var rels = ref.rel.split( ' ' ) + return rels.map( function( rel ) { + var value = Object.assign( {}, ref ) + value.rel = rel + return value + }) +} + +/** + * Parses an extended value and attempts to decode it + * @internal + * @param {String} value + * @return {Object} + */ +Link.parseExtendedValue = function( value ) { + var parts = /([^']+)?(?:'([^']*)')?(.+)/.exec( value ) + return { + language: parts[2].toLowerCase(), + encoding: Link.isCompatibleEncoding( parts[1] ) ? + null : parts[1].toLowerCase(), + value: Link.isCompatibleEncoding( parts[1] ) ? + decodeURIComponent( parts[3] ) : parts[3] + } +} + +/** + * Format a given extended attribute and it's value + * @param {String} attr + * @param {Object} data + * @return {String} + */ +Link.formatExtendedAttribute = function( attr, data ) { + + var encoding = ( data.encoding || 'utf-8' ).toUpperCase() + var language = data.language || 'en' + + var encodedValue = '' + + if( Buffer.isBuffer( data.value ) && Link.isCompatibleEncoding( encoding ) ) { + encodedValue = data.value.toString( encoding ) + } else if( Buffer.isBuffer( data.value ) ) { + encodedValue = data.value.toString( 'hex' ) + .replace( /[0-9a-f]{2}/gi, '%$1' ) + } else { + encodedValue = encodeURIComponent( data.value ) + } + + return attr + '=' + encoding + '\'' + + language + '\'' + encodedValue + +} + +/** + * Format a given attribute and it's value + * @param {String} attr + * @param {String|Object} value + * @return {String} + */ +Link.formatAttribute = function( attr, value ) { + + if( Array.isArray( value ) ) { + return value.map(( item ) => { + return Link.formatAttribute( attr, item ) + }).join( '; ' ) + } + + if( attr[ attr.length - 1 ] === '*' || typeof value !== 'string' ) { + return Link.formatExtendedAttribute( attr, value ) + } + + if( Link.isTokenAttr( attr ) ) { + value = needsQuotes( value ) ? + '"' + Link.escapeQuotes( value ) + '"' : + Link.escapeQuotes( value ) + } else if( needsQuotes( value ) ) { + value = encodeURIComponent( value ) + // We don't need to escape <,> <;> within quotes + value = value + .replace( /%20/g, ' ' ) + .replace( /%2C/g, ',' ) + .replace( /%3B/g, ';' ) + + value = '"' + value + '"' + } + + return attr + '=' + value + +} + +module.exports = Link + + +/***/ }), + +/***/ 645: +/***/ ((__unused_webpack_module, exports) => { + +/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh */ +exports.read = function (buffer, offset, isLE, mLen, nBytes) { + var e, m + var eLen = (nBytes * 8) - mLen - 1 + var eMax = (1 << eLen) - 1 + var eBias = eMax >> 1 + var nBits = -7 + var i = isLE ? (nBytes - 1) : 0 + var d = isLE ? -1 : 1 + var s = buffer[offset + i] + + i += d + + e = s & ((1 << (-nBits)) - 1) + s >>= (-nBits) + nBits += eLen + for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {} + + m = e & ((1 << (-nBits)) - 1) + e >>= (-nBits) + nBits += mLen + for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {} + + if (e === 0) { + e = 1 - eBias + } else if (e === eMax) { + return m ? NaN : ((s ? -1 : 1) * Infinity) + } else { + m = m + Math.pow(2, mLen) + e = e - eBias + } + return (s ? -1 : 1) * m * Math.pow(2, e - mLen) +} + +exports.write = function (buffer, value, offset, isLE, mLen, nBytes) { + var e, m, c + var eLen = (nBytes * 8) - mLen - 1 + var eMax = (1 << eLen) - 1 + var eBias = eMax >> 1 + var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0) + var i = isLE ? 0 : (nBytes - 1) + var d = isLE ? 1 : -1 + var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0 + + value = Math.abs(value) + + if (isNaN(value) || value === Infinity) { + m = isNaN(value) ? 1 : 0 + e = eMax + } else { + e = Math.floor(Math.log(value) / Math.LN2) + if (value * (c = Math.pow(2, -e)) < 1) { + e-- + c *= 2 + } + if (e + eBias >= 1) { + value += rt / c + } else { + value += rt * Math.pow(2, 1 - eBias) + } + if (value * c >= 2) { + e++ + c /= 2 + } + + if (e + eBias >= eMax) { + m = 0 + e = eMax + } else if (e + eBias >= 1) { + m = ((value * c) - 1) * Math.pow(2, mLen) + e = e + eBias + } else { + m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen) + e = 0 + } + } + + for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {} + + e = (e << mLen) | m + eLen += mLen + for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {} + + buffer[offset + i - d] |= s * 128 +} + + +/***/ }), + +/***/ 5717: +/***/ ((module) => { + +if (typeof Object.create === 'function') { + // implementation from standard node.js 'util' module + module.exports = function inherits(ctor, superCtor) { + if (superCtor) { + ctor.super_ = superCtor + ctor.prototype = Object.create(superCtor.prototype, { + constructor: { + value: ctor, + enumerable: false, + writable: true, + configurable: true + } + }) + } + }; +} else { + // old school shim for old browsers + module.exports = function inherits(ctor, superCtor) { + if (superCtor) { + ctor.super_ = superCtor + var TempCtor = function () {} + TempCtor.prototype = superCtor.prototype + ctor.prototype = new TempCtor() + ctor.prototype.constructor = ctor + } + } +} + + +/***/ }), + +/***/ 6512: +/***/ (function(module) { + +(function (root) { + 'use strict'; + // A list of regular expressions that match arbitrary IPv4 addresses, + // for which a number of weird notations exist. + // Note that an address like 0010.0xa5.1.1 is considered legal. + const ipv4Part = '(0?\\d+|0x[a-f0-9]+)'; + const ipv4Regexes = { + fourOctet: new RegExp(`^${ipv4Part}\\.${ipv4Part}\\.${ipv4Part}\\.${ipv4Part}$`, 'i'), + threeOctet: new RegExp(`^${ipv4Part}\\.${ipv4Part}\\.${ipv4Part}$`, 'i'), + twoOctet: new RegExp(`^${ipv4Part}\\.${ipv4Part}$`, 'i'), + longValue: new RegExp(`^${ipv4Part}$`, 'i') + }; + + // Regular Expression for checking Octal numbers + const octalRegex = new RegExp(`^0[0-7]+$`, 'i'); + const hexRegex = new RegExp(`^0x[a-f0-9]+$`, 'i'); + + const zoneIndex = '%[0-9a-z]{1,}'; + + // IPv6-matching regular expressions. + // For IPv6, the task is simpler: it is enough to match the colon-delimited + // hexadecimal IPv6 and a transitional variant with dotted-decimal IPv4 at + // the end. + const ipv6Part = '(?:[0-9a-f]+::?)+'; + const ipv6Regexes = { + zoneIndex: new RegExp(zoneIndex, 'i'), + 'native': new RegExp(`^(::)?(${ipv6Part})?([0-9a-f]+)?(::)?(${zoneIndex})?$`, 'i'), + deprecatedTransitional: new RegExp(`^(?:::)(${ipv4Part}\\.${ipv4Part}\\.${ipv4Part}\\.${ipv4Part}(${zoneIndex})?)$`, 'i'), + transitional: new RegExp(`^((?:${ipv6Part})|(?:::)(?:${ipv6Part})?)${ipv4Part}\\.${ipv4Part}\\.${ipv4Part}\\.${ipv4Part}(${zoneIndex})?$`, 'i') + }; + + // Expand :: in an IPv6 address or address part consisting of `parts` groups. + function expandIPv6 (string, parts) { + // More than one '::' means invalid adddress + if (string.indexOf('::') !== string.lastIndexOf('::')) { + return null; + } + + let colonCount = 0; + let lastColon = -1; + let zoneId = (string.match(ipv6Regexes.zoneIndex) || [])[0]; + let replacement, replacementCount; + + // Remove zone index and save it for later + if (zoneId) { + zoneId = zoneId.substring(1); + string = string.replace(/%.+$/, ''); + } + + // How many parts do we already have? + while ((lastColon = string.indexOf(':', lastColon + 1)) >= 0) { + colonCount++; + } + + // 0::0 is two parts more than :: + if (string.substr(0, 2) === '::') { + colonCount--; + } + + if (string.substr(-2, 2) === '::') { + colonCount--; + } + + // The following loop would hang if colonCount > parts + if (colonCount > parts) { + return null; + } + + // replacement = ':' + '0:' * (parts - colonCount) + replacementCount = parts - colonCount; + replacement = ':'; + while (replacementCount--) { + replacement += '0:'; + } + + // Insert the missing zeroes + string = string.replace('::', replacement); + + // Trim any garbage which may be hanging around if :: was at the edge in + // the source strin + if (string[0] === ':') { + string = string.slice(1); + } + + if (string[string.length - 1] === ':') { + string = string.slice(0, -1); + } + + parts = (function () { + const ref = string.split(':'); + const results = []; + + for (let i = 0; i < ref.length; i++) { + results.push(parseInt(ref[i], 16)); + } + + return results; + })(); + + return { + parts: parts, + zoneId: zoneId + }; + } + + // A generic CIDR (Classless Inter-Domain Routing) RFC1518 range matcher. + function matchCIDR (first, second, partSize, cidrBits) { + if (first.length !== second.length) { + throw new Error('ipaddr: cannot match CIDR for objects with different lengths'); + } + + let part = 0; + let shift; + + while (cidrBits > 0) { + shift = partSize - cidrBits; + if (shift < 0) { + shift = 0; + } + + if (first[part] >> shift !== second[part] >> shift) { + return false; + } + + cidrBits -= partSize; + part += 1; + } + + return true; + } + + function parseIntAuto (string) { + // Hexadedimal base 16 (0x#) + if (hexRegex.test(string)) { + return parseInt(string, 16); + } + // While octal representation is discouraged by ECMAScript 3 + // and forbidden by ECMAScript 5, we silently allow it to + // work only if the rest of the string has numbers less than 8. + if (string[0] === '0' && !isNaN(parseInt(string[1], 10))) { + if (octalRegex.test(string)) { + return parseInt(string, 8); + } + throw new Error(`ipaddr: cannot parse ${string} as octal`); + } + // Always include the base 10 radix! + return parseInt(string, 10); + } + + function padPart (part, length) { + while (part.length < length) { + part = `0${part}`; + } + + return part; + } + + const ipaddr = {}; + + // An IPv4 address (RFC791). + ipaddr.IPv4 = (function () { + // Constructs a new IPv4 address from an array of four octets + // in network order (MSB first) + // Verifies the input. + function IPv4 (octets) { + if (octets.length !== 4) { + throw new Error('ipaddr: ipv4 octet count should be 4'); + } + + let i, octet; + + for (i = 0; i < octets.length; i++) { + octet = octets[i]; + if (!((0 <= octet && octet <= 255))) { + throw new Error('ipaddr: ipv4 octet should fit in 8 bits'); + } + } + + this.octets = octets; + } + + // Special IPv4 address ranges. + // See also https://en.wikipedia.org/wiki/Reserved_IP_addresses + IPv4.prototype.SpecialRanges = { + unspecified: [[new IPv4([0, 0, 0, 0]), 8]], + broadcast: [[new IPv4([255, 255, 255, 255]), 32]], + // RFC3171 + multicast: [[new IPv4([224, 0, 0, 0]), 4]], + // RFC3927 + linkLocal: [[new IPv4([169, 254, 0, 0]), 16]], + // RFC5735 + loopback: [[new IPv4([127, 0, 0, 0]), 8]], + // RFC6598 + carrierGradeNat: [[new IPv4([100, 64, 0, 0]), 10]], + // RFC1918 + 'private': [ + [new IPv4([10, 0, 0, 0]), 8], + [new IPv4([172, 16, 0, 0]), 12], + [new IPv4([192, 168, 0, 0]), 16] + ], + // Reserved and testing-only ranges; RFCs 5735, 5737, 2544, 1700 + reserved: [ + [new IPv4([192, 0, 0, 0]), 24], + [new IPv4([192, 0, 2, 0]), 24], + [new IPv4([192, 88, 99, 0]), 24], + [new IPv4([198, 51, 100, 0]), 24], + [new IPv4([203, 0, 113, 0]), 24], + [new IPv4([240, 0, 0, 0]), 4] + ] + }; + + // The 'kind' method exists on both IPv4 and IPv6 classes. + IPv4.prototype.kind = function () { + return 'ipv4'; + }; + + // Checks if this address matches other one within given CIDR range. + IPv4.prototype.match = function (other, cidrRange) { + let ref; + if (cidrRange === undefined) { + ref = other; + other = ref[0]; + cidrRange = ref[1]; + } + + if (other.kind() !== 'ipv4') { + throw new Error('ipaddr: cannot match ipv4 address with non-ipv4 one'); + } + + return matchCIDR(this.octets, other.octets, 8, cidrRange); + }; + + // returns a number of leading ones in IPv4 address, making sure that + // the rest is a solid sequence of 0's (valid netmask) + // returns either the CIDR length or null if mask is not valid + IPv4.prototype.prefixLengthFromSubnetMask = function () { + let cidr = 0; + // non-zero encountered stop scanning for zeroes + let stop = false; + // number of zeroes in octet + const zerotable = { + 0: 8, + 128: 7, + 192: 6, + 224: 5, + 240: 4, + 248: 3, + 252: 2, + 254: 1, + 255: 0 + }; + let i, octet, zeros; + + for (i = 3; i >= 0; i -= 1) { + octet = this.octets[i]; + if (octet in zerotable) { + zeros = zerotable[octet]; + if (stop && zeros !== 0) { + return null; + } + + if (zeros !== 8) { + stop = true; + } + + cidr += zeros; + } else { + return null; + } + } + + return 32 - cidr; + }; + + // Checks if the address corresponds to one of the special ranges. + IPv4.prototype.range = function () { + return ipaddr.subnetMatch(this, this.SpecialRanges); + }; + + // Returns an array of byte-sized values in network order (MSB first) + IPv4.prototype.toByteArray = function () { + return this.octets.slice(0); + }; + + // Converts this IPv4 address to an IPv4-mapped IPv6 address. + IPv4.prototype.toIPv4MappedAddress = function () { + return ipaddr.IPv6.parse(`::ffff:${this.toString()}`); + }; + + // Symmetrical method strictly for aligning with the IPv6 methods. + IPv4.prototype.toNormalizedString = function () { + return this.toString(); + }; + + // Returns the address in convenient, decimal-dotted format. + IPv4.prototype.toString = function () { + return this.octets.join('.'); + }; + + return IPv4; + })(); + + // A utility function to return broadcast address given the IPv4 interface and prefix length in CIDR notation + ipaddr.IPv4.broadcastAddressFromCIDR = function (string) { + + try { + const cidr = this.parseCIDR(string); + const ipInterfaceOctets = cidr[0].toByteArray(); + const subnetMaskOctets = this.subnetMaskFromPrefixLength(cidr[1]).toByteArray(); + const octets = []; + let i = 0; + while (i < 4) { + // Broadcast address is bitwise OR between ip interface and inverted mask + octets.push(parseInt(ipInterfaceOctets[i], 10) | parseInt(subnetMaskOctets[i], 10) ^ 255); + i++; + } + + return new this(octets); + } catch (e) { + throw new Error('ipaddr: the address does not have IPv4 CIDR format'); + } + }; + + // Checks if a given string is formatted like IPv4 address. + ipaddr.IPv4.isIPv4 = function (string) { + return this.parser(string) !== null; + }; + + // Checks if a given string is a valid IPv4 address. + ipaddr.IPv4.isValid = function (string) { + try { + new this(this.parser(string)); + return true; + } catch (e) { + return false; + } + }; + + // Checks if a given string is a full four-part IPv4 Address. + ipaddr.IPv4.isValidFourPartDecimal = function (string) { + if (ipaddr.IPv4.isValid(string) && string.match(/^(0|[1-9]\d*)(\.(0|[1-9]\d*)){3}$/)) { + return true; + } else { + return false; + } + }; + + // A utility function to return network address given the IPv4 interface and prefix length in CIDR notation + ipaddr.IPv4.networkAddressFromCIDR = function (string) { + let cidr, i, ipInterfaceOctets, octets, subnetMaskOctets; + + try { + cidr = this.parseCIDR(string); + ipInterfaceOctets = cidr[0].toByteArray(); + subnetMaskOctets = this.subnetMaskFromPrefixLength(cidr[1]).toByteArray(); + octets = []; + i = 0; + while (i < 4) { + // Network address is bitwise AND between ip interface and mask + octets.push(parseInt(ipInterfaceOctets[i], 10) & parseInt(subnetMaskOctets[i], 10)); + i++; + } + + return new this(octets); + } catch (e) { + throw new Error('ipaddr: the address does not have IPv4 CIDR format'); + } + }; + + // Tries to parse and validate a string with IPv4 address. + // Throws an error if it fails. + ipaddr.IPv4.parse = function (string) { + const parts = this.parser(string); + + if (parts === null) { + throw new Error('ipaddr: string is not formatted like an IPv4 Address'); + } + + return new this(parts); + }; + + // Parses the string as an IPv4 Address with CIDR Notation. + ipaddr.IPv4.parseCIDR = function (string) { + let match; + + if ((match = string.match(/^(.+)\/(\d+)$/))) { + const maskLength = parseInt(match[2]); + if (maskLength >= 0 && maskLength <= 32) { + const parsed = [this.parse(match[1]), maskLength]; + Object.defineProperty(parsed, 'toString', { + value: function () { + return this.join('/'); + } + }); + return parsed; + } + } + + throw new Error('ipaddr: string is not formatted like an IPv4 CIDR range'); + }; + + // Classful variants (like a.b, where a is an octet, and b is a 24-bit + // value representing last three octets; this corresponds to a class C + // address) are omitted due to classless nature of modern Internet. + ipaddr.IPv4.parser = function (string) { + let match, part, value; + + // parseInt recognizes all that octal & hexadecimal weirdness for us + if ((match = string.match(ipv4Regexes.fourOctet))) { + return (function () { + const ref = match.slice(1, 6); + const results = []; + + for (let i = 0; i < ref.length; i++) { + part = ref[i]; + results.push(parseIntAuto(part)); + } + + return results; + })(); + } else if ((match = string.match(ipv4Regexes.longValue))) { + value = parseIntAuto(match[1]); + if (value > 0xffffffff || value < 0) { + throw new Error('ipaddr: address outside defined range'); + } + + return ((function () { + const results = []; + let shift; + + for (shift = 0; shift <= 24; shift += 8) { + results.push((value >> shift) & 0xff); + } + + return results; + })()).reverse(); + } else if ((match = string.match(ipv4Regexes.twoOctet))) { + return (function () { + const ref = match.slice(1, 4); + const results = []; + + value = parseIntAuto(ref[1]); + if (value > 0xffffff || value < 0) { + throw new Error('ipaddr: address outside defined range'); + } + + results.push(parseIntAuto(ref[0])); + results.push((value >> 16) & 0xff); + results.push((value >> 8) & 0xff); + results.push( value & 0xff); + + return results; + })(); + } else if ((match = string.match(ipv4Regexes.threeOctet))) { + return (function () { + const ref = match.slice(1, 5); + const results = []; + + value = parseIntAuto(ref[2]); + if (value > 0xffff || value < 0) { + throw new Error('ipaddr: address outside defined range'); + } + + results.push(parseIntAuto(ref[0])); + results.push(parseIntAuto(ref[1])); + results.push((value >> 8) & 0xff); + results.push( value & 0xff); + + return results; + })(); + } else { + return null; + } + }; + + // A utility function to return subnet mask in IPv4 format given the prefix length + ipaddr.IPv4.subnetMaskFromPrefixLength = function (prefix) { + prefix = parseInt(prefix); + if (prefix < 0 || prefix > 32) { + throw new Error('ipaddr: invalid IPv4 prefix length'); + } + + const octets = [0, 0, 0, 0]; + let j = 0; + const filledOctetCount = Math.floor(prefix / 8); + + while (j < filledOctetCount) { + octets[j] = 255; + j++; + } + + if (filledOctetCount < 4) { + octets[filledOctetCount] = Math.pow(2, prefix % 8) - 1 << 8 - (prefix % 8); + } + + return new this(octets); + }; + + // An IPv6 address (RFC2460) + ipaddr.IPv6 = (function () { + // Constructs an IPv6 address from an array of eight 16 - bit parts + // or sixteen 8 - bit parts in network order(MSB first). + // Throws an error if the input is invalid. + function IPv6 (parts, zoneId) { + let i, part; + + if (parts.length === 16) { + this.parts = []; + for (i = 0; i <= 14; i += 2) { + this.parts.push((parts[i] << 8) | parts[i + 1]); + } + } else if (parts.length === 8) { + this.parts = parts; + } else { + throw new Error('ipaddr: ipv6 part count should be 8 or 16'); + } + + for (i = 0; i < this.parts.length; i++) { + part = this.parts[i]; + if (!((0 <= part && part <= 0xffff))) { + throw new Error('ipaddr: ipv6 part should fit in 16 bits'); + } + } + + if (zoneId) { + this.zoneId = zoneId; + } + } + + // Special IPv6 ranges + IPv6.prototype.SpecialRanges = { + // RFC4291, here and after + unspecified: [new IPv6([0, 0, 0, 0, 0, 0, 0, 0]), 128], + linkLocal: [new IPv6([0xfe80, 0, 0, 0, 0, 0, 0, 0]), 10], + multicast: [new IPv6([0xff00, 0, 0, 0, 0, 0, 0, 0]), 8], + loopback: [new IPv6([0, 0, 0, 0, 0, 0, 0, 1]), 128], + uniqueLocal: [new IPv6([0xfc00, 0, 0, 0, 0, 0, 0, 0]), 7], + ipv4Mapped: [new IPv6([0, 0, 0, 0, 0, 0xffff, 0, 0]), 96], + // RFC6145 + rfc6145: [new IPv6([0, 0, 0, 0, 0xffff, 0, 0, 0]), 96], + // RFC6052 + rfc6052: [new IPv6([0x64, 0xff9b, 0, 0, 0, 0, 0, 0]), 96], + // RFC3056 + '6to4': [new IPv6([0x2002, 0, 0, 0, 0, 0, 0, 0]), 16], + // RFC6052, RFC6146 + teredo: [new IPv6([0x2001, 0, 0, 0, 0, 0, 0, 0]), 32], + // RFC4291 + reserved: [[new IPv6([0x2001, 0xdb8, 0, 0, 0, 0, 0, 0]), 32]] + }; + + // Checks if this address is an IPv4-mapped IPv6 address. + IPv6.prototype.isIPv4MappedAddress = function () { + return this.range() === 'ipv4Mapped'; + }; + + // The 'kind' method exists on both IPv4 and IPv6 classes. + IPv6.prototype.kind = function () { + return 'ipv6'; + }; + + // Checks if this address matches other one within given CIDR range. + IPv6.prototype.match = function (other, cidrRange) { + let ref; + + if (cidrRange === undefined) { + ref = other; + other = ref[0]; + cidrRange = ref[1]; + } + + if (other.kind() !== 'ipv6') { + throw new Error('ipaddr: cannot match ipv6 address with non-ipv6 one'); + } + + return matchCIDR(this.parts, other.parts, 16, cidrRange); + }; + + // returns a number of leading ones in IPv6 address, making sure that + // the rest is a solid sequence of 0's (valid netmask) + // returns either the CIDR length or null if mask is not valid + IPv6.prototype.prefixLengthFromSubnetMask = function () { + let cidr = 0; + // non-zero encountered stop scanning for zeroes + let stop = false; + // number of zeroes in octet + const zerotable = { + 0: 16, + 32768: 15, + 49152: 14, + 57344: 13, + 61440: 12, + 63488: 11, + 64512: 10, + 65024: 9, + 65280: 8, + 65408: 7, + 65472: 6, + 65504: 5, + 65520: 4, + 65528: 3, + 65532: 2, + 65534: 1, + 65535: 0 + }; + let part, zeros; + + for (let i = 7; i >= 0; i -= 1) { + part = this.parts[i]; + if (part in zerotable) { + zeros = zerotable[part]; + if (stop && zeros !== 0) { + return null; + } + + if (zeros !== 16) { + stop = true; + } + + cidr += zeros; + } else { + return null; + } + } + + return 128 - cidr; + }; + + + // Checks if the address corresponds to one of the special ranges. + IPv6.prototype.range = function () { + return ipaddr.subnetMatch(this, this.SpecialRanges); + }; + + // Returns an array of byte-sized values in network order (MSB first) + IPv6.prototype.toByteArray = function () { + let part; + const bytes = []; + const ref = this.parts; + for (let i = 0; i < ref.length; i++) { + part = ref[i]; + bytes.push(part >> 8); + bytes.push(part & 0xff); + } + + return bytes; + }; + + // Returns the address in expanded format with all zeroes included, like + // 2001:0db8:0008:0066:0000:0000:0000:0001 + IPv6.prototype.toFixedLengthString = function () { + const addr = ((function () { + const results = []; + for (let i = 0; i < this.parts.length; i++) { + results.push(padPart(this.parts[i].toString(16), 4)); + } + + return results; + }).call(this)).join(':'); + + let suffix = ''; + + if (this.zoneId) { + suffix = `%${this.zoneId}`; + } + + return addr + suffix; + }; + + // Converts this address to IPv4 address if it is an IPv4-mapped IPv6 address. + // Throws an error otherwise. + IPv6.prototype.toIPv4Address = function () { + if (!this.isIPv4MappedAddress()) { + throw new Error('ipaddr: trying to convert a generic ipv6 address to ipv4'); + } + + const ref = this.parts.slice(-2); + const high = ref[0]; + const low = ref[1]; + + return new ipaddr.IPv4([high >> 8, high & 0xff, low >> 8, low & 0xff]); + }; + + // Returns the address in expanded format with all zeroes included, like + // 2001:db8:8:66:0:0:0:1 + // + // Deprecated: use toFixedLengthString() instead. + IPv6.prototype.toNormalizedString = function () { + const addr = ((function () { + const results = []; + + for (let i = 0; i < this.parts.length; i++) { + results.push(this.parts[i].toString(16)); + } + + return results; + }).call(this)).join(':'); + + let suffix = ''; + + if (this.zoneId) { + suffix = `%${this.zoneId}`; + } + + return addr + suffix; + }; + + // Returns the address in compact, human-readable format like + // 2001:db8:8:66::1 + // in line with RFC 5952 (see https://tools.ietf.org/html/rfc5952#section-4) + IPv6.prototype.toRFC5952String = function () { + const regex = /((^|:)(0(:|$)){2,})/g; + const string = this.toNormalizedString(); + let bestMatchIndex = 0; + let bestMatchLength = -1; + let match; + + while ((match = regex.exec(string))) { + if (match[0].length > bestMatchLength) { + bestMatchIndex = match.index; + bestMatchLength = match[0].length; + } + } + + if (bestMatchLength < 0) { + return string; + } + + return `${string.substring(0, bestMatchIndex)}::${string.substring(bestMatchIndex + bestMatchLength)}`; + }; + + // Returns the address in compact, human-readable format like + // 2001:db8:8:66::1 + // + // Deprecated: use toRFC5952String() instead. + IPv6.prototype.toString = function () { + // Replace the first sequence of 1 or more '0' parts with '::' + return this.toNormalizedString().replace(/((^|:)(0(:|$))+)/, '::'); + }; + + return IPv6; + + })(); + + // A utility function to return broadcast address given the IPv6 interface and prefix length in CIDR notation + ipaddr.IPv6.broadcastAddressFromCIDR = function (string) { + try { + const cidr = this.parseCIDR(string); + const ipInterfaceOctets = cidr[0].toByteArray(); + const subnetMaskOctets = this.subnetMaskFromPrefixLength(cidr[1]).toByteArray(); + const octets = []; + let i = 0; + while (i < 16) { + // Broadcast address is bitwise OR between ip interface and inverted mask + octets.push(parseInt(ipInterfaceOctets[i], 10) | parseInt(subnetMaskOctets[i], 10) ^ 255); + i++; + } + + return new this(octets); + } catch (e) { + throw new Error(`ipaddr: the address does not have IPv6 CIDR format (${e})`); + } + }; + + // Checks if a given string is formatted like IPv6 address. + ipaddr.IPv6.isIPv6 = function (string) { + return this.parser(string) !== null; + }; + + // Checks to see if string is a valid IPv6 Address + ipaddr.IPv6.isValid = function (string) { + + // Since IPv6.isValid is always called first, this shortcut + // provides a substantial performance gain. + if (typeof string === 'string' && string.indexOf(':') === -1) { + return false; + } + + try { + const addr = this.parser(string); + new this(addr.parts, addr.zoneId); + return true; + } catch (e) { + return false; + } + }; + + // A utility function to return network address given the IPv6 interface and prefix length in CIDR notation + ipaddr.IPv6.networkAddressFromCIDR = function (string) { + let cidr, i, ipInterfaceOctets, octets, subnetMaskOctets; + + try { + cidr = this.parseCIDR(string); + ipInterfaceOctets = cidr[0].toByteArray(); + subnetMaskOctets = this.subnetMaskFromPrefixLength(cidr[1]).toByteArray(); + octets = []; + i = 0; + while (i < 16) { + // Network address is bitwise AND between ip interface and mask + octets.push(parseInt(ipInterfaceOctets[i], 10) & parseInt(subnetMaskOctets[i], 10)); + i++; + } + + return new this(octets); + } catch (e) { + throw new Error(`ipaddr: the address does not have IPv6 CIDR format (${e})`); + } + }; + + // Tries to parse and validate a string with IPv6 address. + // Throws an error if it fails. + ipaddr.IPv6.parse = function (string) { + const addr = this.parser(string); + + if (addr.parts === null) { + throw new Error('ipaddr: string is not formatted like an IPv6 Address'); + } + + return new this(addr.parts, addr.zoneId); + }; + + ipaddr.IPv6.parseCIDR = function (string) { + let maskLength, match, parsed; + + if ((match = string.match(/^(.+)\/(\d+)$/))) { + maskLength = parseInt(match[2]); + if (maskLength >= 0 && maskLength <= 128) { + parsed = [this.parse(match[1]), maskLength]; + Object.defineProperty(parsed, 'toString', { + value: function () { + return this.join('/'); + } + }); + return parsed; + } + } + + throw new Error('ipaddr: string is not formatted like an IPv6 CIDR range'); + }; + + // Parse an IPv6 address. + ipaddr.IPv6.parser = function (string) { + let addr, i, match, octet, octets, zoneId; + + if ((match = string.match(ipv6Regexes.deprecatedTransitional))) { + return this.parser(`::ffff:${match[1]}`); + } + if (ipv6Regexes.native.test(string)) { + return expandIPv6(string, 8); + } + if ((match = string.match(ipv6Regexes.transitional))) { + zoneId = match[6] || ''; + addr = expandIPv6(match[1].slice(0, -1) + zoneId, 6); + if (addr.parts) { + octets = [ + parseInt(match[2]), + parseInt(match[3]), + parseInt(match[4]), + parseInt(match[5]) + ]; + for (i = 0; i < octets.length; i++) { + octet = octets[i]; + if (!((0 <= octet && octet <= 255))) { + return null; + } + } + + addr.parts.push(octets[0] << 8 | octets[1]); + addr.parts.push(octets[2] << 8 | octets[3]); + return { + parts: addr.parts, + zoneId: addr.zoneId + }; + } + } + + return null; + }; + + // A utility function to return subnet mask in IPv6 format given the prefix length + ipaddr.IPv6.subnetMaskFromPrefixLength = function (prefix) { + prefix = parseInt(prefix); + if (prefix < 0 || prefix > 128) { + throw new Error('ipaddr: invalid IPv6 prefix length'); + } + + const octets = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]; + let j = 0; + const filledOctetCount = Math.floor(prefix / 8); + + while (j < filledOctetCount) { + octets[j] = 255; + j++; + } + + if (filledOctetCount < 16) { + octets[filledOctetCount] = Math.pow(2, prefix % 8) - 1 << 8 - (prefix % 8); + } + + return new this(octets); + }; + + // Try to parse an array in network order (MSB first) for IPv4 and IPv6 + ipaddr.fromByteArray = function (bytes) { + const length = bytes.length; + + if (length === 4) { + return new ipaddr.IPv4(bytes); + } else if (length === 16) { + return new ipaddr.IPv6(bytes); + } else { + throw new Error('ipaddr: the binary input is neither an IPv6 nor IPv4 address'); + } + }; + + // Checks if the address is valid IP address + ipaddr.isValid = function (string) { + return ipaddr.IPv6.isValid(string) || ipaddr.IPv4.isValid(string); + }; + + + // Attempts to parse an IP Address, first through IPv6 then IPv4. + // Throws an error if it could not be parsed. + ipaddr.parse = function (string) { + if (ipaddr.IPv6.isValid(string)) { + return ipaddr.IPv6.parse(string); + } else if (ipaddr.IPv4.isValid(string)) { + return ipaddr.IPv4.parse(string); + } else { + throw new Error('ipaddr: the address has neither IPv6 nor IPv4 format'); + } + }; + + // Attempt to parse CIDR notation, first through IPv6 then IPv4. + // Throws an error if it could not be parsed. + ipaddr.parseCIDR = function (string) { + try { + return ipaddr.IPv6.parseCIDR(string); + } catch (e) { + try { + return ipaddr.IPv4.parseCIDR(string); + } catch (e2) { + throw new Error('ipaddr: the address has neither IPv6 nor IPv4 CIDR format'); + } + } + }; + + // Parse an address and return plain IPv4 address if it is an IPv4-mapped address + ipaddr.process = function (string) { + const addr = this.parse(string); + + if (addr.kind() === 'ipv6' && addr.isIPv4MappedAddress()) { + return addr.toIPv4Address(); + } else { + return addr; + } + }; + + // An utility function to ease named range matching. See examples below. + // rangeList can contain both IPv4 and IPv6 subnet entries and will not throw errors + // on matching IPv4 addresses to IPv6 ranges or vice versa. + ipaddr.subnetMatch = function (address, rangeList, defaultName) { + let i, rangeName, rangeSubnets, subnet; + + if (defaultName === undefined || defaultName === null) { + defaultName = 'unicast'; + } + + for (rangeName in rangeList) { + if (Object.prototype.hasOwnProperty.call(rangeList, rangeName)) { + rangeSubnets = rangeList[rangeName]; + // ECMA5 Array.isArray isn't available everywhere + if (rangeSubnets[0] && !(rangeSubnets[0] instanceof Array)) { + rangeSubnets = [rangeSubnets]; + } + + for (i = 0; i < rangeSubnets.length; i++) { + subnet = rangeSubnets[i]; + if (address.kind() === subnet[0].kind() && address.match.apply(address, subnet)) { + return rangeName; + } + } + } + } + + return defaultName; + }; + + // Export for both the CommonJS and browser-like environment + if ( true && module.exports) { + module.exports = ipaddr; + + } else { + root.ipaddr = ipaddr; + } + +}(this)); + + +/***/ }), + +/***/ 9991: +/***/ ((module) => { + +"use strict"; + +module.exports = (function() +{ + function _min(d0, d1, d2, bx, ay) + { + return d0 < d1 || d2 < d1 + ? d0 > d2 + ? d2 + 1 + : d0 + 1 + : bx === ay + ? d1 + : d1 + 1; + } + + return function(a, b) + { + if (a === b) { + return 0; + } + + if (a.length > b.length) { + var tmp = a; + a = b; + b = tmp; + } + + var la = a.length; + var lb = b.length; + + while (la > 0 && (a.charCodeAt(la - 1) === b.charCodeAt(lb - 1))) { + la--; + lb--; + } + + var offset = 0; + + while (offset < la && (a.charCodeAt(offset) === b.charCodeAt(offset))) { + offset++; + } + + la -= offset; + lb -= offset; + + if (la === 0 || lb < 3) { + return lb; + } + + var x = 0; + var y; + var d0; + var d1; + var d2; + var d3; + var dd; + var dy; + var ay; + var bx0; + var bx1; + var bx2; + var bx3; + + var vector = []; + + for (y = 0; y < la; y++) { + vector.push(y + 1); + vector.push(a.charCodeAt(offset + y)); + } + + var len = vector.length - 1; + + for (; x < lb - 3;) { + bx0 = b.charCodeAt(offset + (d0 = x)); + bx1 = b.charCodeAt(offset + (d1 = x + 1)); + bx2 = b.charCodeAt(offset + (d2 = x + 2)); + bx3 = b.charCodeAt(offset + (d3 = x + 3)); + dd = (x += 4); + for (y = 0; y < len; y += 2) { + dy = vector[y]; + ay = vector[y + 1]; + d0 = _min(dy, d0, d1, bx0, ay); + d1 = _min(d0, d1, d2, bx1, ay); + d2 = _min(d1, d2, d3, bx2, ay); + dd = _min(d2, d3, dd, bx3, ay); + vector[y] = dd; + d3 = d2; + d2 = d1; + d1 = d0; + d0 = dy; + } + } + + for (; x < lb;) { + bx0 = b.charCodeAt(offset + (d0 = x)); + dd = ++x; + for (y = 0; y < len; y += 2) { + dy = vector[y]; + vector[y] = dd = _min(dy, d0, dd, bx0, vector[y + 1]); + d0 = dy; + } + } + + return dd; + }; +})(); + + + +/***/ }), + +/***/ 9591: +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +"use strict"; +// Top level file is just a mixin of submodules & constants + + +var assign = (__webpack_require__(4236).assign); + +var deflate = __webpack_require__(4555); +var inflate = __webpack_require__(8843); +var constants = __webpack_require__(1619); + +var pako = {}; + +assign(pako, deflate, inflate, constants); + +module.exports = pako; + + +/***/ }), + +/***/ 4555: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + + + +var zlib_deflate = __webpack_require__(405); +var utils = __webpack_require__(4236); +var strings = __webpack_require__(9373); +var msg = __webpack_require__(8898); +var ZStream = __webpack_require__(2292); + +var toString = Object.prototype.toString; + +/* Public constants ==========================================================*/ +/* ===========================================================================*/ + +var Z_NO_FLUSH = 0; +var Z_FINISH = 4; + +var Z_OK = 0; +var Z_STREAM_END = 1; +var Z_SYNC_FLUSH = 2; + +var Z_DEFAULT_COMPRESSION = -1; + +var Z_DEFAULT_STRATEGY = 0; + +var Z_DEFLATED = 8; + +/* ===========================================================================*/ + + +/** + * class Deflate + * + * Generic JS-style wrapper for zlib calls. If you don't need + * streaming behaviour - use more simple functions: [[deflate]], + * [[deflateRaw]] and [[gzip]]. + **/ + +/* internal + * Deflate.chunks -> Array + * + * Chunks of output data, if [[Deflate#onData]] not overridden. + **/ + +/** + * Deflate.result -> Uint8Array|Array + * + * Compressed result, generated by default [[Deflate#onData]] + * and [[Deflate#onEnd]] handlers. Filled after you push last chunk + * (call [[Deflate#push]] with `Z_FINISH` / `true` param) or if you + * push a chunk with explicit flush (call [[Deflate#push]] with + * `Z_SYNC_FLUSH` param). + **/ + +/** + * Deflate.err -> Number + * + * Error code after deflate finished. 0 (Z_OK) on success. + * You will not need it in real life, because deflate errors + * are possible only on wrong options or bad `onData` / `onEnd` + * custom handlers. + **/ + +/** + * Deflate.msg -> String + * + * Error message, if [[Deflate.err]] != 0 + **/ + + +/** + * new Deflate(options) + * - options (Object): zlib deflate options. + * + * Creates new deflator instance with specified params. Throws exception + * on bad params. Supported options: + * + * - `level` + * - `windowBits` + * - `memLevel` + * - `strategy` + * - `dictionary` + * + * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced) + * for more information on these. + * + * Additional options, for internal needs: + * + * - `chunkSize` - size of generated data chunks (16K by default) + * - `raw` (Boolean) - do raw deflate + * - `gzip` (Boolean) - create gzip wrapper + * - `to` (String) - if equal to 'string', then result will be "binary string" + * (each char code [0..255]) + * - `header` (Object) - custom header for gzip + * - `text` (Boolean) - true if compressed data believed to be text + * - `time` (Number) - modification time, unix timestamp + * - `os` (Number) - operation system code + * - `extra` (Array) - array of bytes with extra data (max 65536) + * - `name` (String) - file name (binary string) + * - `comment` (String) - comment (binary string) + * - `hcrc` (Boolean) - true if header crc should be added + * + * ##### Example: + * + * ```javascript + * var pako = require('pako') + * , chunk1 = Uint8Array([1,2,3,4,5,6,7,8,9]) + * , chunk2 = Uint8Array([10,11,12,13,14,15,16,17,18,19]); + * + * var deflate = new pako.Deflate({ level: 3}); + * + * deflate.push(chunk1, false); + * deflate.push(chunk2, true); // true -> last chunk + * + * if (deflate.err) { throw new Error(deflate.err); } + * + * console.log(deflate.result); + * ``` + **/ +function Deflate(options) { + if (!(this instanceof Deflate)) return new Deflate(options); + + this.options = utils.assign({ + level: Z_DEFAULT_COMPRESSION, + method: Z_DEFLATED, + chunkSize: 16384, + windowBits: 15, + memLevel: 8, + strategy: Z_DEFAULT_STRATEGY, + to: '' + }, options || {}); + + var opt = this.options; + + if (opt.raw && (opt.windowBits > 0)) { + opt.windowBits = -opt.windowBits; + } + + else if (opt.gzip && (opt.windowBits > 0) && (opt.windowBits < 16)) { + opt.windowBits += 16; + } + + this.err = 0; // error code, if happens (0 = Z_OK) + this.msg = ''; // error message + this.ended = false; // used to avoid multiple onEnd() calls + this.chunks = []; // chunks of compressed data + + this.strm = new ZStream(); + this.strm.avail_out = 0; + + var status = zlib_deflate.deflateInit2( + this.strm, + opt.level, + opt.method, + opt.windowBits, + opt.memLevel, + opt.strategy + ); + + if (status !== Z_OK) { + throw new Error(msg[status]); + } + + if (opt.header) { + zlib_deflate.deflateSetHeader(this.strm, opt.header); + } + + if (opt.dictionary) { + var dict; + // Convert data if needed + if (typeof opt.dictionary === 'string') { + // If we need to compress text, change encoding to utf8. + dict = strings.string2buf(opt.dictionary); + } else if (toString.call(opt.dictionary) === '[object ArrayBuffer]') { + dict = new Uint8Array(opt.dictionary); + } else { + dict = opt.dictionary; + } + + status = zlib_deflate.deflateSetDictionary(this.strm, dict); + + if (status !== Z_OK) { + throw new Error(msg[status]); + } + + this._dict_set = true; + } +} + +/** + * Deflate#push(data[, mode]) -> Boolean + * - data (Uint8Array|Array|ArrayBuffer|String): input data. Strings will be + * converted to utf8 byte sequence. + * - mode (Number|Boolean): 0..6 for corresponding Z_NO_FLUSH..Z_TREE modes. + * See constants. Skipped or `false` means Z_NO_FLUSH, `true` means Z_FINISH. + * + * Sends input data to deflate pipe, generating [[Deflate#onData]] calls with + * new compressed chunks. Returns `true` on success. The last data block must have + * mode Z_FINISH (or `true`). That will flush internal pending buffers and call + * [[Deflate#onEnd]]. For interim explicit flushes (without ending the stream) you + * can use mode Z_SYNC_FLUSH, keeping the compression context. + * + * On fail call [[Deflate#onEnd]] with error code and return false. + * + * We strongly recommend to use `Uint8Array` on input for best speed (output + * array format is detected automatically). Also, don't skip last param and always + * use the same type in your code (boolean or number). That will improve JS speed. + * + * For regular `Array`-s make sure all elements are [0..255]. + * + * ##### Example + * + * ```javascript + * push(chunk, false); // push one of data chunks + * ... + * push(chunk, true); // push last chunk + * ``` + **/ +Deflate.prototype.push = function (data, mode) { + var strm = this.strm; + var chunkSize = this.options.chunkSize; + var status, _mode; + + if (this.ended) { return false; } + + _mode = (mode === ~~mode) ? mode : ((mode === true) ? Z_FINISH : Z_NO_FLUSH); + + // Convert data if needed + if (typeof data === 'string') { + // If we need to compress text, change encoding to utf8. + strm.input = strings.string2buf(data); + } else if (toString.call(data) === '[object ArrayBuffer]') { + strm.input = new Uint8Array(data); + } else { + strm.input = data; + } + + strm.next_in = 0; + strm.avail_in = strm.input.length; + + do { + if (strm.avail_out === 0) { + strm.output = new utils.Buf8(chunkSize); + strm.next_out = 0; + strm.avail_out = chunkSize; + } + status = zlib_deflate.deflate(strm, _mode); /* no bad return value */ + + if (status !== Z_STREAM_END && status !== Z_OK) { + this.onEnd(status); + this.ended = true; + return false; + } + if (strm.avail_out === 0 || (strm.avail_in === 0 && (_mode === Z_FINISH || _mode === Z_SYNC_FLUSH))) { + if (this.options.to === 'string') { + this.onData(strings.buf2binstring(utils.shrinkBuf(strm.output, strm.next_out))); + } else { + this.onData(utils.shrinkBuf(strm.output, strm.next_out)); + } + } + } while ((strm.avail_in > 0 || strm.avail_out === 0) && status !== Z_STREAM_END); + + // Finalize on the last chunk. + if (_mode === Z_FINISH) { + status = zlib_deflate.deflateEnd(this.strm); + this.onEnd(status); + this.ended = true; + return status === Z_OK; + } + + // callback interim results if Z_SYNC_FLUSH. + if (_mode === Z_SYNC_FLUSH) { + this.onEnd(Z_OK); + strm.avail_out = 0; + return true; + } + + return true; +}; + + +/** + * Deflate#onData(chunk) -> Void + * - chunk (Uint8Array|Array|String): output data. Type of array depends + * on js engine support. When string output requested, each chunk + * will be string. + * + * By default, stores data blocks in `chunks[]` property and glue + * those in `onEnd`. Override this handler, if you need another behaviour. + **/ +Deflate.prototype.onData = function (chunk) { + this.chunks.push(chunk); +}; + + +/** + * Deflate#onEnd(status) -> Void + * - status (Number): deflate status. 0 (Z_OK) on success, + * other if not. + * + * Called once after you tell deflate that the input stream is + * complete (Z_FINISH) or should be flushed (Z_SYNC_FLUSH) + * or if an error happened. By default - join collected chunks, + * free memory and fill `results` / `err` properties. + **/ +Deflate.prototype.onEnd = function (status) { + // On success - join + if (status === Z_OK) { + if (this.options.to === 'string') { + this.result = this.chunks.join(''); + } else { + this.result = utils.flattenChunks(this.chunks); + } + } + this.chunks = []; + this.err = status; + this.msg = this.strm.msg; +}; + + +/** + * deflate(data[, options]) -> Uint8Array|Array|String + * - data (Uint8Array|Array|String): input data to compress. + * - options (Object): zlib deflate options. + * + * Compress `data` with deflate algorithm and `options`. + * + * Supported options are: + * + * - level + * - windowBits + * - memLevel + * - strategy + * - dictionary + * + * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced) + * for more information on these. + * + * Sugar (options): + * + * - `raw` (Boolean) - say that we work with raw stream, if you don't wish to specify + * negative windowBits implicitly. + * - `to` (String) - if equal to 'string', then result will be "binary string" + * (each char code [0..255]) + * + * ##### Example: + * + * ```javascript + * var pako = require('pako') + * , data = Uint8Array([1,2,3,4,5,6,7,8,9]); + * + * console.log(pako.deflate(data)); + * ``` + **/ +function deflate(input, options) { + var deflator = new Deflate(options); + + deflator.push(input, true); + + // That will never happens, if you don't cheat with options :) + if (deflator.err) { throw deflator.msg || msg[deflator.err]; } + + return deflator.result; +} + + +/** + * deflateRaw(data[, options]) -> Uint8Array|Array|String + * - data (Uint8Array|Array|String): input data to compress. + * - options (Object): zlib deflate options. + * + * The same as [[deflate]], but creates raw data, without wrapper + * (header and adler32 crc). + **/ +function deflateRaw(input, options) { + options = options || {}; + options.raw = true; + return deflate(input, options); +} + + +/** + * gzip(data[, options]) -> Uint8Array|Array|String + * - data (Uint8Array|Array|String): input data to compress. + * - options (Object): zlib deflate options. + * + * The same as [[deflate]], but create gzip wrapper instead of + * deflate one. + **/ +function gzip(input, options) { + options = options || {}; + options.gzip = true; + return deflate(input, options); +} + + +exports.Deflate = Deflate; +exports.deflate = deflate; +exports.deflateRaw = deflateRaw; +exports.gzip = gzip; + + +/***/ }), + +/***/ 8843: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + + + +var zlib_inflate = __webpack_require__(7948); +var utils = __webpack_require__(4236); +var strings = __webpack_require__(9373); +var c = __webpack_require__(1619); +var msg = __webpack_require__(8898); +var ZStream = __webpack_require__(2292); +var GZheader = __webpack_require__(2401); + +var toString = Object.prototype.toString; + +/** + * class Inflate + * + * Generic JS-style wrapper for zlib calls. If you don't need + * streaming behaviour - use more simple functions: [[inflate]] + * and [[inflateRaw]]. + **/ + +/* internal + * inflate.chunks -> Array + * + * Chunks of output data, if [[Inflate#onData]] not overridden. + **/ + +/** + * Inflate.result -> Uint8Array|Array|String + * + * Uncompressed result, generated by default [[Inflate#onData]] + * and [[Inflate#onEnd]] handlers. Filled after you push last chunk + * (call [[Inflate#push]] with `Z_FINISH` / `true` param) or if you + * push a chunk with explicit flush (call [[Inflate#push]] with + * `Z_SYNC_FLUSH` param). + **/ + +/** + * Inflate.err -> Number + * + * Error code after inflate finished. 0 (Z_OK) on success. + * Should be checked if broken data possible. + **/ + +/** + * Inflate.msg -> String + * + * Error message, if [[Inflate.err]] != 0 + **/ + + +/** + * new Inflate(options) + * - options (Object): zlib inflate options. + * + * Creates new inflator instance with specified params. Throws exception + * on bad params. Supported options: + * + * - `windowBits` + * - `dictionary` + * + * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced) + * for more information on these. + * + * Additional options, for internal needs: + * + * - `chunkSize` - size of generated data chunks (16K by default) + * - `raw` (Boolean) - do raw inflate + * - `to` (String) - if equal to 'string', then result will be converted + * from utf8 to utf16 (javascript) string. When string output requested, + * chunk length can differ from `chunkSize`, depending on content. + * + * By default, when no options set, autodetect deflate/gzip data format via + * wrapper header. + * + * ##### Example: + * + * ```javascript + * var pako = require('pako') + * , chunk1 = Uint8Array([1,2,3,4,5,6,7,8,9]) + * , chunk2 = Uint8Array([10,11,12,13,14,15,16,17,18,19]); + * + * var inflate = new pako.Inflate({ level: 3}); + * + * inflate.push(chunk1, false); + * inflate.push(chunk2, true); // true -> last chunk + * + * if (inflate.err) { throw new Error(inflate.err); } + * + * console.log(inflate.result); + * ``` + **/ +function Inflate(options) { + if (!(this instanceof Inflate)) return new Inflate(options); + + this.options = utils.assign({ + chunkSize: 16384, + windowBits: 0, + to: '' + }, options || {}); + + var opt = this.options; + + // Force window size for `raw` data, if not set directly, + // because we have no header for autodetect. + if (opt.raw && (opt.windowBits >= 0) && (opt.windowBits < 16)) { + opt.windowBits = -opt.windowBits; + if (opt.windowBits === 0) { opt.windowBits = -15; } + } + + // If `windowBits` not defined (and mode not raw) - set autodetect flag for gzip/deflate + if ((opt.windowBits >= 0) && (opt.windowBits < 16) && + !(options && options.windowBits)) { + opt.windowBits += 32; + } + + // Gzip header has no info about windows size, we can do autodetect only + // for deflate. So, if window size not set, force it to max when gzip possible + if ((opt.windowBits > 15) && (opt.windowBits < 48)) { + // bit 3 (16) -> gzipped data + // bit 4 (32) -> autodetect gzip/deflate + if ((opt.windowBits & 15) === 0) { + opt.windowBits |= 15; + } + } + + this.err = 0; // error code, if happens (0 = Z_OK) + this.msg = ''; // error message + this.ended = false; // used to avoid multiple onEnd() calls + this.chunks = []; // chunks of compressed data + + this.strm = new ZStream(); + this.strm.avail_out = 0; + + var status = zlib_inflate.inflateInit2( + this.strm, + opt.windowBits + ); + + if (status !== c.Z_OK) { + throw new Error(msg[status]); + } + + this.header = new GZheader(); + + zlib_inflate.inflateGetHeader(this.strm, this.header); + + // Setup dictionary + if (opt.dictionary) { + // Convert data if needed + if (typeof opt.dictionary === 'string') { + opt.dictionary = strings.string2buf(opt.dictionary); + } else if (toString.call(opt.dictionary) === '[object ArrayBuffer]') { + opt.dictionary = new Uint8Array(opt.dictionary); + } + if (opt.raw) { //In raw mode we need to set the dictionary early + status = zlib_inflate.inflateSetDictionary(this.strm, opt.dictionary); + if (status !== c.Z_OK) { + throw new Error(msg[status]); + } + } + } +} + +/** + * Inflate#push(data[, mode]) -> Boolean + * - data (Uint8Array|Array|ArrayBuffer|String): input data + * - mode (Number|Boolean): 0..6 for corresponding Z_NO_FLUSH..Z_TREE modes. + * See constants. Skipped or `false` means Z_NO_FLUSH, `true` means Z_FINISH. + * + * Sends input data to inflate pipe, generating [[Inflate#onData]] calls with + * new output chunks. Returns `true` on success. The last data block must have + * mode Z_FINISH (or `true`). That will flush internal pending buffers and call + * [[Inflate#onEnd]]. For interim explicit flushes (without ending the stream) you + * can use mode Z_SYNC_FLUSH, keeping the decompression context. + * + * On fail call [[Inflate#onEnd]] with error code and return false. + * + * We strongly recommend to use `Uint8Array` on input for best speed (output + * format is detected automatically). Also, don't skip last param and always + * use the same type in your code (boolean or number). That will improve JS speed. + * + * For regular `Array`-s make sure all elements are [0..255]. + * + * ##### Example + * + * ```javascript + * push(chunk, false); // push one of data chunks + * ... + * push(chunk, true); // push last chunk + * ``` + **/ +Inflate.prototype.push = function (data, mode) { + var strm = this.strm; + var chunkSize = this.options.chunkSize; + var dictionary = this.options.dictionary; + var status, _mode; + var next_out_utf8, tail, utf8str; + + // Flag to properly process Z_BUF_ERROR on testing inflate call + // when we check that all output data was flushed. + var allowBufError = false; + + if (this.ended) { return false; } + _mode = (mode === ~~mode) ? mode : ((mode === true) ? c.Z_FINISH : c.Z_NO_FLUSH); + + // Convert data if needed + if (typeof data === 'string') { + // Only binary strings can be decompressed on practice + strm.input = strings.binstring2buf(data); + } else if (toString.call(data) === '[object ArrayBuffer]') { + strm.input = new Uint8Array(data); + } else { + strm.input = data; + } + + strm.next_in = 0; + strm.avail_in = strm.input.length; + + do { + if (strm.avail_out === 0) { + strm.output = new utils.Buf8(chunkSize); + strm.next_out = 0; + strm.avail_out = chunkSize; + } + + status = zlib_inflate.inflate(strm, c.Z_NO_FLUSH); /* no bad return value */ + + if (status === c.Z_NEED_DICT && dictionary) { + status = zlib_inflate.inflateSetDictionary(this.strm, dictionary); + } + + if (status === c.Z_BUF_ERROR && allowBufError === true) { + status = c.Z_OK; + allowBufError = false; + } + + if (status !== c.Z_STREAM_END && status !== c.Z_OK) { + this.onEnd(status); + this.ended = true; + return false; + } + + if (strm.next_out) { + if (strm.avail_out === 0 || status === c.Z_STREAM_END || (strm.avail_in === 0 && (_mode === c.Z_FINISH || _mode === c.Z_SYNC_FLUSH))) { + + if (this.options.to === 'string') { + + next_out_utf8 = strings.utf8border(strm.output, strm.next_out); + + tail = strm.next_out - next_out_utf8; + utf8str = strings.buf2string(strm.output, next_out_utf8); + + // move tail + strm.next_out = tail; + strm.avail_out = chunkSize - tail; + if (tail) { utils.arraySet(strm.output, strm.output, next_out_utf8, tail, 0); } + + this.onData(utf8str); + + } else { + this.onData(utils.shrinkBuf(strm.output, strm.next_out)); + } + } + } + + // When no more input data, we should check that internal inflate buffers + // are flushed. The only way to do it when avail_out = 0 - run one more + // inflate pass. But if output data not exists, inflate return Z_BUF_ERROR. + // Here we set flag to process this error properly. + // + // NOTE. Deflate does not return error in this case and does not needs such + // logic. + if (strm.avail_in === 0 && strm.avail_out === 0) { + allowBufError = true; + } + + } while ((strm.avail_in > 0 || strm.avail_out === 0) && status !== c.Z_STREAM_END); + + if (status === c.Z_STREAM_END) { + _mode = c.Z_FINISH; + } + + // Finalize on the last chunk. + if (_mode === c.Z_FINISH) { + status = zlib_inflate.inflateEnd(this.strm); + this.onEnd(status); + this.ended = true; + return status === c.Z_OK; + } + + // callback interim results if Z_SYNC_FLUSH. + if (_mode === c.Z_SYNC_FLUSH) { + this.onEnd(c.Z_OK); + strm.avail_out = 0; + return true; + } + + return true; +}; + + +/** + * Inflate#onData(chunk) -> Void + * - chunk (Uint8Array|Array|String): output data. Type of array depends + * on js engine support. When string output requested, each chunk + * will be string. + * + * By default, stores data blocks in `chunks[]` property and glue + * those in `onEnd`. Override this handler, if you need another behaviour. + **/ +Inflate.prototype.onData = function (chunk) { + this.chunks.push(chunk); +}; + + +/** + * Inflate#onEnd(status) -> Void + * - status (Number): inflate status. 0 (Z_OK) on success, + * other if not. + * + * Called either after you tell inflate that the input stream is + * complete (Z_FINISH) or should be flushed (Z_SYNC_FLUSH) + * or if an error happened. By default - join collected chunks, + * free memory and fill `results` / `err` properties. + **/ +Inflate.prototype.onEnd = function (status) { + // On success - join + if (status === c.Z_OK) { + if (this.options.to === 'string') { + // Glue & convert here, until we teach pako to send + // utf8 aligned strings to onData + this.result = this.chunks.join(''); + } else { + this.result = utils.flattenChunks(this.chunks); + } + } + this.chunks = []; + this.err = status; + this.msg = this.strm.msg; +}; + + +/** + * inflate(data[, options]) -> Uint8Array|Array|String + * - data (Uint8Array|Array|String): input data to decompress. + * - options (Object): zlib inflate options. + * + * Decompress `data` with inflate/ungzip and `options`. Autodetect + * format via wrapper header by default. That's why we don't provide + * separate `ungzip` method. + * + * Supported options are: + * + * - windowBits + * + * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced) + * for more information. + * + * Sugar (options): + * + * - `raw` (Boolean) - say that we work with raw stream, if you don't wish to specify + * negative windowBits implicitly. + * - `to` (String) - if equal to 'string', then result will be converted + * from utf8 to utf16 (javascript) string. When string output requested, + * chunk length can differ from `chunkSize`, depending on content. + * + * + * ##### Example: + * + * ```javascript + * var pako = require('pako') + * , input = pako.deflate([1,2,3,4,5,6,7,8,9]) + * , output; + * + * try { + * output = pako.inflate(input); + * } catch (err) + * console.log(err); + * } + * ``` + **/ +function inflate(input, options) { + var inflator = new Inflate(options); + + inflator.push(input, true); + + // That will never happens, if you don't cheat with options :) + if (inflator.err) { throw inflator.msg || msg[inflator.err]; } + + return inflator.result; +} + + +/** + * inflateRaw(data[, options]) -> Uint8Array|Array|String + * - data (Uint8Array|Array|String): input data to decompress. + * - options (Object): zlib inflate options. + * + * The same as [[inflate]], but creates raw data, without wrapper + * (header and adler32 crc). + **/ +function inflateRaw(input, options) { + options = options || {}; + options.raw = true; + return inflate(input, options); +} + + +/** + * ungzip(data[, options]) -> Uint8Array|Array|String + * - data (Uint8Array|Array|String): input data to decompress. + * - options (Object): zlib inflate options. + * + * Just shortcut to [[inflate]], because it autodetects format + * by header.content. Done for convenience. + **/ + + +exports.Inflate = Inflate; +exports.inflate = inflate; +exports.inflateRaw = inflateRaw; +exports.ungzip = inflate; + + +/***/ }), + +/***/ 4236: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + + + +var TYPED_OK = (typeof Uint8Array !== 'undefined') && + (typeof Uint16Array !== 'undefined') && + (typeof Int32Array !== 'undefined'); + +function _has(obj, key) { + return Object.prototype.hasOwnProperty.call(obj, key); +} + +exports.assign = function (obj /*from1, from2, from3, ...*/) { + var sources = Array.prototype.slice.call(arguments, 1); + while (sources.length) { + var source = sources.shift(); + if (!source) { continue; } + + if (typeof source !== 'object') { + throw new TypeError(source + 'must be non-object'); + } + + for (var p in source) { + if (_has(source, p)) { + obj[p] = source[p]; + } + } + } + + return obj; +}; + + +// reduce buffer size, avoiding mem copy +exports.shrinkBuf = function (buf, size) { + if (buf.length === size) { return buf; } + if (buf.subarray) { return buf.subarray(0, size); } + buf.length = size; + return buf; +}; + + +var fnTyped = { + arraySet: function (dest, src, src_offs, len, dest_offs) { + if (src.subarray && dest.subarray) { + dest.set(src.subarray(src_offs, src_offs + len), dest_offs); + return; + } + // Fallback to ordinary array + for (var i = 0; i < len; i++) { + dest[dest_offs + i] = src[src_offs + i]; + } + }, + // Join array of chunks to single array. + flattenChunks: function (chunks) { + var i, l, len, pos, chunk, result; + + // calculate data length + len = 0; + for (i = 0, l = chunks.length; i < l; i++) { + len += chunks[i].length; + } + + // join chunks + result = new Uint8Array(len); + pos = 0; + for (i = 0, l = chunks.length; i < l; i++) { + chunk = chunks[i]; + result.set(chunk, pos); + pos += chunk.length; + } + + return result; + } +}; + +var fnUntyped = { + arraySet: function (dest, src, src_offs, len, dest_offs) { + for (var i = 0; i < len; i++) { + dest[dest_offs + i] = src[src_offs + i]; + } + }, + // Join array of chunks to single array. + flattenChunks: function (chunks) { + return [].concat.apply([], chunks); + } +}; + + +// Enable/Disable typed arrays use, for testing +// +exports.setTyped = function (on) { + if (on) { + exports.Buf8 = Uint8Array; + exports.Buf16 = Uint16Array; + exports.Buf32 = Int32Array; + exports.assign(exports, fnTyped); + } else { + exports.Buf8 = Array; + exports.Buf16 = Array; + exports.Buf32 = Array; + exports.assign(exports, fnUntyped); + } +}; + +exports.setTyped(TYPED_OK); + + +/***/ }), + +/***/ 9373: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; +// String encode/decode helpers + + + +var utils = __webpack_require__(4236); + + +// Quick check if we can use fast array to bin string conversion +// +// - apply(Array) can fail on Android 2.2 +// - apply(Uint8Array) can fail on iOS 5.1 Safari +// +var STR_APPLY_OK = true; +var STR_APPLY_UIA_OK = true; + +try { String.fromCharCode.apply(null, [ 0 ]); } catch (__) { STR_APPLY_OK = false; } +try { String.fromCharCode.apply(null, new Uint8Array(1)); } catch (__) { STR_APPLY_UIA_OK = false; } + + +// Table with utf8 lengths (calculated by first byte of sequence) +// Note, that 5 & 6-byte values and some 4-byte values can not be represented in JS, +// because max possible codepoint is 0x10ffff +var _utf8len = new utils.Buf8(256); +for (var q = 0; q < 256; q++) { + _utf8len[q] = (q >= 252 ? 6 : q >= 248 ? 5 : q >= 240 ? 4 : q >= 224 ? 3 : q >= 192 ? 2 : 1); +} +_utf8len[254] = _utf8len[254] = 1; // Invalid sequence start + + +// convert string to array (typed, when possible) +exports.string2buf = function (str) { + var buf, c, c2, m_pos, i, str_len = str.length, buf_len = 0; + + // count binary size + for (m_pos = 0; m_pos < str_len; m_pos++) { + c = str.charCodeAt(m_pos); + if ((c & 0xfc00) === 0xd800 && (m_pos + 1 < str_len)) { + c2 = str.charCodeAt(m_pos + 1); + if ((c2 & 0xfc00) === 0xdc00) { + c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00); + m_pos++; + } + } + buf_len += c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4; + } + + // allocate buffer + buf = new utils.Buf8(buf_len); + + // convert + for (i = 0, m_pos = 0; i < buf_len; m_pos++) { + c = str.charCodeAt(m_pos); + if ((c & 0xfc00) === 0xd800 && (m_pos + 1 < str_len)) { + c2 = str.charCodeAt(m_pos + 1); + if ((c2 & 0xfc00) === 0xdc00) { + c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00); + m_pos++; + } + } + if (c < 0x80) { + /* one byte */ + buf[i++] = c; + } else if (c < 0x800) { + /* two bytes */ + buf[i++] = 0xC0 | (c >>> 6); + buf[i++] = 0x80 | (c & 0x3f); + } else if (c < 0x10000) { + /* three bytes */ + buf[i++] = 0xE0 | (c >>> 12); + buf[i++] = 0x80 | (c >>> 6 & 0x3f); + buf[i++] = 0x80 | (c & 0x3f); + } else { + /* four bytes */ + buf[i++] = 0xf0 | (c >>> 18); + buf[i++] = 0x80 | (c >>> 12 & 0x3f); + buf[i++] = 0x80 | (c >>> 6 & 0x3f); + buf[i++] = 0x80 | (c & 0x3f); + } + } + + return buf; +}; + +// Helper (used in 2 places) +function buf2binstring(buf, len) { + // On Chrome, the arguments in a function call that are allowed is `65534`. + // If the length of the buffer is smaller than that, we can use this optimization, + // otherwise we will take a slower path. + if (len < 65534) { + if ((buf.subarray && STR_APPLY_UIA_OK) || (!buf.subarray && STR_APPLY_OK)) { + return String.fromCharCode.apply(null, utils.shrinkBuf(buf, len)); + } + } + + var result = ''; + for (var i = 0; i < len; i++) { + result += String.fromCharCode(buf[i]); + } + return result; +} + + +// Convert byte array to binary string +exports.buf2binstring = function (buf) { + return buf2binstring(buf, buf.length); +}; + + +// Convert binary string (typed, when possible) +exports.binstring2buf = function (str) { + var buf = new utils.Buf8(str.length); + for (var i = 0, len = buf.length; i < len; i++) { + buf[i] = str.charCodeAt(i); + } + return buf; +}; + + +// convert array to string +exports.buf2string = function (buf, max) { + var i, out, c, c_len; + var len = max || buf.length; + + // Reserve max possible length (2 words per char) + // NB: by unknown reasons, Array is significantly faster for + // String.fromCharCode.apply than Uint16Array. + var utf16buf = new Array(len * 2); + + for (out = 0, i = 0; i < len;) { + c = buf[i++]; + // quick process ascii + if (c < 0x80) { utf16buf[out++] = c; continue; } + + c_len = _utf8len[c]; + // skip 5 & 6 byte codes + if (c_len > 4) { utf16buf[out++] = 0xfffd; i += c_len - 1; continue; } + + // apply mask on first byte + c &= c_len === 2 ? 0x1f : c_len === 3 ? 0x0f : 0x07; + // join the rest + while (c_len > 1 && i < len) { + c = (c << 6) | (buf[i++] & 0x3f); + c_len--; + } + + // terminated by end of string? + if (c_len > 1) { utf16buf[out++] = 0xfffd; continue; } + + if (c < 0x10000) { + utf16buf[out++] = c; + } else { + c -= 0x10000; + utf16buf[out++] = 0xd800 | ((c >> 10) & 0x3ff); + utf16buf[out++] = 0xdc00 | (c & 0x3ff); + } + } + + return buf2binstring(utf16buf, out); +}; + + +// Calculate max possible position in utf8 buffer, +// that will not break sequence. If that's not possible +// - (very small limits) return max size as is. +// +// buf[] - utf8 bytes array +// max - length limit (mandatory); +exports.utf8border = function (buf, max) { + var pos; + + max = max || buf.length; + if (max > buf.length) { max = buf.length; } + + // go back from last position, until start of sequence found + pos = max - 1; + while (pos >= 0 && (buf[pos] & 0xC0) === 0x80) { pos--; } + + // Very small and broken sequence, + // return max, because we should return something anyway. + if (pos < 0) { return max; } + + // If we came to start of buffer - that means buffer is too small, + // return max too. + if (pos === 0) { return max; } + + return (pos + _utf8len[buf[pos]] > max) ? pos : max; +}; + + +/***/ }), + +/***/ 6069: +/***/ ((module) => { + +"use strict"; + + +// Note: adler32 takes 12% for level 0 and 2% for level 6. +// It isn't worth it to make additional optimizations as in original. +// Small size is preferable. + +// (C) 1995-2013 Jean-loup Gailly and Mark Adler +// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin +// +// This software is provided 'as-is', without any express or implied +// warranty. In no event will the authors be held liable for any damages +// arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it +// freely, subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; you must not +// claim that you wrote the original software. If you use this software +// in a product, an acknowledgment in the product documentation would be +// appreciated but is not required. +// 2. Altered source versions must be plainly marked as such, and must not be +// misrepresented as being the original software. +// 3. This notice may not be removed or altered from any source distribution. + +function adler32(adler, buf, len, pos) { + var s1 = (adler & 0xffff) |0, + s2 = ((adler >>> 16) & 0xffff) |0, + n = 0; + + while (len !== 0) { + // Set limit ~ twice less than 5552, to keep + // s2 in 31-bits, because we force signed ints. + // in other case %= will fail. + n = len > 2000 ? 2000 : len; + len -= n; + + do { + s1 = (s1 + buf[pos++]) |0; + s2 = (s2 + s1) |0; + } while (--n); + + s1 %= 65521; + s2 %= 65521; + } + + return (s1 | (s2 << 16)) |0; +} + + +module.exports = adler32; + + +/***/ }), + +/***/ 1619: +/***/ ((module) => { + +"use strict"; + + +// (C) 1995-2013 Jean-loup Gailly and Mark Adler +// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin +// +// This software is provided 'as-is', without any express or implied +// warranty. In no event will the authors be held liable for any damages +// arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it +// freely, subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; you must not +// claim that you wrote the original software. If you use this software +// in a product, an acknowledgment in the product documentation would be +// appreciated but is not required. +// 2. Altered source versions must be plainly marked as such, and must not be +// misrepresented as being the original software. +// 3. This notice may not be removed or altered from any source distribution. + +module.exports = { + + /* Allowed flush values; see deflate() and inflate() below for details */ + Z_NO_FLUSH: 0, + Z_PARTIAL_FLUSH: 1, + Z_SYNC_FLUSH: 2, + Z_FULL_FLUSH: 3, + Z_FINISH: 4, + Z_BLOCK: 5, + Z_TREES: 6, + + /* Return codes for the compression/decompression functions. Negative values + * are errors, positive values are used for special but normal events. + */ + Z_OK: 0, + Z_STREAM_END: 1, + Z_NEED_DICT: 2, + Z_ERRNO: -1, + Z_STREAM_ERROR: -2, + Z_DATA_ERROR: -3, + //Z_MEM_ERROR: -4, + Z_BUF_ERROR: -5, + //Z_VERSION_ERROR: -6, + + /* compression levels */ + Z_NO_COMPRESSION: 0, + Z_BEST_SPEED: 1, + Z_BEST_COMPRESSION: 9, + Z_DEFAULT_COMPRESSION: -1, + + + Z_FILTERED: 1, + Z_HUFFMAN_ONLY: 2, + Z_RLE: 3, + Z_FIXED: 4, + Z_DEFAULT_STRATEGY: 0, + + /* Possible values of the data_type field (though see inflate()) */ + Z_BINARY: 0, + Z_TEXT: 1, + //Z_ASCII: 1, // = Z_TEXT (deprecated) + Z_UNKNOWN: 2, + + /* The deflate compression method */ + Z_DEFLATED: 8 + //Z_NULL: null // Use -1 or null inline, depending on var type +}; + + +/***/ }), + +/***/ 2869: +/***/ ((module) => { + +"use strict"; + + +// Note: we can't get significant speed boost here. +// So write code to minimize size - no pregenerated tables +// and array tools dependencies. + +// (C) 1995-2013 Jean-loup Gailly and Mark Adler +// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin +// +// This software is provided 'as-is', without any express or implied +// warranty. In no event will the authors be held liable for any damages +// arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it +// freely, subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; you must not +// claim that you wrote the original software. If you use this software +// in a product, an acknowledgment in the product documentation would be +// appreciated but is not required. +// 2. Altered source versions must be plainly marked as such, and must not be +// misrepresented as being the original software. +// 3. This notice may not be removed or altered from any source distribution. + +// Use ordinary array, since untyped makes no boost here +function makeTable() { + var c, table = []; + + for (var n = 0; n < 256; n++) { + c = n; + for (var k = 0; k < 8; k++) { + c = ((c & 1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1)); + } + table[n] = c; + } + + return table; +} + +// Create table on load. Just 255 signed longs. Not a problem. +var crcTable = makeTable(); + + +function crc32(crc, buf, len, pos) { + var t = crcTable, + end = pos + len; + + crc ^= -1; + + for (var i = pos; i < end; i++) { + crc = (crc >>> 8) ^ t[(crc ^ buf[i]) & 0xFF]; + } + + return (crc ^ (-1)); // >>> 0; +} + + +module.exports = crc32; + + +/***/ }), + +/***/ 405: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + + +// (C) 1995-2013 Jean-loup Gailly and Mark Adler +// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin +// +// This software is provided 'as-is', without any express or implied +// warranty. In no event will the authors be held liable for any damages +// arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it +// freely, subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; you must not +// claim that you wrote the original software. If you use this software +// in a product, an acknowledgment in the product documentation would be +// appreciated but is not required. +// 2. Altered source versions must be plainly marked as such, and must not be +// misrepresented as being the original software. +// 3. This notice may not be removed or altered from any source distribution. + +var utils = __webpack_require__(4236); +var trees = __webpack_require__(342); +var adler32 = __webpack_require__(6069); +var crc32 = __webpack_require__(2869); +var msg = __webpack_require__(8898); + +/* Public constants ==========================================================*/ +/* ===========================================================================*/ + + +/* Allowed flush values; see deflate() and inflate() below for details */ +var Z_NO_FLUSH = 0; +var Z_PARTIAL_FLUSH = 1; +//var Z_SYNC_FLUSH = 2; +var Z_FULL_FLUSH = 3; +var Z_FINISH = 4; +var Z_BLOCK = 5; +//var Z_TREES = 6; + + +/* Return codes for the compression/decompression functions. Negative values + * are errors, positive values are used for special but normal events. + */ +var Z_OK = 0; +var Z_STREAM_END = 1; +//var Z_NEED_DICT = 2; +//var Z_ERRNO = -1; +var Z_STREAM_ERROR = -2; +var Z_DATA_ERROR = -3; +//var Z_MEM_ERROR = -4; +var Z_BUF_ERROR = -5; +//var Z_VERSION_ERROR = -6; + + +/* compression levels */ +//var Z_NO_COMPRESSION = 0; +//var Z_BEST_SPEED = 1; +//var Z_BEST_COMPRESSION = 9; +var Z_DEFAULT_COMPRESSION = -1; + + +var Z_FILTERED = 1; +var Z_HUFFMAN_ONLY = 2; +var Z_RLE = 3; +var Z_FIXED = 4; +var Z_DEFAULT_STRATEGY = 0; + +/* Possible values of the data_type field (though see inflate()) */ +//var Z_BINARY = 0; +//var Z_TEXT = 1; +//var Z_ASCII = 1; // = Z_TEXT +var Z_UNKNOWN = 2; + + +/* The deflate compression method */ +var Z_DEFLATED = 8; + +/*============================================================================*/ + + +var MAX_MEM_LEVEL = 9; +/* Maximum value for memLevel in deflateInit2 */ +var MAX_WBITS = 15; +/* 32K LZ77 window */ +var DEF_MEM_LEVEL = 8; + + +var LENGTH_CODES = 29; +/* number of length codes, not counting the special END_BLOCK code */ +var LITERALS = 256; +/* number of literal bytes 0..255 */ +var L_CODES = LITERALS + 1 + LENGTH_CODES; +/* number of Literal or Length codes, including the END_BLOCK code */ +var D_CODES = 30; +/* number of distance codes */ +var BL_CODES = 19; +/* number of codes used to transfer the bit lengths */ +var HEAP_SIZE = 2 * L_CODES + 1; +/* maximum heap size */ +var MAX_BITS = 15; +/* All codes must not exceed MAX_BITS bits */ + +var MIN_MATCH = 3; +var MAX_MATCH = 258; +var MIN_LOOKAHEAD = (MAX_MATCH + MIN_MATCH + 1); + +var PRESET_DICT = 0x20; + +var INIT_STATE = 42; +var EXTRA_STATE = 69; +var NAME_STATE = 73; +var COMMENT_STATE = 91; +var HCRC_STATE = 103; +var BUSY_STATE = 113; +var FINISH_STATE = 666; + +var BS_NEED_MORE = 1; /* block not completed, need more input or more output */ +var BS_BLOCK_DONE = 2; /* block flush performed */ +var BS_FINISH_STARTED = 3; /* finish started, need only more output at next deflate */ +var BS_FINISH_DONE = 4; /* finish done, accept no more input or output */ + +var OS_CODE = 0x03; // Unix :) . Don't detect, use this default. + +function err(strm, errorCode) { + strm.msg = msg[errorCode]; + return errorCode; +} + +function rank(f) { + return ((f) << 1) - ((f) > 4 ? 9 : 0); +} + +function zero(buf) { var len = buf.length; while (--len >= 0) { buf[len] = 0; } } + + +/* ========================================================================= + * Flush as much pending output as possible. All deflate() output goes + * through this function so some applications may wish to modify it + * to avoid allocating a large strm->output buffer and copying into it. + * (See also read_buf()). + */ +function flush_pending(strm) { + var s = strm.state; + + //_tr_flush_bits(s); + var len = s.pending; + if (len > strm.avail_out) { + len = strm.avail_out; + } + if (len === 0) { return; } + + utils.arraySet(strm.output, s.pending_buf, s.pending_out, len, strm.next_out); + strm.next_out += len; + s.pending_out += len; + strm.total_out += len; + strm.avail_out -= len; + s.pending -= len; + if (s.pending === 0) { + s.pending_out = 0; + } +} + + +function flush_block_only(s, last) { + trees._tr_flush_block(s, (s.block_start >= 0 ? s.block_start : -1), s.strstart - s.block_start, last); + s.block_start = s.strstart; + flush_pending(s.strm); +} + + +function put_byte(s, b) { + s.pending_buf[s.pending++] = b; +} + + +/* ========================================================================= + * Put a short in the pending buffer. The 16-bit value is put in MSB order. + * IN assertion: the stream state is correct and there is enough room in + * pending_buf. + */ +function putShortMSB(s, b) { +// put_byte(s, (Byte)(b >> 8)); +// put_byte(s, (Byte)(b & 0xff)); + s.pending_buf[s.pending++] = (b >>> 8) & 0xff; + s.pending_buf[s.pending++] = b & 0xff; +} + + +/* =========================================================================== + * Read a new buffer from the current input stream, update the adler32 + * and total number of bytes read. All deflate() input goes through + * this function so some applications may wish to modify it to avoid + * allocating a large strm->input buffer and copying from it. + * (See also flush_pending()). + */ +function read_buf(strm, buf, start, size) { + var len = strm.avail_in; + + if (len > size) { len = size; } + if (len === 0) { return 0; } + + strm.avail_in -= len; + + // zmemcpy(buf, strm->next_in, len); + utils.arraySet(buf, strm.input, strm.next_in, len, start); + if (strm.state.wrap === 1) { + strm.adler = adler32(strm.adler, buf, len, start); + } + + else if (strm.state.wrap === 2) { + strm.adler = crc32(strm.adler, buf, len, start); + } + + strm.next_in += len; + strm.total_in += len; + + return len; +} + + +/* =========================================================================== + * Set match_start to the longest match starting at the given string and + * return its length. Matches shorter or equal to prev_length are discarded, + * in which case the result is equal to prev_length and match_start is + * garbage. + * IN assertions: cur_match is the head of the hash chain for the current + * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1 + * OUT assertion: the match length is not greater than s->lookahead. + */ +function longest_match(s, cur_match) { + var chain_length = s.max_chain_length; /* max hash chain length */ + var scan = s.strstart; /* current string */ + var match; /* matched string */ + var len; /* length of current match */ + var best_len = s.prev_length; /* best match length so far */ + var nice_match = s.nice_match; /* stop if match long enough */ + var limit = (s.strstart > (s.w_size - MIN_LOOKAHEAD)) ? + s.strstart - (s.w_size - MIN_LOOKAHEAD) : 0/*NIL*/; + + var _win = s.window; // shortcut + + var wmask = s.w_mask; + var prev = s.prev; + + /* Stop when cur_match becomes <= limit. To simplify the code, + * we prevent matches with the string of window index 0. + */ + + var strend = s.strstart + MAX_MATCH; + var scan_end1 = _win[scan + best_len - 1]; + var scan_end = _win[scan + best_len]; + + /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. + * It is easy to get rid of this optimization if necessary. + */ + // Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); + + /* Do not waste too much time if we already have a good match: */ + if (s.prev_length >= s.good_match) { + chain_length >>= 2; + } + /* Do not look for matches beyond the end of the input. This is necessary + * to make deflate deterministic. + */ + if (nice_match > s.lookahead) { nice_match = s.lookahead; } + + // Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); + + do { + // Assert(cur_match < s->strstart, "no future"); + match = cur_match; + + /* Skip to next match if the match length cannot increase + * or if the match length is less than 2. Note that the checks below + * for insufficient lookahead only occur occasionally for performance + * reasons. Therefore uninitialized memory will be accessed, and + * conditional jumps will be made that depend on those values. + * However the length of the match is limited to the lookahead, so + * the output of deflate is not affected by the uninitialized values. + */ + + if (_win[match + best_len] !== scan_end || + _win[match + best_len - 1] !== scan_end1 || + _win[match] !== _win[scan] || + _win[++match] !== _win[scan + 1]) { + continue; + } + + /* The check at best_len-1 can be removed because it will be made + * again later. (This heuristic is not always a win.) + * It is not necessary to compare scan[2] and match[2] since they + * are always equal when the other bytes match, given that + * the hash keys are equal and that HASH_BITS >= 8. + */ + scan += 2; + match++; + // Assert(*scan == *match, "match[2]?"); + + /* We check for insufficient lookahead only every 8th comparison; + * the 256th check will be made at strstart+258. + */ + do { + /*jshint noempty:false*/ + } while (_win[++scan] === _win[++match] && _win[++scan] === _win[++match] && + _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && + _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && + _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && + scan < strend); + + // Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); + + len = MAX_MATCH - (strend - scan); + scan = strend - MAX_MATCH; + + if (len > best_len) { + s.match_start = cur_match; + best_len = len; + if (len >= nice_match) { + break; + } + scan_end1 = _win[scan + best_len - 1]; + scan_end = _win[scan + best_len]; + } + } while ((cur_match = prev[cur_match & wmask]) > limit && --chain_length !== 0); + + if (best_len <= s.lookahead) { + return best_len; + } + return s.lookahead; +} + + +/* =========================================================================== + * Fill the window when the lookahead becomes insufficient. + * Updates strstart and lookahead. + * + * IN assertion: lookahead < MIN_LOOKAHEAD + * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD + * At least one byte has been read, or avail_in == 0; reads are + * performed for at least two bytes (required for the zip translate_eol + * option -- not supported here). + */ +function fill_window(s) { + var _w_size = s.w_size; + var p, n, m, more, str; + + //Assert(s->lookahead < MIN_LOOKAHEAD, "already enough lookahead"); + + do { + more = s.window_size - s.lookahead - s.strstart; + + // JS ints have 32 bit, block below not needed + /* Deal with !@#$% 64K limit: */ + //if (sizeof(int) <= 2) { + // if (more == 0 && s->strstart == 0 && s->lookahead == 0) { + // more = wsize; + // + // } else if (more == (unsigned)(-1)) { + // /* Very unlikely, but possible on 16 bit machine if + // * strstart == 0 && lookahead == 1 (input done a byte at time) + // */ + // more--; + // } + //} + + + /* If the window is almost full and there is insufficient lookahead, + * move the upper half to the lower one to make room in the upper half. + */ + if (s.strstart >= _w_size + (_w_size - MIN_LOOKAHEAD)) { + + utils.arraySet(s.window, s.window, _w_size, _w_size, 0); + s.match_start -= _w_size; + s.strstart -= _w_size; + /* we now have strstart >= MAX_DIST */ + s.block_start -= _w_size; + + /* Slide the hash table (could be avoided with 32 bit values + at the expense of memory usage). We slide even when level == 0 + to keep the hash table consistent if we switch back to level > 0 + later. (Using level 0 permanently is not an optimal usage of + zlib, so we don't care about this pathological case.) + */ + + n = s.hash_size; + p = n; + do { + m = s.head[--p]; + s.head[p] = (m >= _w_size ? m - _w_size : 0); + } while (--n); + + n = _w_size; + p = n; + do { + m = s.prev[--p]; + s.prev[p] = (m >= _w_size ? m - _w_size : 0); + /* If n is not on any hash chain, prev[n] is garbage but + * its value will never be used. + */ + } while (--n); + + more += _w_size; + } + if (s.strm.avail_in === 0) { + break; + } + + /* If there was no sliding: + * strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 && + * more == window_size - lookahead - strstart + * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1) + * => more >= window_size - 2*WSIZE + 2 + * In the BIG_MEM or MMAP case (not yet supported), + * window_size == input_size + MIN_LOOKAHEAD && + * strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD. + * Otherwise, window_size == 2*WSIZE so more >= 2. + * If there was sliding, more >= WSIZE. So in all cases, more >= 2. + */ + //Assert(more >= 2, "more < 2"); + n = read_buf(s.strm, s.window, s.strstart + s.lookahead, more); + s.lookahead += n; + + /* Initialize the hash value now that we have some input: */ + if (s.lookahead + s.insert >= MIN_MATCH) { + str = s.strstart - s.insert; + s.ins_h = s.window[str]; + + /* UPDATE_HASH(s, s->ins_h, s->window[str + 1]); */ + s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[str + 1]) & s.hash_mask; +//#if MIN_MATCH != 3 +// Call update_hash() MIN_MATCH-3 more times +//#endif + while (s.insert) { + /* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */ + s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[str + MIN_MATCH - 1]) & s.hash_mask; + + s.prev[str & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = str; + str++; + s.insert--; + if (s.lookahead + s.insert < MIN_MATCH) { + break; + } + } + } + /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage, + * but this is not important since only literal bytes will be emitted. + */ + + } while (s.lookahead < MIN_LOOKAHEAD && s.strm.avail_in !== 0); + + /* If the WIN_INIT bytes after the end of the current data have never been + * written, then zero those bytes in order to avoid memory check reports of + * the use of uninitialized (or uninitialised as Julian writes) bytes by + * the longest match routines. Update the high water mark for the next + * time through here. WIN_INIT is set to MAX_MATCH since the longest match + * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead. + */ +// if (s.high_water < s.window_size) { +// var curr = s.strstart + s.lookahead; +// var init = 0; +// +// if (s.high_water < curr) { +// /* Previous high water mark below current data -- zero WIN_INIT +// * bytes or up to end of window, whichever is less. +// */ +// init = s.window_size - curr; +// if (init > WIN_INIT) +// init = WIN_INIT; +// zmemzero(s->window + curr, (unsigned)init); +// s->high_water = curr + init; +// } +// else if (s->high_water < (ulg)curr + WIN_INIT) { +// /* High water mark at or above current data, but below current data +// * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up +// * to end of window, whichever is less. +// */ +// init = (ulg)curr + WIN_INIT - s->high_water; +// if (init > s->window_size - s->high_water) +// init = s->window_size - s->high_water; +// zmemzero(s->window + s->high_water, (unsigned)init); +// s->high_water += init; +// } +// } +// +// Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD, +// "not enough room for search"); +} + +/* =========================================================================== + * Copy without compression as much as possible from the input stream, return + * the current block state. + * This function does not insert new strings in the dictionary since + * uncompressible data is probably not useful. This function is used + * only for the level=0 compression option. + * NOTE: this function should be optimized to avoid extra copying from + * window to pending_buf. + */ +function deflate_stored(s, flush) { + /* Stored blocks are limited to 0xffff bytes, pending_buf is limited + * to pending_buf_size, and each stored block has a 5 byte header: + */ + var max_block_size = 0xffff; + + if (max_block_size > s.pending_buf_size - 5) { + max_block_size = s.pending_buf_size - 5; + } + + /* Copy as much as possible from input to output: */ + for (;;) { + /* Fill the window as much as possible: */ + if (s.lookahead <= 1) { + + //Assert(s->strstart < s->w_size+MAX_DIST(s) || + // s->block_start >= (long)s->w_size, "slide too late"); +// if (!(s.strstart < s.w_size + (s.w_size - MIN_LOOKAHEAD) || +// s.block_start >= s.w_size)) { +// throw new Error("slide too late"); +// } + + fill_window(s); + if (s.lookahead === 0 && flush === Z_NO_FLUSH) { + return BS_NEED_MORE; + } + + if (s.lookahead === 0) { + break; + } + /* flush the current block */ + } + //Assert(s->block_start >= 0L, "block gone"); +// if (s.block_start < 0) throw new Error("block gone"); + + s.strstart += s.lookahead; + s.lookahead = 0; + + /* Emit a stored block if pending_buf will be full: */ + var max_start = s.block_start + max_block_size; + + if (s.strstart === 0 || s.strstart >= max_start) { + /* strstart == 0 is possible when wraparound on 16-bit machine */ + s.lookahead = s.strstart - max_start; + s.strstart = max_start; + /*** FLUSH_BLOCK(s, 0); ***/ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + + + } + /* Flush if we may have to slide, otherwise block_start may become + * negative and the data will be gone: + */ + if (s.strstart - s.block_start >= (s.w_size - MIN_LOOKAHEAD)) { + /*** FLUSH_BLOCK(s, 0); ***/ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + } + + s.insert = 0; + + if (flush === Z_FINISH) { + /*** FLUSH_BLOCK(s, 1); ***/ + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + /***/ + return BS_FINISH_DONE; + } + + if (s.strstart > s.block_start) { + /*** FLUSH_BLOCK(s, 0); ***/ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + + return BS_NEED_MORE; +} + +/* =========================================================================== + * Compress as much as possible from the input stream, return the current + * block state. + * This function does not perform lazy evaluation of matches and inserts + * new strings in the dictionary only for unmatched strings or for short + * matches. It is used only for the fast compression options. + */ +function deflate_fast(s, flush) { + var hash_head; /* head of the hash chain */ + var bflush; /* set if current block must be flushed */ + + for (;;) { + /* Make sure that we always have enough lookahead, except + * at the end of the input file. We need MAX_MATCH bytes + * for the next match, plus MIN_MATCH bytes to insert the + * string following the next match. + */ + if (s.lookahead < MIN_LOOKAHEAD) { + fill_window(s); + if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) { + return BS_NEED_MORE; + } + if (s.lookahead === 0) { + break; /* flush the current block */ + } + } + + /* Insert the string window[strstart .. strstart+2] in the + * dictionary, and set hash_head to the head of the hash chain: + */ + hash_head = 0/*NIL*/; + if (s.lookahead >= MIN_MATCH) { + /*** INSERT_STRING(s, s.strstart, hash_head); ***/ + s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask; + hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = s.strstart; + /***/ + } + + /* Find the longest match, discarding those <= prev_length. + * At this point we have always match_length < MIN_MATCH + */ + if (hash_head !== 0/*NIL*/ && ((s.strstart - hash_head) <= (s.w_size - MIN_LOOKAHEAD))) { + /* To simplify the code, we prevent matches with the string + * of window index 0 (in particular we have to avoid a match + * of the string with itself at the start of the input file). + */ + s.match_length = longest_match(s, hash_head); + /* longest_match() sets match_start */ + } + if (s.match_length >= MIN_MATCH) { + // check_match(s, s.strstart, s.match_start, s.match_length); // for debug only + + /*** _tr_tally_dist(s, s.strstart - s.match_start, + s.match_length - MIN_MATCH, bflush); ***/ + bflush = trees._tr_tally(s, s.strstart - s.match_start, s.match_length - MIN_MATCH); + + s.lookahead -= s.match_length; + + /* Insert new strings in the hash table only if the match length + * is not too large. This saves time but degrades compression. + */ + if (s.match_length <= s.max_lazy_match/*max_insert_length*/ && s.lookahead >= MIN_MATCH) { + s.match_length--; /* string at strstart already in table */ + do { + s.strstart++; + /*** INSERT_STRING(s, s.strstart, hash_head); ***/ + s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask; + hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = s.strstart; + /***/ + /* strstart never exceeds WSIZE-MAX_MATCH, so there are + * always MIN_MATCH bytes ahead. + */ + } while (--s.match_length !== 0); + s.strstart++; + } else + { + s.strstart += s.match_length; + s.match_length = 0; + s.ins_h = s.window[s.strstart]; + /* UPDATE_HASH(s, s.ins_h, s.window[s.strstart+1]); */ + s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + 1]) & s.hash_mask; + +//#if MIN_MATCH != 3 +// Call UPDATE_HASH() MIN_MATCH-3 more times +//#endif + /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not + * matter since it will be recomputed at next deflate call. + */ + } + } else { + /* No match, output a literal byte */ + //Tracevv((stderr,"%c", s.window[s.strstart])); + /*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/ + bflush = trees._tr_tally(s, 0, s.window[s.strstart]); + + s.lookahead--; + s.strstart++; + } + if (bflush) { + /*** FLUSH_BLOCK(s, 0); ***/ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + } + s.insert = ((s.strstart < (MIN_MATCH - 1)) ? s.strstart : MIN_MATCH - 1); + if (flush === Z_FINISH) { + /*** FLUSH_BLOCK(s, 1); ***/ + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + /***/ + return BS_FINISH_DONE; + } + if (s.last_lit) { + /*** FLUSH_BLOCK(s, 0); ***/ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + return BS_BLOCK_DONE; +} + +/* =========================================================================== + * Same as above, but achieves better compression. We use a lazy + * evaluation for matches: a match is finally adopted only if there is + * no better match at the next window position. + */ +function deflate_slow(s, flush) { + var hash_head; /* head of hash chain */ + var bflush; /* set if current block must be flushed */ + + var max_insert; + + /* Process the input block. */ + for (;;) { + /* Make sure that we always have enough lookahead, except + * at the end of the input file. We need MAX_MATCH bytes + * for the next match, plus MIN_MATCH bytes to insert the + * string following the next match. + */ + if (s.lookahead < MIN_LOOKAHEAD) { + fill_window(s); + if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) { + return BS_NEED_MORE; + } + if (s.lookahead === 0) { break; } /* flush the current block */ + } + + /* Insert the string window[strstart .. strstart+2] in the + * dictionary, and set hash_head to the head of the hash chain: + */ + hash_head = 0/*NIL*/; + if (s.lookahead >= MIN_MATCH) { + /*** INSERT_STRING(s, s.strstart, hash_head); ***/ + s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask; + hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = s.strstart; + /***/ + } + + /* Find the longest match, discarding those <= prev_length. + */ + s.prev_length = s.match_length; + s.prev_match = s.match_start; + s.match_length = MIN_MATCH - 1; + + if (hash_head !== 0/*NIL*/ && s.prev_length < s.max_lazy_match && + s.strstart - hash_head <= (s.w_size - MIN_LOOKAHEAD)/*MAX_DIST(s)*/) { + /* To simplify the code, we prevent matches with the string + * of window index 0 (in particular we have to avoid a match + * of the string with itself at the start of the input file). + */ + s.match_length = longest_match(s, hash_head); + /* longest_match() sets match_start */ + + if (s.match_length <= 5 && + (s.strategy === Z_FILTERED || (s.match_length === MIN_MATCH && s.strstart - s.match_start > 4096/*TOO_FAR*/))) { + + /* If prev_match is also MIN_MATCH, match_start is garbage + * but we will ignore the current match anyway. + */ + s.match_length = MIN_MATCH - 1; + } + } + /* If there was a match at the previous step and the current + * match is not better, output the previous match: + */ + if (s.prev_length >= MIN_MATCH && s.match_length <= s.prev_length) { + max_insert = s.strstart + s.lookahead - MIN_MATCH; + /* Do not insert strings in hash table beyond this. */ + + //check_match(s, s.strstart-1, s.prev_match, s.prev_length); + + /***_tr_tally_dist(s, s.strstart - 1 - s.prev_match, + s.prev_length - MIN_MATCH, bflush);***/ + bflush = trees._tr_tally(s, s.strstart - 1 - s.prev_match, s.prev_length - MIN_MATCH); + /* Insert in hash table all strings up to the end of the match. + * strstart-1 and strstart are already inserted. If there is not + * enough lookahead, the last two strings are not inserted in + * the hash table. + */ + s.lookahead -= s.prev_length - 1; + s.prev_length -= 2; + do { + if (++s.strstart <= max_insert) { + /*** INSERT_STRING(s, s.strstart, hash_head); ***/ + s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask; + hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = s.strstart; + /***/ + } + } while (--s.prev_length !== 0); + s.match_available = 0; + s.match_length = MIN_MATCH - 1; + s.strstart++; + + if (bflush) { + /*** FLUSH_BLOCK(s, 0); ***/ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + + } else if (s.match_available) { + /* If there was no match at the previous position, output a + * single literal. If there was a match but the current match + * is longer, truncate the previous match to a single literal. + */ + //Tracevv((stderr,"%c", s->window[s->strstart-1])); + /*** _tr_tally_lit(s, s.window[s.strstart-1], bflush); ***/ + bflush = trees._tr_tally(s, 0, s.window[s.strstart - 1]); + + if (bflush) { + /*** FLUSH_BLOCK_ONLY(s, 0) ***/ + flush_block_only(s, false); + /***/ + } + s.strstart++; + s.lookahead--; + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } else { + /* There is no previous match to compare with, wait for + * the next step to decide. + */ + s.match_available = 1; + s.strstart++; + s.lookahead--; + } + } + //Assert (flush != Z_NO_FLUSH, "no flush?"); + if (s.match_available) { + //Tracevv((stderr,"%c", s->window[s->strstart-1])); + /*** _tr_tally_lit(s, s.window[s.strstart-1], bflush); ***/ + bflush = trees._tr_tally(s, 0, s.window[s.strstart - 1]); + + s.match_available = 0; + } + s.insert = s.strstart < MIN_MATCH - 1 ? s.strstart : MIN_MATCH - 1; + if (flush === Z_FINISH) { + /*** FLUSH_BLOCK(s, 1); ***/ + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + /***/ + return BS_FINISH_DONE; + } + if (s.last_lit) { + /*** FLUSH_BLOCK(s, 0); ***/ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + + return BS_BLOCK_DONE; +} + + +/* =========================================================================== + * For Z_RLE, simply look for runs of bytes, generate matches only of distance + * one. Do not maintain a hash table. (It will be regenerated if this run of + * deflate switches away from Z_RLE.) + */ +function deflate_rle(s, flush) { + var bflush; /* set if current block must be flushed */ + var prev; /* byte at distance one to match */ + var scan, strend; /* scan goes up to strend for length of run */ + + var _win = s.window; + + for (;;) { + /* Make sure that we always have enough lookahead, except + * at the end of the input file. We need MAX_MATCH bytes + * for the longest run, plus one for the unrolled loop. + */ + if (s.lookahead <= MAX_MATCH) { + fill_window(s); + if (s.lookahead <= MAX_MATCH && flush === Z_NO_FLUSH) { + return BS_NEED_MORE; + } + if (s.lookahead === 0) { break; } /* flush the current block */ + } + + /* See how many times the previous byte repeats */ + s.match_length = 0; + if (s.lookahead >= MIN_MATCH && s.strstart > 0) { + scan = s.strstart - 1; + prev = _win[scan]; + if (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan]) { + strend = s.strstart + MAX_MATCH; + do { + /*jshint noempty:false*/ + } while (prev === _win[++scan] && prev === _win[++scan] && + prev === _win[++scan] && prev === _win[++scan] && + prev === _win[++scan] && prev === _win[++scan] && + prev === _win[++scan] && prev === _win[++scan] && + scan < strend); + s.match_length = MAX_MATCH - (strend - scan); + if (s.match_length > s.lookahead) { + s.match_length = s.lookahead; + } + } + //Assert(scan <= s->window+(uInt)(s->window_size-1), "wild scan"); + } + + /* Emit match if have run of MIN_MATCH or longer, else emit literal */ + if (s.match_length >= MIN_MATCH) { + //check_match(s, s.strstart, s.strstart - 1, s.match_length); + + /*** _tr_tally_dist(s, 1, s.match_length - MIN_MATCH, bflush); ***/ + bflush = trees._tr_tally(s, 1, s.match_length - MIN_MATCH); + + s.lookahead -= s.match_length; + s.strstart += s.match_length; + s.match_length = 0; + } else { + /* No match, output a literal byte */ + //Tracevv((stderr,"%c", s->window[s->strstart])); + /*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/ + bflush = trees._tr_tally(s, 0, s.window[s.strstart]); + + s.lookahead--; + s.strstart++; + } + if (bflush) { + /*** FLUSH_BLOCK(s, 0); ***/ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + } + s.insert = 0; + if (flush === Z_FINISH) { + /*** FLUSH_BLOCK(s, 1); ***/ + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + /***/ + return BS_FINISH_DONE; + } + if (s.last_lit) { + /*** FLUSH_BLOCK(s, 0); ***/ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + return BS_BLOCK_DONE; +} + +/* =========================================================================== + * For Z_HUFFMAN_ONLY, do not look for matches. Do not maintain a hash table. + * (It will be regenerated if this run of deflate switches away from Huffman.) + */ +function deflate_huff(s, flush) { + var bflush; /* set if current block must be flushed */ + + for (;;) { + /* Make sure that we have a literal to write. */ + if (s.lookahead === 0) { + fill_window(s); + if (s.lookahead === 0) { + if (flush === Z_NO_FLUSH) { + return BS_NEED_MORE; + } + break; /* flush the current block */ + } + } + + /* Output a literal byte */ + s.match_length = 0; + //Tracevv((stderr,"%c", s->window[s->strstart])); + /*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/ + bflush = trees._tr_tally(s, 0, s.window[s.strstart]); + s.lookahead--; + s.strstart++; + if (bflush) { + /*** FLUSH_BLOCK(s, 0); ***/ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + } + s.insert = 0; + if (flush === Z_FINISH) { + /*** FLUSH_BLOCK(s, 1); ***/ + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + /***/ + return BS_FINISH_DONE; + } + if (s.last_lit) { + /*** FLUSH_BLOCK(s, 0); ***/ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + return BS_BLOCK_DONE; +} + +/* Values for max_lazy_match, good_match and max_chain_length, depending on + * the desired pack level (0..9). The values given below have been tuned to + * exclude worst case performance for pathological files. Better values may be + * found for specific files. + */ +function Config(good_length, max_lazy, nice_length, max_chain, func) { + this.good_length = good_length; + this.max_lazy = max_lazy; + this.nice_length = nice_length; + this.max_chain = max_chain; + this.func = func; +} + +var configuration_table; + +configuration_table = [ + /* good lazy nice chain */ + new Config(0, 0, 0, 0, deflate_stored), /* 0 store only */ + new Config(4, 4, 8, 4, deflate_fast), /* 1 max speed, no lazy matches */ + new Config(4, 5, 16, 8, deflate_fast), /* 2 */ + new Config(4, 6, 32, 32, deflate_fast), /* 3 */ + + new Config(4, 4, 16, 16, deflate_slow), /* 4 lazy matches */ + new Config(8, 16, 32, 32, deflate_slow), /* 5 */ + new Config(8, 16, 128, 128, deflate_slow), /* 6 */ + new Config(8, 32, 128, 256, deflate_slow), /* 7 */ + new Config(32, 128, 258, 1024, deflate_slow), /* 8 */ + new Config(32, 258, 258, 4096, deflate_slow) /* 9 max compression */ +]; + + +/* =========================================================================== + * Initialize the "longest match" routines for a new zlib stream + */ +function lm_init(s) { + s.window_size = 2 * s.w_size; + + /*** CLEAR_HASH(s); ***/ + zero(s.head); // Fill with NIL (= 0); + + /* Set the default configuration parameters: + */ + s.max_lazy_match = configuration_table[s.level].max_lazy; + s.good_match = configuration_table[s.level].good_length; + s.nice_match = configuration_table[s.level].nice_length; + s.max_chain_length = configuration_table[s.level].max_chain; + + s.strstart = 0; + s.block_start = 0; + s.lookahead = 0; + s.insert = 0; + s.match_length = s.prev_length = MIN_MATCH - 1; + s.match_available = 0; + s.ins_h = 0; +} + + +function DeflateState() { + this.strm = null; /* pointer back to this zlib stream */ + this.status = 0; /* as the name implies */ + this.pending_buf = null; /* output still pending */ + this.pending_buf_size = 0; /* size of pending_buf */ + this.pending_out = 0; /* next pending byte to output to the stream */ + this.pending = 0; /* nb of bytes in the pending buffer */ + this.wrap = 0; /* bit 0 true for zlib, bit 1 true for gzip */ + this.gzhead = null; /* gzip header information to write */ + this.gzindex = 0; /* where in extra, name, or comment */ + this.method = Z_DEFLATED; /* can only be DEFLATED */ + this.last_flush = -1; /* value of flush param for previous deflate call */ + + this.w_size = 0; /* LZ77 window size (32K by default) */ + this.w_bits = 0; /* log2(w_size) (8..16) */ + this.w_mask = 0; /* w_size - 1 */ + + this.window = null; + /* Sliding window. Input bytes are read into the second half of the window, + * and move to the first half later to keep a dictionary of at least wSize + * bytes. With this organization, matches are limited to a distance of + * wSize-MAX_MATCH bytes, but this ensures that IO is always + * performed with a length multiple of the block size. + */ + + this.window_size = 0; + /* Actual size of window: 2*wSize, except when the user input buffer + * is directly used as sliding window. + */ + + this.prev = null; + /* Link to older string with same hash index. To limit the size of this + * array to 64K, this link is maintained only for the last 32K strings. + * An index in this array is thus a window index modulo 32K. + */ + + this.head = null; /* Heads of the hash chains or NIL. */ + + this.ins_h = 0; /* hash index of string to be inserted */ + this.hash_size = 0; /* number of elements in hash table */ + this.hash_bits = 0; /* log2(hash_size) */ + this.hash_mask = 0; /* hash_size-1 */ + + this.hash_shift = 0; + /* Number of bits by which ins_h must be shifted at each input + * step. It must be such that after MIN_MATCH steps, the oldest + * byte no longer takes part in the hash key, that is: + * hash_shift * MIN_MATCH >= hash_bits + */ + + this.block_start = 0; + /* Window position at the beginning of the current output block. Gets + * negative when the window is moved backwards. + */ + + this.match_length = 0; /* length of best match */ + this.prev_match = 0; /* previous match */ + this.match_available = 0; /* set if previous match exists */ + this.strstart = 0; /* start of string to insert */ + this.match_start = 0; /* start of matching string */ + this.lookahead = 0; /* number of valid bytes ahead in window */ + + this.prev_length = 0; + /* Length of the best match at previous step. Matches not greater than this + * are discarded. This is used in the lazy match evaluation. + */ + + this.max_chain_length = 0; + /* To speed up deflation, hash chains are never searched beyond this + * length. A higher limit improves compression ratio but degrades the + * speed. + */ + + this.max_lazy_match = 0; + /* Attempt to find a better match only when the current match is strictly + * smaller than this value. This mechanism is used only for compression + * levels >= 4. + */ + // That's alias to max_lazy_match, don't use directly + //this.max_insert_length = 0; + /* Insert new strings in the hash table only if the match length is not + * greater than this length. This saves time but degrades compression. + * max_insert_length is used only for compression levels <= 3. + */ + + this.level = 0; /* compression level (1..9) */ + this.strategy = 0; /* favor or force Huffman coding*/ + + this.good_match = 0; + /* Use a faster search when the previous match is longer than this */ + + this.nice_match = 0; /* Stop searching when current match exceeds this */ + + /* used by trees.c: */ + + /* Didn't use ct_data typedef below to suppress compiler warning */ + + // struct ct_data_s dyn_ltree[HEAP_SIZE]; /* literal and length tree */ + // struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */ + // struct ct_data_s bl_tree[2*BL_CODES+1]; /* Huffman tree for bit lengths */ + + // Use flat array of DOUBLE size, with interleaved fata, + // because JS does not support effective + this.dyn_ltree = new utils.Buf16(HEAP_SIZE * 2); + this.dyn_dtree = new utils.Buf16((2 * D_CODES + 1) * 2); + this.bl_tree = new utils.Buf16((2 * BL_CODES + 1) * 2); + zero(this.dyn_ltree); + zero(this.dyn_dtree); + zero(this.bl_tree); + + this.l_desc = null; /* desc. for literal tree */ + this.d_desc = null; /* desc. for distance tree */ + this.bl_desc = null; /* desc. for bit length tree */ + + //ush bl_count[MAX_BITS+1]; + this.bl_count = new utils.Buf16(MAX_BITS + 1); + /* number of codes at each bit length for an optimal tree */ + + //int heap[2*L_CODES+1]; /* heap used to build the Huffman trees */ + this.heap = new utils.Buf16(2 * L_CODES + 1); /* heap used to build the Huffman trees */ + zero(this.heap); + + this.heap_len = 0; /* number of elements in the heap */ + this.heap_max = 0; /* element of largest frequency */ + /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used. + * The same heap array is used to build all trees. + */ + + this.depth = new utils.Buf16(2 * L_CODES + 1); //uch depth[2*L_CODES+1]; + zero(this.depth); + /* Depth of each subtree used as tie breaker for trees of equal frequency + */ + + this.l_buf = 0; /* buffer index for literals or lengths */ + + this.lit_bufsize = 0; + /* Size of match buffer for literals/lengths. There are 4 reasons for + * limiting lit_bufsize to 64K: + * - frequencies can be kept in 16 bit counters + * - if compression is not successful for the first block, all input + * data is still in the window so we can still emit a stored block even + * when input comes from standard input. (This can also be done for + * all blocks if lit_bufsize is not greater than 32K.) + * - if compression is not successful for a file smaller than 64K, we can + * even emit a stored file instead of a stored block (saving 5 bytes). + * This is applicable only for zip (not gzip or zlib). + * - creating new Huffman trees less frequently may not provide fast + * adaptation to changes in the input data statistics. (Take for + * example a binary file with poorly compressible code followed by + * a highly compressible string table.) Smaller buffer sizes give + * fast adaptation but have of course the overhead of transmitting + * trees more frequently. + * - I can't count above 4 + */ + + this.last_lit = 0; /* running index in l_buf */ + + this.d_buf = 0; + /* Buffer index for distances. To simplify the code, d_buf and l_buf have + * the same number of elements. To use different lengths, an extra flag + * array would be necessary. + */ + + this.opt_len = 0; /* bit length of current block with optimal trees */ + this.static_len = 0; /* bit length of current block with static trees */ + this.matches = 0; /* number of string matches in current block */ + this.insert = 0; /* bytes at end of window left to insert */ + + + this.bi_buf = 0; + /* Output buffer. bits are inserted starting at the bottom (least + * significant bits). + */ + this.bi_valid = 0; + /* Number of valid bits in bi_buf. All bits above the last valid bit + * are always zero. + */ + + // Used for window memory init. We safely ignore it for JS. That makes + // sense only for pointers and memory check tools. + //this.high_water = 0; + /* High water mark offset in window for initialized bytes -- bytes above + * this are set to zero in order to avoid memory check warnings when + * longest match routines access bytes past the input. This is then + * updated to the new high water mark. + */ +} + + +function deflateResetKeep(strm) { + var s; + + if (!strm || !strm.state) { + return err(strm, Z_STREAM_ERROR); + } + + strm.total_in = strm.total_out = 0; + strm.data_type = Z_UNKNOWN; + + s = strm.state; + s.pending = 0; + s.pending_out = 0; + + if (s.wrap < 0) { + s.wrap = -s.wrap; + /* was made negative by deflate(..., Z_FINISH); */ + } + s.status = (s.wrap ? INIT_STATE : BUSY_STATE); + strm.adler = (s.wrap === 2) ? + 0 // crc32(0, Z_NULL, 0) + : + 1; // adler32(0, Z_NULL, 0) + s.last_flush = Z_NO_FLUSH; + trees._tr_init(s); + return Z_OK; +} + + +function deflateReset(strm) { + var ret = deflateResetKeep(strm); + if (ret === Z_OK) { + lm_init(strm.state); + } + return ret; +} + + +function deflateSetHeader(strm, head) { + if (!strm || !strm.state) { return Z_STREAM_ERROR; } + if (strm.state.wrap !== 2) { return Z_STREAM_ERROR; } + strm.state.gzhead = head; + return Z_OK; +} + + +function deflateInit2(strm, level, method, windowBits, memLevel, strategy) { + if (!strm) { // === Z_NULL + return Z_STREAM_ERROR; + } + var wrap = 1; + + if (level === Z_DEFAULT_COMPRESSION) { + level = 6; + } + + if (windowBits < 0) { /* suppress zlib wrapper */ + wrap = 0; + windowBits = -windowBits; + } + + else if (windowBits > 15) { + wrap = 2; /* write gzip wrapper instead */ + windowBits -= 16; + } + + + if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method !== Z_DEFLATED || + windowBits < 8 || windowBits > 15 || level < 0 || level > 9 || + strategy < 0 || strategy > Z_FIXED) { + return err(strm, Z_STREAM_ERROR); + } + + + if (windowBits === 8) { + windowBits = 9; + } + /* until 256-byte window bug fixed */ + + var s = new DeflateState(); + + strm.state = s; + s.strm = strm; + + s.wrap = wrap; + s.gzhead = null; + s.w_bits = windowBits; + s.w_size = 1 << s.w_bits; + s.w_mask = s.w_size - 1; + + s.hash_bits = memLevel + 7; + s.hash_size = 1 << s.hash_bits; + s.hash_mask = s.hash_size - 1; + s.hash_shift = ~~((s.hash_bits + MIN_MATCH - 1) / MIN_MATCH); + + s.window = new utils.Buf8(s.w_size * 2); + s.head = new utils.Buf16(s.hash_size); + s.prev = new utils.Buf16(s.w_size); + + // Don't need mem init magic for JS. + //s.high_water = 0; /* nothing written to s->window yet */ + + s.lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */ + + s.pending_buf_size = s.lit_bufsize * 4; + + //overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2); + //s->pending_buf = (uchf *) overlay; + s.pending_buf = new utils.Buf8(s.pending_buf_size); + + // It is offset from `s.pending_buf` (size is `s.lit_bufsize * 2`) + //s->d_buf = overlay + s->lit_bufsize/sizeof(ush); + s.d_buf = 1 * s.lit_bufsize; + + //s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize; + s.l_buf = (1 + 2) * s.lit_bufsize; + + s.level = level; + s.strategy = strategy; + s.method = method; + + return deflateReset(strm); +} + +function deflateInit(strm, level) { + return deflateInit2(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY); +} + + +function deflate(strm, flush) { + var old_flush, s; + var beg, val; // for gzip header write only + + if (!strm || !strm.state || + flush > Z_BLOCK || flush < 0) { + return strm ? err(strm, Z_STREAM_ERROR) : Z_STREAM_ERROR; + } + + s = strm.state; + + if (!strm.output || + (!strm.input && strm.avail_in !== 0) || + (s.status === FINISH_STATE && flush !== Z_FINISH)) { + return err(strm, (strm.avail_out === 0) ? Z_BUF_ERROR : Z_STREAM_ERROR); + } + + s.strm = strm; /* just in case */ + old_flush = s.last_flush; + s.last_flush = flush; + + /* Write the header */ + if (s.status === INIT_STATE) { + + if (s.wrap === 2) { // GZIP header + strm.adler = 0; //crc32(0L, Z_NULL, 0); + put_byte(s, 31); + put_byte(s, 139); + put_byte(s, 8); + if (!s.gzhead) { // s->gzhead == Z_NULL + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, s.level === 9 ? 2 : + (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? + 4 : 0)); + put_byte(s, OS_CODE); + s.status = BUSY_STATE; + } + else { + put_byte(s, (s.gzhead.text ? 1 : 0) + + (s.gzhead.hcrc ? 2 : 0) + + (!s.gzhead.extra ? 0 : 4) + + (!s.gzhead.name ? 0 : 8) + + (!s.gzhead.comment ? 0 : 16) + ); + put_byte(s, s.gzhead.time & 0xff); + put_byte(s, (s.gzhead.time >> 8) & 0xff); + put_byte(s, (s.gzhead.time >> 16) & 0xff); + put_byte(s, (s.gzhead.time >> 24) & 0xff); + put_byte(s, s.level === 9 ? 2 : + (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? + 4 : 0)); + put_byte(s, s.gzhead.os & 0xff); + if (s.gzhead.extra && s.gzhead.extra.length) { + put_byte(s, s.gzhead.extra.length & 0xff); + put_byte(s, (s.gzhead.extra.length >> 8) & 0xff); + } + if (s.gzhead.hcrc) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending, 0); + } + s.gzindex = 0; + s.status = EXTRA_STATE; + } + } + else // DEFLATE header + { + var header = (Z_DEFLATED + ((s.w_bits - 8) << 4)) << 8; + var level_flags = -1; + + if (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2) { + level_flags = 0; + } else if (s.level < 6) { + level_flags = 1; + } else if (s.level === 6) { + level_flags = 2; + } else { + level_flags = 3; + } + header |= (level_flags << 6); + if (s.strstart !== 0) { header |= PRESET_DICT; } + header += 31 - (header % 31); + + s.status = BUSY_STATE; + putShortMSB(s, header); + + /* Save the adler32 of the preset dictionary: */ + if (s.strstart !== 0) { + putShortMSB(s, strm.adler >>> 16); + putShortMSB(s, strm.adler & 0xffff); + } + strm.adler = 1; // adler32(0L, Z_NULL, 0); + } + } + +//#ifdef GZIP + if (s.status === EXTRA_STATE) { + if (s.gzhead.extra/* != Z_NULL*/) { + beg = s.pending; /* start of bytes to update crc */ + + while (s.gzindex < (s.gzhead.extra.length & 0xffff)) { + if (s.pending === s.pending_buf_size) { + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); + } + flush_pending(strm); + beg = s.pending; + if (s.pending === s.pending_buf_size) { + break; + } + } + put_byte(s, s.gzhead.extra[s.gzindex] & 0xff); + s.gzindex++; + } + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); + } + if (s.gzindex === s.gzhead.extra.length) { + s.gzindex = 0; + s.status = NAME_STATE; + } + } + else { + s.status = NAME_STATE; + } + } + if (s.status === NAME_STATE) { + if (s.gzhead.name/* != Z_NULL*/) { + beg = s.pending; /* start of bytes to update crc */ + //int val; + + do { + if (s.pending === s.pending_buf_size) { + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); + } + flush_pending(strm); + beg = s.pending; + if (s.pending === s.pending_buf_size) { + val = 1; + break; + } + } + // JS specific: little magic to add zero terminator to end of string + if (s.gzindex < s.gzhead.name.length) { + val = s.gzhead.name.charCodeAt(s.gzindex++) & 0xff; + } else { + val = 0; + } + put_byte(s, val); + } while (val !== 0); + + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); + } + if (val === 0) { + s.gzindex = 0; + s.status = COMMENT_STATE; + } + } + else { + s.status = COMMENT_STATE; + } + } + if (s.status === COMMENT_STATE) { + if (s.gzhead.comment/* != Z_NULL*/) { + beg = s.pending; /* start of bytes to update crc */ + //int val; + + do { + if (s.pending === s.pending_buf_size) { + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); + } + flush_pending(strm); + beg = s.pending; + if (s.pending === s.pending_buf_size) { + val = 1; + break; + } + } + // JS specific: little magic to add zero terminator to end of string + if (s.gzindex < s.gzhead.comment.length) { + val = s.gzhead.comment.charCodeAt(s.gzindex++) & 0xff; + } else { + val = 0; + } + put_byte(s, val); + } while (val !== 0); + + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); + } + if (val === 0) { + s.status = HCRC_STATE; + } + } + else { + s.status = HCRC_STATE; + } + } + if (s.status === HCRC_STATE) { + if (s.gzhead.hcrc) { + if (s.pending + 2 > s.pending_buf_size) { + flush_pending(strm); + } + if (s.pending + 2 <= s.pending_buf_size) { + put_byte(s, strm.adler & 0xff); + put_byte(s, (strm.adler >> 8) & 0xff); + strm.adler = 0; //crc32(0L, Z_NULL, 0); + s.status = BUSY_STATE; + } + } + else { + s.status = BUSY_STATE; + } + } +//#endif + + /* Flush as much pending output as possible */ + if (s.pending !== 0) { + flush_pending(strm); + if (strm.avail_out === 0) { + /* Since avail_out is 0, deflate will be called again with + * more output space, but possibly with both pending and + * avail_in equal to zero. There won't be anything to do, + * but this is not an error situation so make sure we + * return OK instead of BUF_ERROR at next call of deflate: + */ + s.last_flush = -1; + return Z_OK; + } + + /* Make sure there is something to do and avoid duplicate consecutive + * flushes. For repeated and useless calls with Z_FINISH, we keep + * returning Z_STREAM_END instead of Z_BUF_ERROR. + */ + } else if (strm.avail_in === 0 && rank(flush) <= rank(old_flush) && + flush !== Z_FINISH) { + return err(strm, Z_BUF_ERROR); + } + + /* User must not provide more input after the first FINISH: */ + if (s.status === FINISH_STATE && strm.avail_in !== 0) { + return err(strm, Z_BUF_ERROR); + } + + /* Start a new block or continue the current one. + */ + if (strm.avail_in !== 0 || s.lookahead !== 0 || + (flush !== Z_NO_FLUSH && s.status !== FINISH_STATE)) { + var bstate = (s.strategy === Z_HUFFMAN_ONLY) ? deflate_huff(s, flush) : + (s.strategy === Z_RLE ? deflate_rle(s, flush) : + configuration_table[s.level].func(s, flush)); + + if (bstate === BS_FINISH_STARTED || bstate === BS_FINISH_DONE) { + s.status = FINISH_STATE; + } + if (bstate === BS_NEED_MORE || bstate === BS_FINISH_STARTED) { + if (strm.avail_out === 0) { + s.last_flush = -1; + /* avoid BUF_ERROR next call, see above */ + } + return Z_OK; + /* If flush != Z_NO_FLUSH && avail_out == 0, the next call + * of deflate should use the same flush parameter to make sure + * that the flush is complete. So we don't have to output an + * empty block here, this will be done at next call. This also + * ensures that for a very small output buffer, we emit at most + * one empty block. + */ + } + if (bstate === BS_BLOCK_DONE) { + if (flush === Z_PARTIAL_FLUSH) { + trees._tr_align(s); + } + else if (flush !== Z_BLOCK) { /* FULL_FLUSH or SYNC_FLUSH */ + + trees._tr_stored_block(s, 0, 0, false); + /* For a full flush, this empty block will be recognized + * as a special marker by inflate_sync(). + */ + if (flush === Z_FULL_FLUSH) { + /*** CLEAR_HASH(s); ***/ /* forget history */ + zero(s.head); // Fill with NIL (= 0); + + if (s.lookahead === 0) { + s.strstart = 0; + s.block_start = 0; + s.insert = 0; + } + } + } + flush_pending(strm); + if (strm.avail_out === 0) { + s.last_flush = -1; /* avoid BUF_ERROR at next call, see above */ + return Z_OK; + } + } + } + //Assert(strm->avail_out > 0, "bug2"); + //if (strm.avail_out <= 0) { throw new Error("bug2");} + + if (flush !== Z_FINISH) { return Z_OK; } + if (s.wrap <= 0) { return Z_STREAM_END; } + + /* Write the trailer */ + if (s.wrap === 2) { + put_byte(s, strm.adler & 0xff); + put_byte(s, (strm.adler >> 8) & 0xff); + put_byte(s, (strm.adler >> 16) & 0xff); + put_byte(s, (strm.adler >> 24) & 0xff); + put_byte(s, strm.total_in & 0xff); + put_byte(s, (strm.total_in >> 8) & 0xff); + put_byte(s, (strm.total_in >> 16) & 0xff); + put_byte(s, (strm.total_in >> 24) & 0xff); + } + else + { + putShortMSB(s, strm.adler >>> 16); + putShortMSB(s, strm.adler & 0xffff); + } + + flush_pending(strm); + /* If avail_out is zero, the application will call deflate again + * to flush the rest. + */ + if (s.wrap > 0) { s.wrap = -s.wrap; } + /* write the trailer only once! */ + return s.pending !== 0 ? Z_OK : Z_STREAM_END; +} + +function deflateEnd(strm) { + var status; + + if (!strm/*== Z_NULL*/ || !strm.state/*== Z_NULL*/) { + return Z_STREAM_ERROR; + } + + status = strm.state.status; + if (status !== INIT_STATE && + status !== EXTRA_STATE && + status !== NAME_STATE && + status !== COMMENT_STATE && + status !== HCRC_STATE && + status !== BUSY_STATE && + status !== FINISH_STATE + ) { + return err(strm, Z_STREAM_ERROR); + } + + strm.state = null; + + return status === BUSY_STATE ? err(strm, Z_DATA_ERROR) : Z_OK; +} + + +/* ========================================================================= + * Initializes the compression dictionary from the given byte + * sequence without producing any compressed output. + */ +function deflateSetDictionary(strm, dictionary) { + var dictLength = dictionary.length; + + var s; + var str, n; + var wrap; + var avail; + var next; + var input; + var tmpDict; + + if (!strm/*== Z_NULL*/ || !strm.state/*== Z_NULL*/) { + return Z_STREAM_ERROR; + } + + s = strm.state; + wrap = s.wrap; + + if (wrap === 2 || (wrap === 1 && s.status !== INIT_STATE) || s.lookahead) { + return Z_STREAM_ERROR; + } + + /* when using zlib wrappers, compute Adler-32 for provided dictionary */ + if (wrap === 1) { + /* adler32(strm->adler, dictionary, dictLength); */ + strm.adler = adler32(strm.adler, dictionary, dictLength, 0); + } + + s.wrap = 0; /* avoid computing Adler-32 in read_buf */ + + /* if dictionary would fill window, just replace the history */ + if (dictLength >= s.w_size) { + if (wrap === 0) { /* already empty otherwise */ + /*** CLEAR_HASH(s); ***/ + zero(s.head); // Fill with NIL (= 0); + s.strstart = 0; + s.block_start = 0; + s.insert = 0; + } + /* use the tail */ + // dictionary = dictionary.slice(dictLength - s.w_size); + tmpDict = new utils.Buf8(s.w_size); + utils.arraySet(tmpDict, dictionary, dictLength - s.w_size, s.w_size, 0); + dictionary = tmpDict; + dictLength = s.w_size; + } + /* insert dictionary into window and hash */ + avail = strm.avail_in; + next = strm.next_in; + input = strm.input; + strm.avail_in = dictLength; + strm.next_in = 0; + strm.input = dictionary; + fill_window(s); + while (s.lookahead >= MIN_MATCH) { + str = s.strstart; + n = s.lookahead - (MIN_MATCH - 1); + do { + /* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */ + s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[str + MIN_MATCH - 1]) & s.hash_mask; + + s.prev[str & s.w_mask] = s.head[s.ins_h]; + + s.head[s.ins_h] = str; + str++; + } while (--n); + s.strstart = str; + s.lookahead = MIN_MATCH - 1; + fill_window(s); + } + s.strstart += s.lookahead; + s.block_start = s.strstart; + s.insert = s.lookahead; + s.lookahead = 0; + s.match_length = s.prev_length = MIN_MATCH - 1; + s.match_available = 0; + strm.next_in = next; + strm.input = input; + strm.avail_in = avail; + s.wrap = wrap; + return Z_OK; +} + + +exports.deflateInit = deflateInit; +exports.deflateInit2 = deflateInit2; +exports.deflateReset = deflateReset; +exports.deflateResetKeep = deflateResetKeep; +exports.deflateSetHeader = deflateSetHeader; +exports.deflate = deflate; +exports.deflateEnd = deflateEnd; +exports.deflateSetDictionary = deflateSetDictionary; +exports.deflateInfo = 'pako deflate (from Nodeca project)'; + +/* Not implemented +exports.deflateBound = deflateBound; +exports.deflateCopy = deflateCopy; +exports.deflateParams = deflateParams; +exports.deflatePending = deflatePending; +exports.deflatePrime = deflatePrime; +exports.deflateTune = deflateTune; +*/ + + +/***/ }), + +/***/ 2401: +/***/ ((module) => { + +"use strict"; + + +// (C) 1995-2013 Jean-loup Gailly and Mark Adler +// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin +// +// This software is provided 'as-is', without any express or implied +// warranty. In no event will the authors be held liable for any damages +// arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it +// freely, subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; you must not +// claim that you wrote the original software. If you use this software +// in a product, an acknowledgment in the product documentation would be +// appreciated but is not required. +// 2. Altered source versions must be plainly marked as such, and must not be +// misrepresented as being the original software. +// 3. This notice may not be removed or altered from any source distribution. + +function GZheader() { + /* true if compressed data believed to be text */ + this.text = 0; + /* modification time */ + this.time = 0; + /* extra flags (not used when writing a gzip file) */ + this.xflags = 0; + /* operating system */ + this.os = 0; + /* pointer to extra field or Z_NULL if none */ + this.extra = null; + /* extra field length (valid if extra != Z_NULL) */ + this.extra_len = 0; // Actually, we don't need it in JS, + // but leave for few code modifications + + // + // Setup limits is not necessary because in js we should not preallocate memory + // for inflate use constant limit in 65536 bytes + // + + /* space at extra (only when reading header) */ + // this.extra_max = 0; + /* pointer to zero-terminated file name or Z_NULL */ + this.name = ''; + /* space at name (only when reading header) */ + // this.name_max = 0; + /* pointer to zero-terminated comment or Z_NULL */ + this.comment = ''; + /* space at comment (only when reading header) */ + // this.comm_max = 0; + /* true if there was or will be a header crc */ + this.hcrc = 0; + /* true when done reading gzip header (not used when writing a gzip file) */ + this.done = false; +} + +module.exports = GZheader; + + +/***/ }), + +/***/ 4264: +/***/ ((module) => { + +"use strict"; + + +// (C) 1995-2013 Jean-loup Gailly and Mark Adler +// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin +// +// This software is provided 'as-is', without any express or implied +// warranty. In no event will the authors be held liable for any damages +// arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it +// freely, subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; you must not +// claim that you wrote the original software. If you use this software +// in a product, an acknowledgment in the product documentation would be +// appreciated but is not required. +// 2. Altered source versions must be plainly marked as such, and must not be +// misrepresented as being the original software. +// 3. This notice may not be removed or altered from any source distribution. + +// See state defs from inflate.js +var BAD = 30; /* got a data error -- remain here until reset */ +var TYPE = 12; /* i: waiting for type bits, including last-flag bit */ + +/* + Decode literal, length, and distance codes and write out the resulting + literal and match bytes until either not enough input or output is + available, an end-of-block is encountered, or a data error is encountered. + When large enough input and output buffers are supplied to inflate(), for + example, a 16K input buffer and a 64K output buffer, more than 95% of the + inflate execution time is spent in this routine. + + Entry assumptions: + + state.mode === LEN + strm.avail_in >= 6 + strm.avail_out >= 258 + start >= strm.avail_out + state.bits < 8 + + On return, state.mode is one of: + + LEN -- ran out of enough output space or enough available input + TYPE -- reached end of block code, inflate() to interpret next block + BAD -- error in block data + + Notes: + + - The maximum input bits used by a length/distance pair is 15 bits for the + length code, 5 bits for the length extra, 15 bits for the distance code, + and 13 bits for the distance extra. This totals 48 bits, or six bytes. + Therefore if strm.avail_in >= 6, then there is enough input to avoid + checking for available input while decoding. + + - The maximum bytes that a single length/distance pair can output is 258 + bytes, which is the maximum length that can be coded. inflate_fast() + requires strm.avail_out >= 258 for each loop to avoid checking for + output space. + */ +module.exports = function inflate_fast(strm, start) { + var state; + var _in; /* local strm.input */ + var last; /* have enough input while in < last */ + var _out; /* local strm.output */ + var beg; /* inflate()'s initial strm.output */ + var end; /* while out < end, enough space available */ +//#ifdef INFLATE_STRICT + var dmax; /* maximum distance from zlib header */ +//#endif + var wsize; /* window size or zero if not using window */ + var whave; /* valid bytes in the window */ + var wnext; /* window write index */ + // Use `s_window` instead `window`, avoid conflict with instrumentation tools + var s_window; /* allocated sliding window, if wsize != 0 */ + var hold; /* local strm.hold */ + var bits; /* local strm.bits */ + var lcode; /* local strm.lencode */ + var dcode; /* local strm.distcode */ + var lmask; /* mask for first level of length codes */ + var dmask; /* mask for first level of distance codes */ + var here; /* retrieved table entry */ + var op; /* code bits, operation, extra bits, or */ + /* window position, window bytes to copy */ + var len; /* match length, unused bytes */ + var dist; /* match distance */ + var from; /* where to copy match from */ + var from_source; + + + var input, output; // JS specific, because we have no pointers + + /* copy state to local variables */ + state = strm.state; + //here = state.here; + _in = strm.next_in; + input = strm.input; + last = _in + (strm.avail_in - 5); + _out = strm.next_out; + output = strm.output; + beg = _out - (start - strm.avail_out); + end = _out + (strm.avail_out - 257); +//#ifdef INFLATE_STRICT + dmax = state.dmax; +//#endif + wsize = state.wsize; + whave = state.whave; + wnext = state.wnext; + s_window = state.window; + hold = state.hold; + bits = state.bits; + lcode = state.lencode; + dcode = state.distcode; + lmask = (1 << state.lenbits) - 1; + dmask = (1 << state.distbits) - 1; + + + /* decode literals and length/distances until end-of-block or not enough + input data or output space */ + + top: + do { + if (bits < 15) { + hold += input[_in++] << bits; + bits += 8; + hold += input[_in++] << bits; + bits += 8; + } + + here = lcode[hold & lmask]; + + dolen: + for (;;) { // Goto emulation + op = here >>> 24/*here.bits*/; + hold >>>= op; + bits -= op; + op = (here >>> 16) & 0xff/*here.op*/; + if (op === 0) { /* literal */ + //Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? + // "inflate: literal '%c'\n" : + // "inflate: literal 0x%02x\n", here.val)); + output[_out++] = here & 0xffff/*here.val*/; + } + else if (op & 16) { /* length base */ + len = here & 0xffff/*here.val*/; + op &= 15; /* number of extra bits */ + if (op) { + if (bits < op) { + hold += input[_in++] << bits; + bits += 8; + } + len += hold & ((1 << op) - 1); + hold >>>= op; + bits -= op; + } + //Tracevv((stderr, "inflate: length %u\n", len)); + if (bits < 15) { + hold += input[_in++] << bits; + bits += 8; + hold += input[_in++] << bits; + bits += 8; + } + here = dcode[hold & dmask]; + + dodist: + for (;;) { // goto emulation + op = here >>> 24/*here.bits*/; + hold >>>= op; + bits -= op; + op = (here >>> 16) & 0xff/*here.op*/; + + if (op & 16) { /* distance base */ + dist = here & 0xffff/*here.val*/; + op &= 15; /* number of extra bits */ + if (bits < op) { + hold += input[_in++] << bits; + bits += 8; + if (bits < op) { + hold += input[_in++] << bits; + bits += 8; + } + } + dist += hold & ((1 << op) - 1); +//#ifdef INFLATE_STRICT + if (dist > dmax) { + strm.msg = 'invalid distance too far back'; + state.mode = BAD; + break top; + } +//#endif + hold >>>= op; + bits -= op; + //Tracevv((stderr, "inflate: distance %u\n", dist)); + op = _out - beg; /* max distance in output */ + if (dist > op) { /* see if copy from window */ + op = dist - op; /* distance back in window */ + if (op > whave) { + if (state.sane) { + strm.msg = 'invalid distance too far back'; + state.mode = BAD; + break top; + } + +// (!) This block is disabled in zlib defaults, +// don't enable it for binary compatibility +//#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR +// if (len <= op - whave) { +// do { +// output[_out++] = 0; +// } while (--len); +// continue top; +// } +// len -= op - whave; +// do { +// output[_out++] = 0; +// } while (--op > whave); +// if (op === 0) { +// from = _out - dist; +// do { +// output[_out++] = output[from++]; +// } while (--len); +// continue top; +// } +//#endif + } + from = 0; // window index + from_source = s_window; + if (wnext === 0) { /* very common case */ + from += wsize - op; + if (op < len) { /* some from window */ + len -= op; + do { + output[_out++] = s_window[from++]; + } while (--op); + from = _out - dist; /* rest from output */ + from_source = output; + } + } + else if (wnext < op) { /* wrap around window */ + from += wsize + wnext - op; + op -= wnext; + if (op < len) { /* some from end of window */ + len -= op; + do { + output[_out++] = s_window[from++]; + } while (--op); + from = 0; + if (wnext < len) { /* some from start of window */ + op = wnext; + len -= op; + do { + output[_out++] = s_window[from++]; + } while (--op); + from = _out - dist; /* rest from output */ + from_source = output; + } + } + } + else { /* contiguous in window */ + from += wnext - op; + if (op < len) { /* some from window */ + len -= op; + do { + output[_out++] = s_window[from++]; + } while (--op); + from = _out - dist; /* rest from output */ + from_source = output; + } + } + while (len > 2) { + output[_out++] = from_source[from++]; + output[_out++] = from_source[from++]; + output[_out++] = from_source[from++]; + len -= 3; + } + if (len) { + output[_out++] = from_source[from++]; + if (len > 1) { + output[_out++] = from_source[from++]; + } + } + } + else { + from = _out - dist; /* copy direct from output */ + do { /* minimum length is three */ + output[_out++] = output[from++]; + output[_out++] = output[from++]; + output[_out++] = output[from++]; + len -= 3; + } while (len > 2); + if (len) { + output[_out++] = output[from++]; + if (len > 1) { + output[_out++] = output[from++]; + } + } + } + } + else if ((op & 64) === 0) { /* 2nd level distance code */ + here = dcode[(here & 0xffff)/*here.val*/ + (hold & ((1 << op) - 1))]; + continue dodist; + } + else { + strm.msg = 'invalid distance code'; + state.mode = BAD; + break top; + } + + break; // need to emulate goto via "continue" + } + } + else if ((op & 64) === 0) { /* 2nd level length code */ + here = lcode[(here & 0xffff)/*here.val*/ + (hold & ((1 << op) - 1))]; + continue dolen; + } + else if (op & 32) { /* end-of-block */ + //Tracevv((stderr, "inflate: end of block\n")); + state.mode = TYPE; + break top; + } + else { + strm.msg = 'invalid literal/length code'; + state.mode = BAD; + break top; + } + + break; // need to emulate goto via "continue" + } + } while (_in < last && _out < end); + + /* return unused bytes (on entry, bits < 8, so in won't go too far back) */ + len = bits >> 3; + _in -= len; + bits -= len << 3; + hold &= (1 << bits) - 1; + + /* update state and return */ + strm.next_in = _in; + strm.next_out = _out; + strm.avail_in = (_in < last ? 5 + (last - _in) : 5 - (_in - last)); + strm.avail_out = (_out < end ? 257 + (end - _out) : 257 - (_out - end)); + state.hold = hold; + state.bits = bits; + return; +}; + + +/***/ }), + +/***/ 7948: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + + +// (C) 1995-2013 Jean-loup Gailly and Mark Adler +// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin +// +// This software is provided 'as-is', without any express or implied +// warranty. In no event will the authors be held liable for any damages +// arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it +// freely, subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; you must not +// claim that you wrote the original software. If you use this software +// in a product, an acknowledgment in the product documentation would be +// appreciated but is not required. +// 2. Altered source versions must be plainly marked as such, and must not be +// misrepresented as being the original software. +// 3. This notice may not be removed or altered from any source distribution. + +var utils = __webpack_require__(4236); +var adler32 = __webpack_require__(6069); +var crc32 = __webpack_require__(2869); +var inflate_fast = __webpack_require__(4264); +var inflate_table = __webpack_require__(9241); + +var CODES = 0; +var LENS = 1; +var DISTS = 2; + +/* Public constants ==========================================================*/ +/* ===========================================================================*/ + + +/* Allowed flush values; see deflate() and inflate() below for details */ +//var Z_NO_FLUSH = 0; +//var Z_PARTIAL_FLUSH = 1; +//var Z_SYNC_FLUSH = 2; +//var Z_FULL_FLUSH = 3; +var Z_FINISH = 4; +var Z_BLOCK = 5; +var Z_TREES = 6; + + +/* Return codes for the compression/decompression functions. Negative values + * are errors, positive values are used for special but normal events. + */ +var Z_OK = 0; +var Z_STREAM_END = 1; +var Z_NEED_DICT = 2; +//var Z_ERRNO = -1; +var Z_STREAM_ERROR = -2; +var Z_DATA_ERROR = -3; +var Z_MEM_ERROR = -4; +var Z_BUF_ERROR = -5; +//var Z_VERSION_ERROR = -6; + +/* The deflate compression method */ +var Z_DEFLATED = 8; + + +/* STATES ====================================================================*/ +/* ===========================================================================*/ + + +var HEAD = 1; /* i: waiting for magic header */ +var FLAGS = 2; /* i: waiting for method and flags (gzip) */ +var TIME = 3; /* i: waiting for modification time (gzip) */ +var OS = 4; /* i: waiting for extra flags and operating system (gzip) */ +var EXLEN = 5; /* i: waiting for extra length (gzip) */ +var EXTRA = 6; /* i: waiting for extra bytes (gzip) */ +var NAME = 7; /* i: waiting for end of file name (gzip) */ +var COMMENT = 8; /* i: waiting for end of comment (gzip) */ +var HCRC = 9; /* i: waiting for header crc (gzip) */ +var DICTID = 10; /* i: waiting for dictionary check value */ +var DICT = 11; /* waiting for inflateSetDictionary() call */ +var TYPE = 12; /* i: waiting for type bits, including last-flag bit */ +var TYPEDO = 13; /* i: same, but skip check to exit inflate on new block */ +var STORED = 14; /* i: waiting for stored size (length and complement) */ +var COPY_ = 15; /* i/o: same as COPY below, but only first time in */ +var COPY = 16; /* i/o: waiting for input or output to copy stored block */ +var TABLE = 17; /* i: waiting for dynamic block table lengths */ +var LENLENS = 18; /* i: waiting for code length code lengths */ +var CODELENS = 19; /* i: waiting for length/lit and distance code lengths */ +var LEN_ = 20; /* i: same as LEN below, but only first time in */ +var LEN = 21; /* i: waiting for length/lit/eob code */ +var LENEXT = 22; /* i: waiting for length extra bits */ +var DIST = 23; /* i: waiting for distance code */ +var DISTEXT = 24; /* i: waiting for distance extra bits */ +var MATCH = 25; /* o: waiting for output space to copy string */ +var LIT = 26; /* o: waiting for output space to write literal */ +var CHECK = 27; /* i: waiting for 32-bit check value */ +var LENGTH = 28; /* i: waiting for 32-bit length (gzip) */ +var DONE = 29; /* finished check, done -- remain here until reset */ +var BAD = 30; /* got a data error -- remain here until reset */ +var MEM = 31; /* got an inflate() memory error -- remain here until reset */ +var SYNC = 32; /* looking for synchronization bytes to restart inflate() */ + +/* ===========================================================================*/ + + + +var ENOUGH_LENS = 852; +var ENOUGH_DISTS = 592; +//var ENOUGH = (ENOUGH_LENS+ENOUGH_DISTS); + +var MAX_WBITS = 15; +/* 32K LZ77 window */ +var DEF_WBITS = MAX_WBITS; + + +function zswap32(q) { + return (((q >>> 24) & 0xff) + + ((q >>> 8) & 0xff00) + + ((q & 0xff00) << 8) + + ((q & 0xff) << 24)); +} + + +function InflateState() { + this.mode = 0; /* current inflate mode */ + this.last = false; /* true if processing last block */ + this.wrap = 0; /* bit 0 true for zlib, bit 1 true for gzip */ + this.havedict = false; /* true if dictionary provided */ + this.flags = 0; /* gzip header method and flags (0 if zlib) */ + this.dmax = 0; /* zlib header max distance (INFLATE_STRICT) */ + this.check = 0; /* protected copy of check value */ + this.total = 0; /* protected copy of output count */ + // TODO: may be {} + this.head = null; /* where to save gzip header information */ + + /* sliding window */ + this.wbits = 0; /* log base 2 of requested window size */ + this.wsize = 0; /* window size or zero if not using window */ + this.whave = 0; /* valid bytes in the window */ + this.wnext = 0; /* window write index */ + this.window = null; /* allocated sliding window, if needed */ + + /* bit accumulator */ + this.hold = 0; /* input bit accumulator */ + this.bits = 0; /* number of bits in "in" */ + + /* for string and stored block copying */ + this.length = 0; /* literal or length of data to copy */ + this.offset = 0; /* distance back to copy string from */ + + /* for table and code decoding */ + this.extra = 0; /* extra bits needed */ + + /* fixed and dynamic code tables */ + this.lencode = null; /* starting table for length/literal codes */ + this.distcode = null; /* starting table for distance codes */ + this.lenbits = 0; /* index bits for lencode */ + this.distbits = 0; /* index bits for distcode */ + + /* dynamic table building */ + this.ncode = 0; /* number of code length code lengths */ + this.nlen = 0; /* number of length code lengths */ + this.ndist = 0; /* number of distance code lengths */ + this.have = 0; /* number of code lengths in lens[] */ + this.next = null; /* next available space in codes[] */ + + this.lens = new utils.Buf16(320); /* temporary storage for code lengths */ + this.work = new utils.Buf16(288); /* work area for code table building */ + + /* + because we don't have pointers in js, we use lencode and distcode directly + as buffers so we don't need codes + */ + //this.codes = new utils.Buf32(ENOUGH); /* space for code tables */ + this.lendyn = null; /* dynamic table for length/literal codes (JS specific) */ + this.distdyn = null; /* dynamic table for distance codes (JS specific) */ + this.sane = 0; /* if false, allow invalid distance too far */ + this.back = 0; /* bits back of last unprocessed length/lit */ + this.was = 0; /* initial length of match */ +} + +function inflateResetKeep(strm) { + var state; + + if (!strm || !strm.state) { return Z_STREAM_ERROR; } + state = strm.state; + strm.total_in = strm.total_out = state.total = 0; + strm.msg = ''; /*Z_NULL*/ + if (state.wrap) { /* to support ill-conceived Java test suite */ + strm.adler = state.wrap & 1; + } + state.mode = HEAD; + state.last = 0; + state.havedict = 0; + state.dmax = 32768; + state.head = null/*Z_NULL*/; + state.hold = 0; + state.bits = 0; + //state.lencode = state.distcode = state.next = state.codes; + state.lencode = state.lendyn = new utils.Buf32(ENOUGH_LENS); + state.distcode = state.distdyn = new utils.Buf32(ENOUGH_DISTS); + + state.sane = 1; + state.back = -1; + //Tracev((stderr, "inflate: reset\n")); + return Z_OK; +} + +function inflateReset(strm) { + var state; + + if (!strm || !strm.state) { return Z_STREAM_ERROR; } + state = strm.state; + state.wsize = 0; + state.whave = 0; + state.wnext = 0; + return inflateResetKeep(strm); + +} + +function inflateReset2(strm, windowBits) { + var wrap; + var state; + + /* get the state */ + if (!strm || !strm.state) { return Z_STREAM_ERROR; } + state = strm.state; + + /* extract wrap request from windowBits parameter */ + if (windowBits < 0) { + wrap = 0; + windowBits = -windowBits; + } + else { + wrap = (windowBits >> 4) + 1; + if (windowBits < 48) { + windowBits &= 15; + } + } + + /* set number of window bits, free window if different */ + if (windowBits && (windowBits < 8 || windowBits > 15)) { + return Z_STREAM_ERROR; + } + if (state.window !== null && state.wbits !== windowBits) { + state.window = null; + } + + /* update state and reset the rest of it */ + state.wrap = wrap; + state.wbits = windowBits; + return inflateReset(strm); +} + +function inflateInit2(strm, windowBits) { + var ret; + var state; + + if (!strm) { return Z_STREAM_ERROR; } + //strm.msg = Z_NULL; /* in case we return an error */ + + state = new InflateState(); + + //if (state === Z_NULL) return Z_MEM_ERROR; + //Tracev((stderr, "inflate: allocated\n")); + strm.state = state; + state.window = null/*Z_NULL*/; + ret = inflateReset2(strm, windowBits); + if (ret !== Z_OK) { + strm.state = null/*Z_NULL*/; + } + return ret; +} + +function inflateInit(strm) { + return inflateInit2(strm, DEF_WBITS); +} + + +/* + Return state with length and distance decoding tables and index sizes set to + fixed code decoding. Normally this returns fixed tables from inffixed.h. + If BUILDFIXED is defined, then instead this routine builds the tables the + first time it's called, and returns those tables the first time and + thereafter. This reduces the size of the code by about 2K bytes, in + exchange for a little execution time. However, BUILDFIXED should not be + used for threaded applications, since the rewriting of the tables and virgin + may not be thread-safe. + */ +var virgin = true; + +var lenfix, distfix; // We have no pointers in JS, so keep tables separate + +function fixedtables(state) { + /* build fixed huffman tables if first call (may not be thread safe) */ + if (virgin) { + var sym; + + lenfix = new utils.Buf32(512); + distfix = new utils.Buf32(32); + + /* literal/length table */ + sym = 0; + while (sym < 144) { state.lens[sym++] = 8; } + while (sym < 256) { state.lens[sym++] = 9; } + while (sym < 280) { state.lens[sym++] = 7; } + while (sym < 288) { state.lens[sym++] = 8; } + + inflate_table(LENS, state.lens, 0, 288, lenfix, 0, state.work, { bits: 9 }); + + /* distance table */ + sym = 0; + while (sym < 32) { state.lens[sym++] = 5; } + + inflate_table(DISTS, state.lens, 0, 32, distfix, 0, state.work, { bits: 5 }); + + /* do this just once */ + virgin = false; + } + + state.lencode = lenfix; + state.lenbits = 9; + state.distcode = distfix; + state.distbits = 5; +} + + +/* + Update the window with the last wsize (normally 32K) bytes written before + returning. If window does not exist yet, create it. This is only called + when a window is already in use, or when output has been written during this + inflate call, but the end of the deflate stream has not been reached yet. + It is also called to create a window for dictionary data when a dictionary + is loaded. + + Providing output buffers larger than 32K to inflate() should provide a speed + advantage, since only the last 32K of output is copied to the sliding window + upon return from inflate(), and since all distances after the first 32K of + output will fall in the output data, making match copies simpler and faster. + The advantage may be dependent on the size of the processor's data caches. + */ +function updatewindow(strm, src, end, copy) { + var dist; + var state = strm.state; + + /* if it hasn't been done already, allocate space for the window */ + if (state.window === null) { + state.wsize = 1 << state.wbits; + state.wnext = 0; + state.whave = 0; + + state.window = new utils.Buf8(state.wsize); + } + + /* copy state->wsize or less output bytes into the circular window */ + if (copy >= state.wsize) { + utils.arraySet(state.window, src, end - state.wsize, state.wsize, 0); + state.wnext = 0; + state.whave = state.wsize; + } + else { + dist = state.wsize - state.wnext; + if (dist > copy) { + dist = copy; + } + //zmemcpy(state->window + state->wnext, end - copy, dist); + utils.arraySet(state.window, src, end - copy, dist, state.wnext); + copy -= dist; + if (copy) { + //zmemcpy(state->window, end - copy, copy); + utils.arraySet(state.window, src, end - copy, copy, 0); + state.wnext = copy; + state.whave = state.wsize; + } + else { + state.wnext += dist; + if (state.wnext === state.wsize) { state.wnext = 0; } + if (state.whave < state.wsize) { state.whave += dist; } + } + } + return 0; +} + +function inflate(strm, flush) { + var state; + var input, output; // input/output buffers + var next; /* next input INDEX */ + var put; /* next output INDEX */ + var have, left; /* available input and output */ + var hold; /* bit buffer */ + var bits; /* bits in bit buffer */ + var _in, _out; /* save starting available input and output */ + var copy; /* number of stored or match bytes to copy */ + var from; /* where to copy match bytes from */ + var from_source; + var here = 0; /* current decoding table entry */ + var here_bits, here_op, here_val; // paked "here" denormalized (JS specific) + //var last; /* parent table entry */ + var last_bits, last_op, last_val; // paked "last" denormalized (JS specific) + var len; /* length to copy for repeats, bits to drop */ + var ret; /* return code */ + var hbuf = new utils.Buf8(4); /* buffer for gzip header crc calculation */ + var opts; + + var n; // temporary var for NEED_BITS + + var order = /* permutation of code lengths */ + [ 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 ]; + + + if (!strm || !strm.state || !strm.output || + (!strm.input && strm.avail_in !== 0)) { + return Z_STREAM_ERROR; + } + + state = strm.state; + if (state.mode === TYPE) { state.mode = TYPEDO; } /* skip check */ + + + //--- LOAD() --- + put = strm.next_out; + output = strm.output; + left = strm.avail_out; + next = strm.next_in; + input = strm.input; + have = strm.avail_in; + hold = state.hold; + bits = state.bits; + //--- + + _in = have; + _out = left; + ret = Z_OK; + + inf_leave: // goto emulation + for (;;) { + switch (state.mode) { + case HEAD: + if (state.wrap === 0) { + state.mode = TYPEDO; + break; + } + //=== NEEDBITS(16); + while (bits < 16) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + if ((state.wrap & 2) && hold === 0x8b1f) { /* gzip header */ + state.check = 0/*crc32(0L, Z_NULL, 0)*/; + //=== CRC2(state.check, hold); + hbuf[0] = hold & 0xff; + hbuf[1] = (hold >>> 8) & 0xff; + state.check = crc32(state.check, hbuf, 2, 0); + //===// + + //=== INITBITS(); + hold = 0; + bits = 0; + //===// + state.mode = FLAGS; + break; + } + state.flags = 0; /* expect zlib header */ + if (state.head) { + state.head.done = false; + } + if (!(state.wrap & 1) || /* check if zlib header allowed */ + (((hold & 0xff)/*BITS(8)*/ << 8) + (hold >> 8)) % 31) { + strm.msg = 'incorrect header check'; + state.mode = BAD; + break; + } + if ((hold & 0x0f)/*BITS(4)*/ !== Z_DEFLATED) { + strm.msg = 'unknown compression method'; + state.mode = BAD; + break; + } + //--- DROPBITS(4) ---// + hold >>>= 4; + bits -= 4; + //---// + len = (hold & 0x0f)/*BITS(4)*/ + 8; + if (state.wbits === 0) { + state.wbits = len; + } + else if (len > state.wbits) { + strm.msg = 'invalid window size'; + state.mode = BAD; + break; + } + state.dmax = 1 << len; + //Tracev((stderr, "inflate: zlib header ok\n")); + strm.adler = state.check = 1/*adler32(0L, Z_NULL, 0)*/; + state.mode = hold & 0x200 ? DICTID : TYPE; + //=== INITBITS(); + hold = 0; + bits = 0; + //===// + break; + case FLAGS: + //=== NEEDBITS(16); */ + while (bits < 16) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + state.flags = hold; + if ((state.flags & 0xff) !== Z_DEFLATED) { + strm.msg = 'unknown compression method'; + state.mode = BAD; + break; + } + if (state.flags & 0xe000) { + strm.msg = 'unknown header flags set'; + state.mode = BAD; + break; + } + if (state.head) { + state.head.text = ((hold >> 8) & 1); + } + if (state.flags & 0x0200) { + //=== CRC2(state.check, hold); + hbuf[0] = hold & 0xff; + hbuf[1] = (hold >>> 8) & 0xff; + state.check = crc32(state.check, hbuf, 2, 0); + //===// + } + //=== INITBITS(); + hold = 0; + bits = 0; + //===// + state.mode = TIME; + /* falls through */ + case TIME: + //=== NEEDBITS(32); */ + while (bits < 32) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + if (state.head) { + state.head.time = hold; + } + if (state.flags & 0x0200) { + //=== CRC4(state.check, hold) + hbuf[0] = hold & 0xff; + hbuf[1] = (hold >>> 8) & 0xff; + hbuf[2] = (hold >>> 16) & 0xff; + hbuf[3] = (hold >>> 24) & 0xff; + state.check = crc32(state.check, hbuf, 4, 0); + //=== + } + //=== INITBITS(); + hold = 0; + bits = 0; + //===// + state.mode = OS; + /* falls through */ + case OS: + //=== NEEDBITS(16); */ + while (bits < 16) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + if (state.head) { + state.head.xflags = (hold & 0xff); + state.head.os = (hold >> 8); + } + if (state.flags & 0x0200) { + //=== CRC2(state.check, hold); + hbuf[0] = hold & 0xff; + hbuf[1] = (hold >>> 8) & 0xff; + state.check = crc32(state.check, hbuf, 2, 0); + //===// + } + //=== INITBITS(); + hold = 0; + bits = 0; + //===// + state.mode = EXLEN; + /* falls through */ + case EXLEN: + if (state.flags & 0x0400) { + //=== NEEDBITS(16); */ + while (bits < 16) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + state.length = hold; + if (state.head) { + state.head.extra_len = hold; + } + if (state.flags & 0x0200) { + //=== CRC2(state.check, hold); + hbuf[0] = hold & 0xff; + hbuf[1] = (hold >>> 8) & 0xff; + state.check = crc32(state.check, hbuf, 2, 0); + //===// + } + //=== INITBITS(); + hold = 0; + bits = 0; + //===// + } + else if (state.head) { + state.head.extra = null/*Z_NULL*/; + } + state.mode = EXTRA; + /* falls through */ + case EXTRA: + if (state.flags & 0x0400) { + copy = state.length; + if (copy > have) { copy = have; } + if (copy) { + if (state.head) { + len = state.head.extra_len - state.length; + if (!state.head.extra) { + // Use untyped array for more convenient processing later + state.head.extra = new Array(state.head.extra_len); + } + utils.arraySet( + state.head.extra, + input, + next, + // extra field is limited to 65536 bytes + // - no need for additional size check + copy, + /*len + copy > state.head.extra_max - len ? state.head.extra_max : copy,*/ + len + ); + //zmemcpy(state.head.extra + len, next, + // len + copy > state.head.extra_max ? + // state.head.extra_max - len : copy); + } + if (state.flags & 0x0200) { + state.check = crc32(state.check, input, copy, next); + } + have -= copy; + next += copy; + state.length -= copy; + } + if (state.length) { break inf_leave; } + } + state.length = 0; + state.mode = NAME; + /* falls through */ + case NAME: + if (state.flags & 0x0800) { + if (have === 0) { break inf_leave; } + copy = 0; + do { + // TODO: 2 or 1 bytes? + len = input[next + copy++]; + /* use constant limit because in js we should not preallocate memory */ + if (state.head && len && + (state.length < 65536 /*state.head.name_max*/)) { + state.head.name += String.fromCharCode(len); + } + } while (len && copy < have); + + if (state.flags & 0x0200) { + state.check = crc32(state.check, input, copy, next); + } + have -= copy; + next += copy; + if (len) { break inf_leave; } + } + else if (state.head) { + state.head.name = null; + } + state.length = 0; + state.mode = COMMENT; + /* falls through */ + case COMMENT: + if (state.flags & 0x1000) { + if (have === 0) { break inf_leave; } + copy = 0; + do { + len = input[next + copy++]; + /* use constant limit because in js we should not preallocate memory */ + if (state.head && len && + (state.length < 65536 /*state.head.comm_max*/)) { + state.head.comment += String.fromCharCode(len); + } + } while (len && copy < have); + if (state.flags & 0x0200) { + state.check = crc32(state.check, input, copy, next); + } + have -= copy; + next += copy; + if (len) { break inf_leave; } + } + else if (state.head) { + state.head.comment = null; + } + state.mode = HCRC; + /* falls through */ + case HCRC: + if (state.flags & 0x0200) { + //=== NEEDBITS(16); */ + while (bits < 16) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + if (hold !== (state.check & 0xffff)) { + strm.msg = 'header crc mismatch'; + state.mode = BAD; + break; + } + //=== INITBITS(); + hold = 0; + bits = 0; + //===// + } + if (state.head) { + state.head.hcrc = ((state.flags >> 9) & 1); + state.head.done = true; + } + strm.adler = state.check = 0; + state.mode = TYPE; + break; + case DICTID: + //=== NEEDBITS(32); */ + while (bits < 32) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + strm.adler = state.check = zswap32(hold); + //=== INITBITS(); + hold = 0; + bits = 0; + //===// + state.mode = DICT; + /* falls through */ + case DICT: + if (state.havedict === 0) { + //--- RESTORE() --- + strm.next_out = put; + strm.avail_out = left; + strm.next_in = next; + strm.avail_in = have; + state.hold = hold; + state.bits = bits; + //--- + return Z_NEED_DICT; + } + strm.adler = state.check = 1/*adler32(0L, Z_NULL, 0)*/; + state.mode = TYPE; + /* falls through */ + case TYPE: + if (flush === Z_BLOCK || flush === Z_TREES) { break inf_leave; } + /* falls through */ + case TYPEDO: + if (state.last) { + //--- BYTEBITS() ---// + hold >>>= bits & 7; + bits -= bits & 7; + //---// + state.mode = CHECK; + break; + } + //=== NEEDBITS(3); */ + while (bits < 3) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + state.last = (hold & 0x01)/*BITS(1)*/; + //--- DROPBITS(1) ---// + hold >>>= 1; + bits -= 1; + //---// + + switch ((hold & 0x03)/*BITS(2)*/) { + case 0: /* stored block */ + //Tracev((stderr, "inflate: stored block%s\n", + // state.last ? " (last)" : "")); + state.mode = STORED; + break; + case 1: /* fixed block */ + fixedtables(state); + //Tracev((stderr, "inflate: fixed codes block%s\n", + // state.last ? " (last)" : "")); + state.mode = LEN_; /* decode codes */ + if (flush === Z_TREES) { + //--- DROPBITS(2) ---// + hold >>>= 2; + bits -= 2; + //---// + break inf_leave; + } + break; + case 2: /* dynamic block */ + //Tracev((stderr, "inflate: dynamic codes block%s\n", + // state.last ? " (last)" : "")); + state.mode = TABLE; + break; + case 3: + strm.msg = 'invalid block type'; + state.mode = BAD; + } + //--- DROPBITS(2) ---// + hold >>>= 2; + bits -= 2; + //---// + break; + case STORED: + //--- BYTEBITS() ---// /* go to byte boundary */ + hold >>>= bits & 7; + bits -= bits & 7; + //---// + //=== NEEDBITS(32); */ + while (bits < 32) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + if ((hold & 0xffff) !== ((hold >>> 16) ^ 0xffff)) { + strm.msg = 'invalid stored block lengths'; + state.mode = BAD; + break; + } + state.length = hold & 0xffff; + //Tracev((stderr, "inflate: stored length %u\n", + // state.length)); + //=== INITBITS(); + hold = 0; + bits = 0; + //===// + state.mode = COPY_; + if (flush === Z_TREES) { break inf_leave; } + /* falls through */ + case COPY_: + state.mode = COPY; + /* falls through */ + case COPY: + copy = state.length; + if (copy) { + if (copy > have) { copy = have; } + if (copy > left) { copy = left; } + if (copy === 0) { break inf_leave; } + //--- zmemcpy(put, next, copy); --- + utils.arraySet(output, input, next, copy, put); + //---// + have -= copy; + next += copy; + left -= copy; + put += copy; + state.length -= copy; + break; + } + //Tracev((stderr, "inflate: stored end\n")); + state.mode = TYPE; + break; + case TABLE: + //=== NEEDBITS(14); */ + while (bits < 14) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + state.nlen = (hold & 0x1f)/*BITS(5)*/ + 257; + //--- DROPBITS(5) ---// + hold >>>= 5; + bits -= 5; + //---// + state.ndist = (hold & 0x1f)/*BITS(5)*/ + 1; + //--- DROPBITS(5) ---// + hold >>>= 5; + bits -= 5; + //---// + state.ncode = (hold & 0x0f)/*BITS(4)*/ + 4; + //--- DROPBITS(4) ---// + hold >>>= 4; + bits -= 4; + //---// +//#ifndef PKZIP_BUG_WORKAROUND + if (state.nlen > 286 || state.ndist > 30) { + strm.msg = 'too many length or distance symbols'; + state.mode = BAD; + break; + } +//#endif + //Tracev((stderr, "inflate: table sizes ok\n")); + state.have = 0; + state.mode = LENLENS; + /* falls through */ + case LENLENS: + while (state.have < state.ncode) { + //=== NEEDBITS(3); + while (bits < 3) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + state.lens[order[state.have++]] = (hold & 0x07);//BITS(3); + //--- DROPBITS(3) ---// + hold >>>= 3; + bits -= 3; + //---// + } + while (state.have < 19) { + state.lens[order[state.have++]] = 0; + } + // We have separate tables & no pointers. 2 commented lines below not needed. + //state.next = state.codes; + //state.lencode = state.next; + // Switch to use dynamic table + state.lencode = state.lendyn; + state.lenbits = 7; + + opts = { bits: state.lenbits }; + ret = inflate_table(CODES, state.lens, 0, 19, state.lencode, 0, state.work, opts); + state.lenbits = opts.bits; + + if (ret) { + strm.msg = 'invalid code lengths set'; + state.mode = BAD; + break; + } + //Tracev((stderr, "inflate: code lengths ok\n")); + state.have = 0; + state.mode = CODELENS; + /* falls through */ + case CODELENS: + while (state.have < state.nlen + state.ndist) { + for (;;) { + here = state.lencode[hold & ((1 << state.lenbits) - 1)];/*BITS(state.lenbits)*/ + here_bits = here >>> 24; + here_op = (here >>> 16) & 0xff; + here_val = here & 0xffff; + + if ((here_bits) <= bits) { break; } + //--- PULLBYTE() ---// + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + //---// + } + if (here_val < 16) { + //--- DROPBITS(here.bits) ---// + hold >>>= here_bits; + bits -= here_bits; + //---// + state.lens[state.have++] = here_val; + } + else { + if (here_val === 16) { + //=== NEEDBITS(here.bits + 2); + n = here_bits + 2; + while (bits < n) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + //--- DROPBITS(here.bits) ---// + hold >>>= here_bits; + bits -= here_bits; + //---// + if (state.have === 0) { + strm.msg = 'invalid bit length repeat'; + state.mode = BAD; + break; + } + len = state.lens[state.have - 1]; + copy = 3 + (hold & 0x03);//BITS(2); + //--- DROPBITS(2) ---// + hold >>>= 2; + bits -= 2; + //---// + } + else if (here_val === 17) { + //=== NEEDBITS(here.bits + 3); + n = here_bits + 3; + while (bits < n) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + //--- DROPBITS(here.bits) ---// + hold >>>= here_bits; + bits -= here_bits; + //---// + len = 0; + copy = 3 + (hold & 0x07);//BITS(3); + //--- DROPBITS(3) ---// + hold >>>= 3; + bits -= 3; + //---// + } + else { + //=== NEEDBITS(here.bits + 7); + n = here_bits + 7; + while (bits < n) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + //--- DROPBITS(here.bits) ---// + hold >>>= here_bits; + bits -= here_bits; + //---// + len = 0; + copy = 11 + (hold & 0x7f);//BITS(7); + //--- DROPBITS(7) ---// + hold >>>= 7; + bits -= 7; + //---// + } + if (state.have + copy > state.nlen + state.ndist) { + strm.msg = 'invalid bit length repeat'; + state.mode = BAD; + break; + } + while (copy--) { + state.lens[state.have++] = len; + } + } + } + + /* handle error breaks in while */ + if (state.mode === BAD) { break; } + + /* check for end-of-block code (better have one) */ + if (state.lens[256] === 0) { + strm.msg = 'invalid code -- missing end-of-block'; + state.mode = BAD; + break; + } + + /* build code tables -- note: do not change the lenbits or distbits + values here (9 and 6) without reading the comments in inftrees.h + concerning the ENOUGH constants, which depend on those values */ + state.lenbits = 9; + + opts = { bits: state.lenbits }; + ret = inflate_table(LENS, state.lens, 0, state.nlen, state.lencode, 0, state.work, opts); + // We have separate tables & no pointers. 2 commented lines below not needed. + // state.next_index = opts.table_index; + state.lenbits = opts.bits; + // state.lencode = state.next; + + if (ret) { + strm.msg = 'invalid literal/lengths set'; + state.mode = BAD; + break; + } + + state.distbits = 6; + //state.distcode.copy(state.codes); + // Switch to use dynamic table + state.distcode = state.distdyn; + opts = { bits: state.distbits }; + ret = inflate_table(DISTS, state.lens, state.nlen, state.ndist, state.distcode, 0, state.work, opts); + // We have separate tables & no pointers. 2 commented lines below not needed. + // state.next_index = opts.table_index; + state.distbits = opts.bits; + // state.distcode = state.next; + + if (ret) { + strm.msg = 'invalid distances set'; + state.mode = BAD; + break; + } + //Tracev((stderr, 'inflate: codes ok\n')); + state.mode = LEN_; + if (flush === Z_TREES) { break inf_leave; } + /* falls through */ + case LEN_: + state.mode = LEN; + /* falls through */ + case LEN: + if (have >= 6 && left >= 258) { + //--- RESTORE() --- + strm.next_out = put; + strm.avail_out = left; + strm.next_in = next; + strm.avail_in = have; + state.hold = hold; + state.bits = bits; + //--- + inflate_fast(strm, _out); + //--- LOAD() --- + put = strm.next_out; + output = strm.output; + left = strm.avail_out; + next = strm.next_in; + input = strm.input; + have = strm.avail_in; + hold = state.hold; + bits = state.bits; + //--- + + if (state.mode === TYPE) { + state.back = -1; + } + break; + } + state.back = 0; + for (;;) { + here = state.lencode[hold & ((1 << state.lenbits) - 1)]; /*BITS(state.lenbits)*/ + here_bits = here >>> 24; + here_op = (here >>> 16) & 0xff; + here_val = here & 0xffff; + + if (here_bits <= bits) { break; } + //--- PULLBYTE() ---// + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + //---// + } + if (here_op && (here_op & 0xf0) === 0) { + last_bits = here_bits; + last_op = here_op; + last_val = here_val; + for (;;) { + here = state.lencode[last_val + + ((hold & ((1 << (last_bits + last_op)) - 1))/*BITS(last.bits + last.op)*/ >> last_bits)]; + here_bits = here >>> 24; + here_op = (here >>> 16) & 0xff; + here_val = here & 0xffff; + + if ((last_bits + here_bits) <= bits) { break; } + //--- PULLBYTE() ---// + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + //---// + } + //--- DROPBITS(last.bits) ---// + hold >>>= last_bits; + bits -= last_bits; + //---// + state.back += last_bits; + } + //--- DROPBITS(here.bits) ---// + hold >>>= here_bits; + bits -= here_bits; + //---// + state.back += here_bits; + state.length = here_val; + if (here_op === 0) { + //Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? + // "inflate: literal '%c'\n" : + // "inflate: literal 0x%02x\n", here.val)); + state.mode = LIT; + break; + } + if (here_op & 32) { + //Tracevv((stderr, "inflate: end of block\n")); + state.back = -1; + state.mode = TYPE; + break; + } + if (here_op & 64) { + strm.msg = 'invalid literal/length code'; + state.mode = BAD; + break; + } + state.extra = here_op & 15; + state.mode = LENEXT; + /* falls through */ + case LENEXT: + if (state.extra) { + //=== NEEDBITS(state.extra); + n = state.extra; + while (bits < n) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + state.length += hold & ((1 << state.extra) - 1)/*BITS(state.extra)*/; + //--- DROPBITS(state.extra) ---// + hold >>>= state.extra; + bits -= state.extra; + //---// + state.back += state.extra; + } + //Tracevv((stderr, "inflate: length %u\n", state.length)); + state.was = state.length; + state.mode = DIST; + /* falls through */ + case DIST: + for (;;) { + here = state.distcode[hold & ((1 << state.distbits) - 1)];/*BITS(state.distbits)*/ + here_bits = here >>> 24; + here_op = (here >>> 16) & 0xff; + here_val = here & 0xffff; + + if ((here_bits) <= bits) { break; } + //--- PULLBYTE() ---// + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + //---// + } + if ((here_op & 0xf0) === 0) { + last_bits = here_bits; + last_op = here_op; + last_val = here_val; + for (;;) { + here = state.distcode[last_val + + ((hold & ((1 << (last_bits + last_op)) - 1))/*BITS(last.bits + last.op)*/ >> last_bits)]; + here_bits = here >>> 24; + here_op = (here >>> 16) & 0xff; + here_val = here & 0xffff; + + if ((last_bits + here_bits) <= bits) { break; } + //--- PULLBYTE() ---// + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + //---// + } + //--- DROPBITS(last.bits) ---// + hold >>>= last_bits; + bits -= last_bits; + //---// + state.back += last_bits; + } + //--- DROPBITS(here.bits) ---// + hold >>>= here_bits; + bits -= here_bits; + //---// + state.back += here_bits; + if (here_op & 64) { + strm.msg = 'invalid distance code'; + state.mode = BAD; + break; + } + state.offset = here_val; + state.extra = (here_op) & 15; + state.mode = DISTEXT; + /* falls through */ + case DISTEXT: + if (state.extra) { + //=== NEEDBITS(state.extra); + n = state.extra; + while (bits < n) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + state.offset += hold & ((1 << state.extra) - 1)/*BITS(state.extra)*/; + //--- DROPBITS(state.extra) ---// + hold >>>= state.extra; + bits -= state.extra; + //---// + state.back += state.extra; + } +//#ifdef INFLATE_STRICT + if (state.offset > state.dmax) { + strm.msg = 'invalid distance too far back'; + state.mode = BAD; + break; + } +//#endif + //Tracevv((stderr, "inflate: distance %u\n", state.offset)); + state.mode = MATCH; + /* falls through */ + case MATCH: + if (left === 0) { break inf_leave; } + copy = _out - left; + if (state.offset > copy) { /* copy from window */ + copy = state.offset - copy; + if (copy > state.whave) { + if (state.sane) { + strm.msg = 'invalid distance too far back'; + state.mode = BAD; + break; + } +// (!) This block is disabled in zlib defaults, +// don't enable it for binary compatibility +//#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR +// Trace((stderr, "inflate.c too far\n")); +// copy -= state.whave; +// if (copy > state.length) { copy = state.length; } +// if (copy > left) { copy = left; } +// left -= copy; +// state.length -= copy; +// do { +// output[put++] = 0; +// } while (--copy); +// if (state.length === 0) { state.mode = LEN; } +// break; +//#endif + } + if (copy > state.wnext) { + copy -= state.wnext; + from = state.wsize - copy; + } + else { + from = state.wnext - copy; + } + if (copy > state.length) { copy = state.length; } + from_source = state.window; + } + else { /* copy from output */ + from_source = output; + from = put - state.offset; + copy = state.length; + } + if (copy > left) { copy = left; } + left -= copy; + state.length -= copy; + do { + output[put++] = from_source[from++]; + } while (--copy); + if (state.length === 0) { state.mode = LEN; } + break; + case LIT: + if (left === 0) { break inf_leave; } + output[put++] = state.length; + left--; + state.mode = LEN; + break; + case CHECK: + if (state.wrap) { + //=== NEEDBITS(32); + while (bits < 32) { + if (have === 0) { break inf_leave; } + have--; + // Use '|' instead of '+' to make sure that result is signed + hold |= input[next++] << bits; + bits += 8; + } + //===// + _out -= left; + strm.total_out += _out; + state.total += _out; + if (_out) { + strm.adler = state.check = + /*UPDATE(state.check, put - _out, _out);*/ + (state.flags ? crc32(state.check, output, _out, put - _out) : adler32(state.check, output, _out, put - _out)); + + } + _out = left; + // NB: crc32 stored as signed 32-bit int, zswap32 returns signed too + if ((state.flags ? hold : zswap32(hold)) !== state.check) { + strm.msg = 'incorrect data check'; + state.mode = BAD; + break; + } + //=== INITBITS(); + hold = 0; + bits = 0; + //===// + //Tracev((stderr, "inflate: check matches trailer\n")); + } + state.mode = LENGTH; + /* falls through */ + case LENGTH: + if (state.wrap && state.flags) { + //=== NEEDBITS(32); + while (bits < 32) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + if (hold !== (state.total & 0xffffffff)) { + strm.msg = 'incorrect length check'; + state.mode = BAD; + break; + } + //=== INITBITS(); + hold = 0; + bits = 0; + //===// + //Tracev((stderr, "inflate: length matches trailer\n")); + } + state.mode = DONE; + /* falls through */ + case DONE: + ret = Z_STREAM_END; + break inf_leave; + case BAD: + ret = Z_DATA_ERROR; + break inf_leave; + case MEM: + return Z_MEM_ERROR; + case SYNC: + /* falls through */ + default: + return Z_STREAM_ERROR; + } + } + + // inf_leave <- here is real place for "goto inf_leave", emulated via "break inf_leave" + + /* + Return from inflate(), updating the total counts and the check value. + If there was no progress during the inflate() call, return a buffer + error. Call updatewindow() to create and/or update the window state. + Note: a memory error from inflate() is non-recoverable. + */ + + //--- RESTORE() --- + strm.next_out = put; + strm.avail_out = left; + strm.next_in = next; + strm.avail_in = have; + state.hold = hold; + state.bits = bits; + //--- + + if (state.wsize || (_out !== strm.avail_out && state.mode < BAD && + (state.mode < CHECK || flush !== Z_FINISH))) { + if (updatewindow(strm, strm.output, strm.next_out, _out - strm.avail_out)) { + state.mode = MEM; + return Z_MEM_ERROR; + } + } + _in -= strm.avail_in; + _out -= strm.avail_out; + strm.total_in += _in; + strm.total_out += _out; + state.total += _out; + if (state.wrap && _out) { + strm.adler = state.check = /*UPDATE(state.check, strm.next_out - _out, _out);*/ + (state.flags ? crc32(state.check, output, _out, strm.next_out - _out) : adler32(state.check, output, _out, strm.next_out - _out)); + } + strm.data_type = state.bits + (state.last ? 64 : 0) + + (state.mode === TYPE ? 128 : 0) + + (state.mode === LEN_ || state.mode === COPY_ ? 256 : 0); + if (((_in === 0 && _out === 0) || flush === Z_FINISH) && ret === Z_OK) { + ret = Z_BUF_ERROR; + } + return ret; +} + +function inflateEnd(strm) { + + if (!strm || !strm.state /*|| strm->zfree == (free_func)0*/) { + return Z_STREAM_ERROR; + } + + var state = strm.state; + if (state.window) { + state.window = null; + } + strm.state = null; + return Z_OK; +} + +function inflateGetHeader(strm, head) { + var state; + + /* check state */ + if (!strm || !strm.state) { return Z_STREAM_ERROR; } + state = strm.state; + if ((state.wrap & 2) === 0) { return Z_STREAM_ERROR; } + + /* save header structure */ + state.head = head; + head.done = false; + return Z_OK; +} + +function inflateSetDictionary(strm, dictionary) { + var dictLength = dictionary.length; + + var state; + var dictid; + var ret; + + /* check state */ + if (!strm /* == Z_NULL */ || !strm.state /* == Z_NULL */) { return Z_STREAM_ERROR; } + state = strm.state; + + if (state.wrap !== 0 && state.mode !== DICT) { + return Z_STREAM_ERROR; + } + + /* check for correct dictionary identifier */ + if (state.mode === DICT) { + dictid = 1; /* adler32(0, null, 0)*/ + /* dictid = adler32(dictid, dictionary, dictLength); */ + dictid = adler32(dictid, dictionary, dictLength, 0); + if (dictid !== state.check) { + return Z_DATA_ERROR; + } + } + /* copy dictionary to window using updatewindow(), which will amend the + existing dictionary if appropriate */ + ret = updatewindow(strm, dictionary, dictLength, dictLength); + if (ret) { + state.mode = MEM; + return Z_MEM_ERROR; + } + state.havedict = 1; + // Tracev((stderr, "inflate: dictionary set\n")); + return Z_OK; +} + +exports.inflateReset = inflateReset; +exports.inflateReset2 = inflateReset2; +exports.inflateResetKeep = inflateResetKeep; +exports.inflateInit = inflateInit; +exports.inflateInit2 = inflateInit2; +exports.inflate = inflate; +exports.inflateEnd = inflateEnd; +exports.inflateGetHeader = inflateGetHeader; +exports.inflateSetDictionary = inflateSetDictionary; +exports.inflateInfo = 'pako inflate (from Nodeca project)'; + +/* Not implemented +exports.inflateCopy = inflateCopy; +exports.inflateGetDictionary = inflateGetDictionary; +exports.inflateMark = inflateMark; +exports.inflatePrime = inflatePrime; +exports.inflateSync = inflateSync; +exports.inflateSyncPoint = inflateSyncPoint; +exports.inflateUndermine = inflateUndermine; +*/ + + +/***/ }), + +/***/ 9241: +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +"use strict"; + + +// (C) 1995-2013 Jean-loup Gailly and Mark Adler +// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin +// +// This software is provided 'as-is', without any express or implied +// warranty. In no event will the authors be held liable for any damages +// arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it +// freely, subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; you must not +// claim that you wrote the original software. If you use this software +// in a product, an acknowledgment in the product documentation would be +// appreciated but is not required. +// 2. Altered source versions must be plainly marked as such, and must not be +// misrepresented as being the original software. +// 3. This notice may not be removed or altered from any source distribution. + +var utils = __webpack_require__(4236); + +var MAXBITS = 15; +var ENOUGH_LENS = 852; +var ENOUGH_DISTS = 592; +//var ENOUGH = (ENOUGH_LENS+ENOUGH_DISTS); + +var CODES = 0; +var LENS = 1; +var DISTS = 2; + +var lbase = [ /* Length codes 257..285 base */ + 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, + 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0 +]; + +var lext = [ /* Length codes 257..285 extra */ + 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, + 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78 +]; + +var dbase = [ /* Distance codes 0..29 base */ + 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, + 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, + 8193, 12289, 16385, 24577, 0, 0 +]; + +var dext = [ /* Distance codes 0..29 extra */ + 16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, + 23, 23, 24, 24, 25, 25, 26, 26, 27, 27, + 28, 28, 29, 29, 64, 64 +]; + +module.exports = function inflate_table(type, lens, lens_index, codes, table, table_index, work, opts) +{ + var bits = opts.bits; + //here = opts.here; /* table entry for duplication */ + + var len = 0; /* a code's length in bits */ + var sym = 0; /* index of code symbols */ + var min = 0, max = 0; /* minimum and maximum code lengths */ + var root = 0; /* number of index bits for root table */ + var curr = 0; /* number of index bits for current table */ + var drop = 0; /* code bits to drop for sub-table */ + var left = 0; /* number of prefix codes available */ + var used = 0; /* code entries in table used */ + var huff = 0; /* Huffman code */ + var incr; /* for incrementing code, index */ + var fill; /* index for replicating entries */ + var low; /* low bits for current root entry */ + var mask; /* mask for low root bits */ + var next; /* next available space in table */ + var base = null; /* base value table to use */ + var base_index = 0; +// var shoextra; /* extra bits table to use */ + var end; /* use base and extra for symbol > end */ + var count = new utils.Buf16(MAXBITS + 1); //[MAXBITS+1]; /* number of codes of each length */ + var offs = new utils.Buf16(MAXBITS + 1); //[MAXBITS+1]; /* offsets in table for each length */ + var extra = null; + var extra_index = 0; + + var here_bits, here_op, here_val; + + /* + Process a set of code lengths to create a canonical Huffman code. The + code lengths are lens[0..codes-1]. Each length corresponds to the + symbols 0..codes-1. The Huffman code is generated by first sorting the + symbols by length from short to long, and retaining the symbol order + for codes with equal lengths. Then the code starts with all zero bits + for the first code of the shortest length, and the codes are integer + increments for the same length, and zeros are appended as the length + increases. For the deflate format, these bits are stored backwards + from their more natural integer increment ordering, and so when the + decoding tables are built in the large loop below, the integer codes + are incremented backwards. + + This routine assumes, but does not check, that all of the entries in + lens[] are in the range 0..MAXBITS. The caller must assure this. + 1..MAXBITS is interpreted as that code length. zero means that that + symbol does not occur in this code. + + The codes are sorted by computing a count of codes for each length, + creating from that a table of starting indices for each length in the + sorted table, and then entering the symbols in order in the sorted + table. The sorted table is work[], with that space being provided by + the caller. + + The length counts are used for other purposes as well, i.e. finding + the minimum and maximum length codes, determining if there are any + codes at all, checking for a valid set of lengths, and looking ahead + at length counts to determine sub-table sizes when building the + decoding tables. + */ + + /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */ + for (len = 0; len <= MAXBITS; len++) { + count[len] = 0; + } + for (sym = 0; sym < codes; sym++) { + count[lens[lens_index + sym]]++; + } + + /* bound code lengths, force root to be within code lengths */ + root = bits; + for (max = MAXBITS; max >= 1; max--) { + if (count[max] !== 0) { break; } + } + if (root > max) { + root = max; + } + if (max === 0) { /* no symbols to code at all */ + //table.op[opts.table_index] = 64; //here.op = (var char)64; /* invalid code marker */ + //table.bits[opts.table_index] = 1; //here.bits = (var char)1; + //table.val[opts.table_index++] = 0; //here.val = (var short)0; + table[table_index++] = (1 << 24) | (64 << 16) | 0; + + + //table.op[opts.table_index] = 64; + //table.bits[opts.table_index] = 1; + //table.val[opts.table_index++] = 0; + table[table_index++] = (1 << 24) | (64 << 16) | 0; + + opts.bits = 1; + return 0; /* no symbols, but wait for decoding to report error */ + } + for (min = 1; min < max; min++) { + if (count[min] !== 0) { break; } + } + if (root < min) { + root = min; + } + + /* check for an over-subscribed or incomplete set of lengths */ + left = 1; + for (len = 1; len <= MAXBITS; len++) { + left <<= 1; + left -= count[len]; + if (left < 0) { + return -1; + } /* over-subscribed */ + } + if (left > 0 && (type === CODES || max !== 1)) { + return -1; /* incomplete set */ + } + + /* generate offsets into symbol table for each length for sorting */ + offs[1] = 0; + for (len = 1; len < MAXBITS; len++) { + offs[len + 1] = offs[len] + count[len]; + } + + /* sort symbols by length, by symbol order within each length */ + for (sym = 0; sym < codes; sym++) { + if (lens[lens_index + sym] !== 0) { + work[offs[lens[lens_index + sym]]++] = sym; + } + } + + /* + Create and fill in decoding tables. In this loop, the table being + filled is at next and has curr index bits. The code being used is huff + with length len. That code is converted to an index by dropping drop + bits off of the bottom. For codes where len is less than drop + curr, + those top drop + curr - len bits are incremented through all values to + fill the table with replicated entries. + + root is the number of index bits for the root table. When len exceeds + root, sub-tables are created pointed to by the root entry with an index + of the low root bits of huff. This is saved in low to check for when a + new sub-table should be started. drop is zero when the root table is + being filled, and drop is root when sub-tables are being filled. + + When a new sub-table is needed, it is necessary to look ahead in the + code lengths to determine what size sub-table is needed. The length + counts are used for this, and so count[] is decremented as codes are + entered in the tables. + + used keeps track of how many table entries have been allocated from the + provided *table space. It is checked for LENS and DIST tables against + the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in + the initial root table size constants. See the comments in inftrees.h + for more information. + + sym increments through all symbols, and the loop terminates when + all codes of length max, i.e. all codes, have been processed. This + routine permits incomplete codes, so another loop after this one fills + in the rest of the decoding tables with invalid code markers. + */ + + /* set up for code type */ + // poor man optimization - use if-else instead of switch, + // to avoid deopts in old v8 + if (type === CODES) { + base = extra = work; /* dummy value--not used */ + end = 19; + + } else if (type === LENS) { + base = lbase; + base_index -= 257; + extra = lext; + extra_index -= 257; + end = 256; + + } else { /* DISTS */ + base = dbase; + extra = dext; + end = -1; + } + + /* initialize opts for loop */ + huff = 0; /* starting code */ + sym = 0; /* starting code symbol */ + len = min; /* starting code length */ + next = table_index; /* current table to fill in */ + curr = root; /* current table index bits */ + drop = 0; /* current bits to drop from code for index */ + low = -1; /* trigger new sub-table when len > root */ + used = 1 << root; /* use root table entries */ + mask = used - 1; /* mask for comparing low */ + + /* check available table space */ + if ((type === LENS && used > ENOUGH_LENS) || + (type === DISTS && used > ENOUGH_DISTS)) { + return 1; + } + + /* process all codes and make table entries */ + for (;;) { + /* create table entry */ + here_bits = len - drop; + if (work[sym] < end) { + here_op = 0; + here_val = work[sym]; + } + else if (work[sym] > end) { + here_op = extra[extra_index + work[sym]]; + here_val = base[base_index + work[sym]]; + } + else { + here_op = 32 + 64; /* end of block */ + here_val = 0; + } + + /* replicate for those indices with low len bits equal to huff */ + incr = 1 << (len - drop); + fill = 1 << curr; + min = fill; /* save offset to next table */ + do { + fill -= incr; + table[next + (huff >> drop) + fill] = (here_bits << 24) | (here_op << 16) | here_val |0; + } while (fill !== 0); + + /* backwards increment the len-bit code huff */ + incr = 1 << (len - 1); + while (huff & incr) { + incr >>= 1; + } + if (incr !== 0) { + huff &= incr - 1; + huff += incr; + } else { + huff = 0; + } + + /* go to next symbol, update count, len */ + sym++; + if (--count[len] === 0) { + if (len === max) { break; } + len = lens[lens_index + work[sym]]; + } + + /* create new sub-table if needed */ + if (len > root && (huff & mask) !== low) { + /* if first time, transition to sub-tables */ + if (drop === 0) { + drop = root; + } + + /* increment past last table */ + next += min; /* here min is 1 << curr */ + + /* determine length of next table */ + curr = len - drop; + left = 1 << curr; + while (curr + drop < max) { + left -= count[curr + drop]; + if (left <= 0) { break; } + curr++; + left <<= 1; + } + + /* check for enough space */ + used += 1 << curr; + if ((type === LENS && used > ENOUGH_LENS) || + (type === DISTS && used > ENOUGH_DISTS)) { + return 1; + } + + /* point entry in root table to sub-table */ + low = huff & mask; + /*table.op[low] = curr; + table.bits[low] = root; + table.val[low] = next - opts.table_index;*/ + table[low] = (root << 24) | (curr << 16) | (next - table_index) |0; + } + } + + /* fill in remaining table entry if code is incomplete (guaranteed to have + at most one remaining entry, since if the code is incomplete, the + maximum code length that was allowed to get this far is one bit) */ + if (huff !== 0) { + //table.op[next + huff] = 64; /* invalid code marker */ + //table.bits[next + huff] = len - drop; + //table.val[next + huff] = 0; + table[next + huff] = ((len - drop) << 24) | (64 << 16) |0; + } + + /* set return parameters */ + //opts.table_index += used; + opts.bits = root; + return 0; +}; + + +/***/ }), + +/***/ 8898: +/***/ ((module) => { + +"use strict"; + + +// (C) 1995-2013 Jean-loup Gailly and Mark Adler +// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin +// +// This software is provided 'as-is', without any express or implied +// warranty. In no event will the authors be held liable for any damages +// arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it +// freely, subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; you must not +// claim that you wrote the original software. If you use this software +// in a product, an acknowledgment in the product documentation would be +// appreciated but is not required. +// 2. Altered source versions must be plainly marked as such, and must not be +// misrepresented as being the original software. +// 3. This notice may not be removed or altered from any source distribution. + +module.exports = { + 2: 'need dictionary', /* Z_NEED_DICT 2 */ + 1: 'stream end', /* Z_STREAM_END 1 */ + 0: '', /* Z_OK 0 */ + '-1': 'file error', /* Z_ERRNO (-1) */ + '-2': 'stream error', /* Z_STREAM_ERROR (-2) */ + '-3': 'data error', /* Z_DATA_ERROR (-3) */ + '-4': 'insufficient memory', /* Z_MEM_ERROR (-4) */ + '-5': 'buffer error', /* Z_BUF_ERROR (-5) */ + '-6': 'incompatible version' /* Z_VERSION_ERROR (-6) */ +}; + + +/***/ }), + +/***/ 342: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + + +// (C) 1995-2013 Jean-loup Gailly and Mark Adler +// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin +// +// This software is provided 'as-is', without any express or implied +// warranty. In no event will the authors be held liable for any damages +// arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it +// freely, subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; you must not +// claim that you wrote the original software. If you use this software +// in a product, an acknowledgment in the product documentation would be +// appreciated but is not required. +// 2. Altered source versions must be plainly marked as such, and must not be +// misrepresented as being the original software. +// 3. This notice may not be removed or altered from any source distribution. + +/* eslint-disable space-unary-ops */ + +var utils = __webpack_require__(4236); + +/* Public constants ==========================================================*/ +/* ===========================================================================*/ + + +//var Z_FILTERED = 1; +//var Z_HUFFMAN_ONLY = 2; +//var Z_RLE = 3; +var Z_FIXED = 4; +//var Z_DEFAULT_STRATEGY = 0; + +/* Possible values of the data_type field (though see inflate()) */ +var Z_BINARY = 0; +var Z_TEXT = 1; +//var Z_ASCII = 1; // = Z_TEXT +var Z_UNKNOWN = 2; + +/*============================================================================*/ + + +function zero(buf) { var len = buf.length; while (--len >= 0) { buf[len] = 0; } } + +// From zutil.h + +var STORED_BLOCK = 0; +var STATIC_TREES = 1; +var DYN_TREES = 2; +/* The three kinds of block type */ + +var MIN_MATCH = 3; +var MAX_MATCH = 258; +/* The minimum and maximum match lengths */ + +// From deflate.h +/* =========================================================================== + * Internal compression state. + */ + +var LENGTH_CODES = 29; +/* number of length codes, not counting the special END_BLOCK code */ + +var LITERALS = 256; +/* number of literal bytes 0..255 */ + +var L_CODES = LITERALS + 1 + LENGTH_CODES; +/* number of Literal or Length codes, including the END_BLOCK code */ + +var D_CODES = 30; +/* number of distance codes */ + +var BL_CODES = 19; +/* number of codes used to transfer the bit lengths */ + +var HEAP_SIZE = 2 * L_CODES + 1; +/* maximum heap size */ + +var MAX_BITS = 15; +/* All codes must not exceed MAX_BITS bits */ + +var Buf_size = 16; +/* size of bit buffer in bi_buf */ + + +/* =========================================================================== + * Constants + */ + +var MAX_BL_BITS = 7; +/* Bit length codes must not exceed MAX_BL_BITS bits */ + +var END_BLOCK = 256; +/* end of block literal code */ + +var REP_3_6 = 16; +/* repeat previous bit length 3-6 times (2 bits of repeat count) */ + +var REPZ_3_10 = 17; +/* repeat a zero length 3-10 times (3 bits of repeat count) */ + +var REPZ_11_138 = 18; +/* repeat a zero length 11-138 times (7 bits of repeat count) */ + +/* eslint-disable comma-spacing,array-bracket-spacing */ +var extra_lbits = /* extra bits for each length code */ + [0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0]; + +var extra_dbits = /* extra bits for each distance code */ + [0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13]; + +var extra_blbits = /* extra bits for each bit length code */ + [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7]; + +var bl_order = + [16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15]; +/* eslint-enable comma-spacing,array-bracket-spacing */ + +/* The lengths of the bit length codes are sent in order of decreasing + * probability, to avoid transmitting the lengths for unused bit length codes. + */ + +/* =========================================================================== + * Local data. These are initialized only once. + */ + +// We pre-fill arrays with 0 to avoid uninitialized gaps + +var DIST_CODE_LEN = 512; /* see definition of array dist_code below */ + +// !!!! Use flat array instead of structure, Freq = i*2, Len = i*2+1 +var static_ltree = new Array((L_CODES + 2) * 2); +zero(static_ltree); +/* The static literal tree. Since the bit lengths are imposed, there is no + * need for the L_CODES extra codes used during heap construction. However + * The codes 286 and 287 are needed to build a canonical tree (see _tr_init + * below). + */ + +var static_dtree = new Array(D_CODES * 2); +zero(static_dtree); +/* The static distance tree. (Actually a trivial tree since all codes use + * 5 bits.) + */ + +var _dist_code = new Array(DIST_CODE_LEN); +zero(_dist_code); +/* Distance codes. The first 256 values correspond to the distances + * 3 .. 258, the last 256 values correspond to the top 8 bits of + * the 15 bit distances. + */ + +var _length_code = new Array(MAX_MATCH - MIN_MATCH + 1); +zero(_length_code); +/* length code for each normalized match length (0 == MIN_MATCH) */ + +var base_length = new Array(LENGTH_CODES); +zero(base_length); +/* First normalized length for each code (0 = MIN_MATCH) */ + +var base_dist = new Array(D_CODES); +zero(base_dist); +/* First normalized distance for each code (0 = distance of 1) */ + + +function StaticTreeDesc(static_tree, extra_bits, extra_base, elems, max_length) { + + this.static_tree = static_tree; /* static tree or NULL */ + this.extra_bits = extra_bits; /* extra bits for each code or NULL */ + this.extra_base = extra_base; /* base index for extra_bits */ + this.elems = elems; /* max number of elements in the tree */ + this.max_length = max_length; /* max bit length for the codes */ + + // show if `static_tree` has data or dummy - needed for monomorphic objects + this.has_stree = static_tree && static_tree.length; +} + + +var static_l_desc; +var static_d_desc; +var static_bl_desc; + + +function TreeDesc(dyn_tree, stat_desc) { + this.dyn_tree = dyn_tree; /* the dynamic tree */ + this.max_code = 0; /* largest code with non zero frequency */ + this.stat_desc = stat_desc; /* the corresponding static tree */ +} + + + +function d_code(dist) { + return dist < 256 ? _dist_code[dist] : _dist_code[256 + (dist >>> 7)]; +} + + +/* =========================================================================== + * Output a short LSB first on the stream. + * IN assertion: there is enough room in pendingBuf. + */ +function put_short(s, w) { +// put_byte(s, (uch)((w) & 0xff)); +// put_byte(s, (uch)((ush)(w) >> 8)); + s.pending_buf[s.pending++] = (w) & 0xff; + s.pending_buf[s.pending++] = (w >>> 8) & 0xff; +} + + +/* =========================================================================== + * Send a value on a given number of bits. + * IN assertion: length <= 16 and value fits in length bits. + */ +function send_bits(s, value, length) { + if (s.bi_valid > (Buf_size - length)) { + s.bi_buf |= (value << s.bi_valid) & 0xffff; + put_short(s, s.bi_buf); + s.bi_buf = value >> (Buf_size - s.bi_valid); + s.bi_valid += length - Buf_size; + } else { + s.bi_buf |= (value << s.bi_valid) & 0xffff; + s.bi_valid += length; + } +} + + +function send_code(s, c, tree) { + send_bits(s, tree[c * 2]/*.Code*/, tree[c * 2 + 1]/*.Len*/); +} + + +/* =========================================================================== + * Reverse the first len bits of a code, using straightforward code (a faster + * method would use a table) + * IN assertion: 1 <= len <= 15 + */ +function bi_reverse(code, len) { + var res = 0; + do { + res |= code & 1; + code >>>= 1; + res <<= 1; + } while (--len > 0); + return res >>> 1; +} + + +/* =========================================================================== + * Flush the bit buffer, keeping at most 7 bits in it. + */ +function bi_flush(s) { + if (s.bi_valid === 16) { + put_short(s, s.bi_buf); + s.bi_buf = 0; + s.bi_valid = 0; + + } else if (s.bi_valid >= 8) { + s.pending_buf[s.pending++] = s.bi_buf & 0xff; + s.bi_buf >>= 8; + s.bi_valid -= 8; + } +} + + +/* =========================================================================== + * Compute the optimal bit lengths for a tree and update the total bit length + * for the current block. + * IN assertion: the fields freq and dad are set, heap[heap_max] and + * above are the tree nodes sorted by increasing frequency. + * OUT assertions: the field len is set to the optimal bit length, the + * array bl_count contains the frequencies for each bit length. + * The length opt_len is updated; static_len is also updated if stree is + * not null. + */ +function gen_bitlen(s, desc) +// deflate_state *s; +// tree_desc *desc; /* the tree descriptor */ +{ + var tree = desc.dyn_tree; + var max_code = desc.max_code; + var stree = desc.stat_desc.static_tree; + var has_stree = desc.stat_desc.has_stree; + var extra = desc.stat_desc.extra_bits; + var base = desc.stat_desc.extra_base; + var max_length = desc.stat_desc.max_length; + var h; /* heap index */ + var n, m; /* iterate over the tree elements */ + var bits; /* bit length */ + var xbits; /* extra bits */ + var f; /* frequency */ + var overflow = 0; /* number of elements with bit length too large */ + + for (bits = 0; bits <= MAX_BITS; bits++) { + s.bl_count[bits] = 0; + } + + /* In a first pass, compute the optimal bit lengths (which may + * overflow in the case of the bit length tree). + */ + tree[s.heap[s.heap_max] * 2 + 1]/*.Len*/ = 0; /* root of the heap */ + + for (h = s.heap_max + 1; h < HEAP_SIZE; h++) { + n = s.heap[h]; + bits = tree[tree[n * 2 + 1]/*.Dad*/ * 2 + 1]/*.Len*/ + 1; + if (bits > max_length) { + bits = max_length; + overflow++; + } + tree[n * 2 + 1]/*.Len*/ = bits; + /* We overwrite tree[n].Dad which is no longer needed */ + + if (n > max_code) { continue; } /* not a leaf node */ + + s.bl_count[bits]++; + xbits = 0; + if (n >= base) { + xbits = extra[n - base]; + } + f = tree[n * 2]/*.Freq*/; + s.opt_len += f * (bits + xbits); + if (has_stree) { + s.static_len += f * (stree[n * 2 + 1]/*.Len*/ + xbits); + } + } + if (overflow === 0) { return; } + + // Trace((stderr,"\nbit length overflow\n")); + /* This happens for example on obj2 and pic of the Calgary corpus */ + + /* Find the first bit length which could increase: */ + do { + bits = max_length - 1; + while (s.bl_count[bits] === 0) { bits--; } + s.bl_count[bits]--; /* move one leaf down the tree */ + s.bl_count[bits + 1] += 2; /* move one overflow item as its brother */ + s.bl_count[max_length]--; + /* The brother of the overflow item also moves one step up, + * but this does not affect bl_count[max_length] + */ + overflow -= 2; + } while (overflow > 0); + + /* Now recompute all bit lengths, scanning in increasing frequency. + * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all + * lengths instead of fixing only the wrong ones. This idea is taken + * from 'ar' written by Haruhiko Okumura.) + */ + for (bits = max_length; bits !== 0; bits--) { + n = s.bl_count[bits]; + while (n !== 0) { + m = s.heap[--h]; + if (m > max_code) { continue; } + if (tree[m * 2 + 1]/*.Len*/ !== bits) { + // Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits)); + s.opt_len += (bits - tree[m * 2 + 1]/*.Len*/) * tree[m * 2]/*.Freq*/; + tree[m * 2 + 1]/*.Len*/ = bits; + } + n--; + } + } +} + + +/* =========================================================================== + * Generate the codes for a given tree and bit counts (which need not be + * optimal). + * IN assertion: the array bl_count contains the bit length statistics for + * the given tree and the field len is set for all tree elements. + * OUT assertion: the field code is set for all tree elements of non + * zero code length. + */ +function gen_codes(tree, max_code, bl_count) +// ct_data *tree; /* the tree to decorate */ +// int max_code; /* largest code with non zero frequency */ +// ushf *bl_count; /* number of codes at each bit length */ +{ + var next_code = new Array(MAX_BITS + 1); /* next code value for each bit length */ + var code = 0; /* running code value */ + var bits; /* bit index */ + var n; /* code index */ + + /* The distribution counts are first used to generate the code values + * without bit reversal. + */ + for (bits = 1; bits <= MAX_BITS; bits++) { + next_code[bits] = code = (code + bl_count[bits - 1]) << 1; + } + /* Check that the bit counts in bl_count are consistent. The last code + * must be all ones. + */ + //Assert (code + bl_count[MAX_BITS]-1 == (1< length code (0..28) */ + length = 0; + for (code = 0; code < LENGTH_CODES - 1; code++) { + base_length[code] = length; + for (n = 0; n < (1 << extra_lbits[code]); n++) { + _length_code[length++] = code; + } + } + //Assert (length == 256, "tr_static_init: length != 256"); + /* Note that the length 255 (match length 258) can be represented + * in two different ways: code 284 + 5 bits or code 285, so we + * overwrite length_code[255] to use the best encoding: + */ + _length_code[length - 1] = code; + + /* Initialize the mapping dist (0..32K) -> dist code (0..29) */ + dist = 0; + for (code = 0; code < 16; code++) { + base_dist[code] = dist; + for (n = 0; n < (1 << extra_dbits[code]); n++) { + _dist_code[dist++] = code; + } + } + //Assert (dist == 256, "tr_static_init: dist != 256"); + dist >>= 7; /* from now on, all distances are divided by 128 */ + for (; code < D_CODES; code++) { + base_dist[code] = dist << 7; + for (n = 0; n < (1 << (extra_dbits[code] - 7)); n++) { + _dist_code[256 + dist++] = code; + } + } + //Assert (dist == 256, "tr_static_init: 256+dist != 512"); + + /* Construct the codes of the static literal tree */ + for (bits = 0; bits <= MAX_BITS; bits++) { + bl_count[bits] = 0; + } + + n = 0; + while (n <= 143) { + static_ltree[n * 2 + 1]/*.Len*/ = 8; + n++; + bl_count[8]++; + } + while (n <= 255) { + static_ltree[n * 2 + 1]/*.Len*/ = 9; + n++; + bl_count[9]++; + } + while (n <= 279) { + static_ltree[n * 2 + 1]/*.Len*/ = 7; + n++; + bl_count[7]++; + } + while (n <= 287) { + static_ltree[n * 2 + 1]/*.Len*/ = 8; + n++; + bl_count[8]++; + } + /* Codes 286 and 287 do not exist, but we must include them in the + * tree construction to get a canonical Huffman tree (longest code + * all ones) + */ + gen_codes(static_ltree, L_CODES + 1, bl_count); + + /* The static distance tree is trivial: */ + for (n = 0; n < D_CODES; n++) { + static_dtree[n * 2 + 1]/*.Len*/ = 5; + static_dtree[n * 2]/*.Code*/ = bi_reverse(n, 5); + } + + // Now data ready and we can init static trees + static_l_desc = new StaticTreeDesc(static_ltree, extra_lbits, LITERALS + 1, L_CODES, MAX_BITS); + static_d_desc = new StaticTreeDesc(static_dtree, extra_dbits, 0, D_CODES, MAX_BITS); + static_bl_desc = new StaticTreeDesc(new Array(0), extra_blbits, 0, BL_CODES, MAX_BL_BITS); + + //static_init_done = true; +} + + +/* =========================================================================== + * Initialize a new block. + */ +function init_block(s) { + var n; /* iterates over tree elements */ + + /* Initialize the trees. */ + for (n = 0; n < L_CODES; n++) { s.dyn_ltree[n * 2]/*.Freq*/ = 0; } + for (n = 0; n < D_CODES; n++) { s.dyn_dtree[n * 2]/*.Freq*/ = 0; } + for (n = 0; n < BL_CODES; n++) { s.bl_tree[n * 2]/*.Freq*/ = 0; } + + s.dyn_ltree[END_BLOCK * 2]/*.Freq*/ = 1; + s.opt_len = s.static_len = 0; + s.last_lit = s.matches = 0; +} + + +/* =========================================================================== + * Flush the bit buffer and align the output on a byte boundary + */ +function bi_windup(s) +{ + if (s.bi_valid > 8) { + put_short(s, s.bi_buf); + } else if (s.bi_valid > 0) { + //put_byte(s, (Byte)s->bi_buf); + s.pending_buf[s.pending++] = s.bi_buf; + } + s.bi_buf = 0; + s.bi_valid = 0; +} + +/* =========================================================================== + * Copy a stored block, storing first the length and its + * one's complement if requested. + */ +function copy_block(s, buf, len, header) +//DeflateState *s; +//charf *buf; /* the input data */ +//unsigned len; /* its length */ +//int header; /* true if block header must be written */ +{ + bi_windup(s); /* align on byte boundary */ + + if (header) { + put_short(s, len); + put_short(s, ~len); + } +// while (len--) { +// put_byte(s, *buf++); +// } + utils.arraySet(s.pending_buf, s.window, buf, len, s.pending); + s.pending += len; +} + +/* =========================================================================== + * Compares to subtrees, using the tree depth as tie breaker when + * the subtrees have equal frequency. This minimizes the worst case length. + */ +function smaller(tree, n, m, depth) { + var _n2 = n * 2; + var _m2 = m * 2; + return (tree[_n2]/*.Freq*/ < tree[_m2]/*.Freq*/ || + (tree[_n2]/*.Freq*/ === tree[_m2]/*.Freq*/ && depth[n] <= depth[m])); +} + +/* =========================================================================== + * Restore the heap property by moving down the tree starting at node k, + * exchanging a node with the smallest of its two sons if necessary, stopping + * when the heap property is re-established (each father smaller than its + * two sons). + */ +function pqdownheap(s, tree, k) +// deflate_state *s; +// ct_data *tree; /* the tree to restore */ +// int k; /* node to move down */ +{ + var v = s.heap[k]; + var j = k << 1; /* left son of k */ + while (j <= s.heap_len) { + /* Set j to the smallest of the two sons: */ + if (j < s.heap_len && + smaller(tree, s.heap[j + 1], s.heap[j], s.depth)) { + j++; + } + /* Exit if v is smaller than both sons */ + if (smaller(tree, v, s.heap[j], s.depth)) { break; } + + /* Exchange v with the smallest son */ + s.heap[k] = s.heap[j]; + k = j; + + /* And continue down the tree, setting j to the left son of k */ + j <<= 1; + } + s.heap[k] = v; +} + + +// inlined manually +// var SMALLEST = 1; + +/* =========================================================================== + * Send the block data compressed using the given Huffman trees + */ +function compress_block(s, ltree, dtree) +// deflate_state *s; +// const ct_data *ltree; /* literal tree */ +// const ct_data *dtree; /* distance tree */ +{ + var dist; /* distance of matched string */ + var lc; /* match length or unmatched char (if dist == 0) */ + var lx = 0; /* running index in l_buf */ + var code; /* the code to send */ + var extra; /* number of extra bits to send */ + + if (s.last_lit !== 0) { + do { + dist = (s.pending_buf[s.d_buf + lx * 2] << 8) | (s.pending_buf[s.d_buf + lx * 2 + 1]); + lc = s.pending_buf[s.l_buf + lx]; + lx++; + + if (dist === 0) { + send_code(s, lc, ltree); /* send a literal byte */ + //Tracecv(isgraph(lc), (stderr," '%c' ", lc)); + } else { + /* Here, lc is the match length - MIN_MATCH */ + code = _length_code[lc]; + send_code(s, code + LITERALS + 1, ltree); /* send the length code */ + extra = extra_lbits[code]; + if (extra !== 0) { + lc -= base_length[code]; + send_bits(s, lc, extra); /* send the extra length bits */ + } + dist--; /* dist is now the match distance - 1 */ + code = d_code(dist); + //Assert (code < D_CODES, "bad d_code"); + + send_code(s, code, dtree); /* send the distance code */ + extra = extra_dbits[code]; + if (extra !== 0) { + dist -= base_dist[code]; + send_bits(s, dist, extra); /* send the extra distance bits */ + } + } /* literal or match pair ? */ + + /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */ + //Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx, + // "pendingBuf overflow"); + + } while (lx < s.last_lit); + } + + send_code(s, END_BLOCK, ltree); +} + + +/* =========================================================================== + * Construct one Huffman tree and assigns the code bit strings and lengths. + * Update the total bit length for the current block. + * IN assertion: the field freq is set for all tree elements. + * OUT assertions: the fields len and code are set to the optimal bit length + * and corresponding code. The length opt_len is updated; static_len is + * also updated if stree is not null. The field max_code is set. + */ +function build_tree(s, desc) +// deflate_state *s; +// tree_desc *desc; /* the tree descriptor */ +{ + var tree = desc.dyn_tree; + var stree = desc.stat_desc.static_tree; + var has_stree = desc.stat_desc.has_stree; + var elems = desc.stat_desc.elems; + var n, m; /* iterate over heap elements */ + var max_code = -1; /* largest code with non zero frequency */ + var node; /* new node being created */ + + /* Construct the initial heap, with least frequent element in + * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1]. + * heap[0] is not used. + */ + s.heap_len = 0; + s.heap_max = HEAP_SIZE; + + for (n = 0; n < elems; n++) { + if (tree[n * 2]/*.Freq*/ !== 0) { + s.heap[++s.heap_len] = max_code = n; + s.depth[n] = 0; + + } else { + tree[n * 2 + 1]/*.Len*/ = 0; + } + } + + /* The pkzip format requires that at least one distance code exists, + * and that at least one bit should be sent even if there is only one + * possible code. So to avoid special checks later on we force at least + * two codes of non zero frequency. + */ + while (s.heap_len < 2) { + node = s.heap[++s.heap_len] = (max_code < 2 ? ++max_code : 0); + tree[node * 2]/*.Freq*/ = 1; + s.depth[node] = 0; + s.opt_len--; + + if (has_stree) { + s.static_len -= stree[node * 2 + 1]/*.Len*/; + } + /* node is 0 or 1 so it does not have extra bits */ + } + desc.max_code = max_code; + + /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree, + * establish sub-heaps of increasing lengths: + */ + for (n = (s.heap_len >> 1/*int /2*/); n >= 1; n--) { pqdownheap(s, tree, n); } + + /* Construct the Huffman tree by repeatedly combining the least two + * frequent nodes. + */ + node = elems; /* next internal node of the tree */ + do { + //pqremove(s, tree, n); /* n = node of least frequency */ + /*** pqremove ***/ + n = s.heap[1/*SMALLEST*/]; + s.heap[1/*SMALLEST*/] = s.heap[s.heap_len--]; + pqdownheap(s, tree, 1/*SMALLEST*/); + /***/ + + m = s.heap[1/*SMALLEST*/]; /* m = node of next least frequency */ + + s.heap[--s.heap_max] = n; /* keep the nodes sorted by frequency */ + s.heap[--s.heap_max] = m; + + /* Create a new node father of n and m */ + tree[node * 2]/*.Freq*/ = tree[n * 2]/*.Freq*/ + tree[m * 2]/*.Freq*/; + s.depth[node] = (s.depth[n] >= s.depth[m] ? s.depth[n] : s.depth[m]) + 1; + tree[n * 2 + 1]/*.Dad*/ = tree[m * 2 + 1]/*.Dad*/ = node; + + /* and insert the new node in the heap */ + s.heap[1/*SMALLEST*/] = node++; + pqdownheap(s, tree, 1/*SMALLEST*/); + + } while (s.heap_len >= 2); + + s.heap[--s.heap_max] = s.heap[1/*SMALLEST*/]; + + /* At this point, the fields freq and dad are set. We can now + * generate the bit lengths. + */ + gen_bitlen(s, desc); + + /* The field len is now set, we can generate the bit codes */ + gen_codes(tree, max_code, s.bl_count); +} + + +/* =========================================================================== + * Scan a literal or distance tree to determine the frequencies of the codes + * in the bit length tree. + */ +function scan_tree(s, tree, max_code) +// deflate_state *s; +// ct_data *tree; /* the tree to be scanned */ +// int max_code; /* and its largest code of non zero frequency */ +{ + var n; /* iterates over all tree elements */ + var prevlen = -1; /* last emitted length */ + var curlen; /* length of current code */ + + var nextlen = tree[0 * 2 + 1]/*.Len*/; /* length of next code */ + + var count = 0; /* repeat count of the current code */ + var max_count = 7; /* max repeat count */ + var min_count = 4; /* min repeat count */ + + if (nextlen === 0) { + max_count = 138; + min_count = 3; + } + tree[(max_code + 1) * 2 + 1]/*.Len*/ = 0xffff; /* guard */ + + for (n = 0; n <= max_code; n++) { + curlen = nextlen; + nextlen = tree[(n + 1) * 2 + 1]/*.Len*/; + + if (++count < max_count && curlen === nextlen) { + continue; + + } else if (count < min_count) { + s.bl_tree[curlen * 2]/*.Freq*/ += count; + + } else if (curlen !== 0) { + + if (curlen !== prevlen) { s.bl_tree[curlen * 2]/*.Freq*/++; } + s.bl_tree[REP_3_6 * 2]/*.Freq*/++; + + } else if (count <= 10) { + s.bl_tree[REPZ_3_10 * 2]/*.Freq*/++; + + } else { + s.bl_tree[REPZ_11_138 * 2]/*.Freq*/++; + } + + count = 0; + prevlen = curlen; + + if (nextlen === 0) { + max_count = 138; + min_count = 3; + + } else if (curlen === nextlen) { + max_count = 6; + min_count = 3; + + } else { + max_count = 7; + min_count = 4; + } + } +} + + +/* =========================================================================== + * Send a literal or distance tree in compressed form, using the codes in + * bl_tree. + */ +function send_tree(s, tree, max_code) +// deflate_state *s; +// ct_data *tree; /* the tree to be scanned */ +// int max_code; /* and its largest code of non zero frequency */ +{ + var n; /* iterates over all tree elements */ + var prevlen = -1; /* last emitted length */ + var curlen; /* length of current code */ + + var nextlen = tree[0 * 2 + 1]/*.Len*/; /* length of next code */ + + var count = 0; /* repeat count of the current code */ + var max_count = 7; /* max repeat count */ + var min_count = 4; /* min repeat count */ + + /* tree[max_code+1].Len = -1; */ /* guard already set */ + if (nextlen === 0) { + max_count = 138; + min_count = 3; + } + + for (n = 0; n <= max_code; n++) { + curlen = nextlen; + nextlen = tree[(n + 1) * 2 + 1]/*.Len*/; + + if (++count < max_count && curlen === nextlen) { + continue; + + } else if (count < min_count) { + do { send_code(s, curlen, s.bl_tree); } while (--count !== 0); + + } else if (curlen !== 0) { + if (curlen !== prevlen) { + send_code(s, curlen, s.bl_tree); + count--; + } + //Assert(count >= 3 && count <= 6, " 3_6?"); + send_code(s, REP_3_6, s.bl_tree); + send_bits(s, count - 3, 2); + + } else if (count <= 10) { + send_code(s, REPZ_3_10, s.bl_tree); + send_bits(s, count - 3, 3); + + } else { + send_code(s, REPZ_11_138, s.bl_tree); + send_bits(s, count - 11, 7); + } + + count = 0; + prevlen = curlen; + if (nextlen === 0) { + max_count = 138; + min_count = 3; + + } else if (curlen === nextlen) { + max_count = 6; + min_count = 3; + + } else { + max_count = 7; + min_count = 4; + } + } +} + + +/* =========================================================================== + * Construct the Huffman tree for the bit lengths and return the index in + * bl_order of the last bit length code to send. + */ +function build_bl_tree(s) { + var max_blindex; /* index of last bit length code of non zero freq */ + + /* Determine the bit length frequencies for literal and distance trees */ + scan_tree(s, s.dyn_ltree, s.l_desc.max_code); + scan_tree(s, s.dyn_dtree, s.d_desc.max_code); + + /* Build the bit length tree: */ + build_tree(s, s.bl_desc); + /* opt_len now includes the length of the tree representations, except + * the lengths of the bit lengths codes and the 5+5+4 bits for the counts. + */ + + /* Determine the number of bit length codes to send. The pkzip format + * requires that at least 4 bit length codes be sent. (appnote.txt says + * 3 but the actual value used is 4.) + */ + for (max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) { + if (s.bl_tree[bl_order[max_blindex] * 2 + 1]/*.Len*/ !== 0) { + break; + } + } + /* Update opt_len to include the bit length tree and counts */ + s.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4; + //Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld", + // s->opt_len, s->static_len)); + + return max_blindex; +} + + +/* =========================================================================== + * Send the header for a block using dynamic Huffman trees: the counts, the + * lengths of the bit length codes, the literal tree and the distance tree. + * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4. + */ +function send_all_trees(s, lcodes, dcodes, blcodes) +// deflate_state *s; +// int lcodes, dcodes, blcodes; /* number of codes for each tree */ +{ + var rank; /* index in bl_order */ + + //Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes"); + //Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES, + // "too many codes"); + //Tracev((stderr, "\nbl counts: ")); + send_bits(s, lcodes - 257, 5); /* not +255 as stated in appnote.txt */ + send_bits(s, dcodes - 1, 5); + send_bits(s, blcodes - 4, 4); /* not -3 as stated in appnote.txt */ + for (rank = 0; rank < blcodes; rank++) { + //Tracev((stderr, "\nbl code %2d ", bl_order[rank])); + send_bits(s, s.bl_tree[bl_order[rank] * 2 + 1]/*.Len*/, 3); + } + //Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent)); + + send_tree(s, s.dyn_ltree, lcodes - 1); /* literal tree */ + //Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent)); + + send_tree(s, s.dyn_dtree, dcodes - 1); /* distance tree */ + //Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent)); +} + + +/* =========================================================================== + * Check if the data type is TEXT or BINARY, using the following algorithm: + * - TEXT if the two conditions below are satisfied: + * a) There are no non-portable control characters belonging to the + * "black list" (0..6, 14..25, 28..31). + * b) There is at least one printable character belonging to the + * "white list" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255). + * - BINARY otherwise. + * - The following partially-portable control characters form a + * "gray list" that is ignored in this detection algorithm: + * (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 {ESC}). + * IN assertion: the fields Freq of dyn_ltree are set. + */ +function detect_data_type(s) { + /* black_mask is the bit mask of black-listed bytes + * set bits 0..6, 14..25, and 28..31 + * 0xf3ffc07f = binary 11110011111111111100000001111111 + */ + var black_mask = 0xf3ffc07f; + var n; + + /* Check for non-textual ("black-listed") bytes. */ + for (n = 0; n <= 31; n++, black_mask >>>= 1) { + if ((black_mask & 1) && (s.dyn_ltree[n * 2]/*.Freq*/ !== 0)) { + return Z_BINARY; + } + } + + /* Check for textual ("white-listed") bytes. */ + if (s.dyn_ltree[9 * 2]/*.Freq*/ !== 0 || s.dyn_ltree[10 * 2]/*.Freq*/ !== 0 || + s.dyn_ltree[13 * 2]/*.Freq*/ !== 0) { + return Z_TEXT; + } + for (n = 32; n < LITERALS; n++) { + if (s.dyn_ltree[n * 2]/*.Freq*/ !== 0) { + return Z_TEXT; + } + } + + /* There are no "black-listed" or "white-listed" bytes: + * this stream either is empty or has tolerated ("gray-listed") bytes only. + */ + return Z_BINARY; +} + + +var static_init_done = false; + +/* =========================================================================== + * Initialize the tree data structures for a new zlib stream. + */ +function _tr_init(s) +{ + + if (!static_init_done) { + tr_static_init(); + static_init_done = true; + } + + s.l_desc = new TreeDesc(s.dyn_ltree, static_l_desc); + s.d_desc = new TreeDesc(s.dyn_dtree, static_d_desc); + s.bl_desc = new TreeDesc(s.bl_tree, static_bl_desc); + + s.bi_buf = 0; + s.bi_valid = 0; + + /* Initialize the first block of the first file: */ + init_block(s); +} + + +/* =========================================================================== + * Send a stored block + */ +function _tr_stored_block(s, buf, stored_len, last) +//DeflateState *s; +//charf *buf; /* input block */ +//ulg stored_len; /* length of input block */ +//int last; /* one if this is the last block for a file */ +{ + send_bits(s, (STORED_BLOCK << 1) + (last ? 1 : 0), 3); /* send block type */ + copy_block(s, buf, stored_len, true); /* with header */ +} + + +/* =========================================================================== + * Send one empty static block to give enough lookahead for inflate. + * This takes 10 bits, of which 7 may remain in the bit buffer. + */ +function _tr_align(s) { + send_bits(s, STATIC_TREES << 1, 3); + send_code(s, END_BLOCK, static_ltree); + bi_flush(s); +} + + +/* =========================================================================== + * Determine the best encoding for the current block: dynamic trees, static + * trees or store, and output the encoded block to the zip file. + */ +function _tr_flush_block(s, buf, stored_len, last) +//DeflateState *s; +//charf *buf; /* input block, or NULL if too old */ +//ulg stored_len; /* length of input block */ +//int last; /* one if this is the last block for a file */ +{ + var opt_lenb, static_lenb; /* opt_len and static_len in bytes */ + var max_blindex = 0; /* index of last bit length code of non zero freq */ + + /* Build the Huffman trees unless a stored block is forced */ + if (s.level > 0) { + + /* Check if the file is binary or text */ + if (s.strm.data_type === Z_UNKNOWN) { + s.strm.data_type = detect_data_type(s); + } + + /* Construct the literal and distance trees */ + build_tree(s, s.l_desc); + // Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len, + // s->static_len)); + + build_tree(s, s.d_desc); + // Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len, + // s->static_len)); + /* At this point, opt_len and static_len are the total bit lengths of + * the compressed block data, excluding the tree representations. + */ + + /* Build the bit length tree for the above two trees, and get the index + * in bl_order of the last bit length code to send. + */ + max_blindex = build_bl_tree(s); + + /* Determine the best encoding. Compute the block lengths in bytes. */ + opt_lenb = (s.opt_len + 3 + 7) >>> 3; + static_lenb = (s.static_len + 3 + 7) >>> 3; + + // Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ", + // opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len, + // s->last_lit)); + + if (static_lenb <= opt_lenb) { opt_lenb = static_lenb; } + + } else { + // Assert(buf != (char*)0, "lost buf"); + opt_lenb = static_lenb = stored_len + 5; /* force a stored block */ + } + + if ((stored_len + 4 <= opt_lenb) && (buf !== -1)) { + /* 4: two words for the lengths */ + + /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE. + * Otherwise we can't have processed more than WSIZE input bytes since + * the last block flush, because compression would have been + * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to + * transform a block into a stored block. + */ + _tr_stored_block(s, buf, stored_len, last); + + } else if (s.strategy === Z_FIXED || static_lenb === opt_lenb) { + + send_bits(s, (STATIC_TREES << 1) + (last ? 1 : 0), 3); + compress_block(s, static_ltree, static_dtree); + + } else { + send_bits(s, (DYN_TREES << 1) + (last ? 1 : 0), 3); + send_all_trees(s, s.l_desc.max_code + 1, s.d_desc.max_code + 1, max_blindex + 1); + compress_block(s, s.dyn_ltree, s.dyn_dtree); + } + // Assert (s->compressed_len == s->bits_sent, "bad compressed size"); + /* The above check is made mod 2^32, for files larger than 512 MB + * and uLong implemented on 32 bits. + */ + init_block(s); + + if (last) { + bi_windup(s); + } + // Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3, + // s->compressed_len-7*last)); +} + +/* =========================================================================== + * Save the match info and tally the frequency counts. Return true if + * the current block must be flushed. + */ +function _tr_tally(s, dist, lc) +// deflate_state *s; +// unsigned dist; /* distance of matched string */ +// unsigned lc; /* match length-MIN_MATCH or unmatched char (if dist==0) */ +{ + //var out_length, in_length, dcode; + + s.pending_buf[s.d_buf + s.last_lit * 2] = (dist >>> 8) & 0xff; + s.pending_buf[s.d_buf + s.last_lit * 2 + 1] = dist & 0xff; + + s.pending_buf[s.l_buf + s.last_lit] = lc & 0xff; + s.last_lit++; + + if (dist === 0) { + /* lc is the unmatched char */ + s.dyn_ltree[lc * 2]/*.Freq*/++; + } else { + s.matches++; + /* Here, lc is the match length - MIN_MATCH */ + dist--; /* dist = match distance - 1 */ + //Assert((ush)dist < (ush)MAX_DIST(s) && + // (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) && + // (ush)d_code(dist) < (ush)D_CODES, "_tr_tally: bad match"); + + s.dyn_ltree[(_length_code[lc] + LITERALS + 1) * 2]/*.Freq*/++; + s.dyn_dtree[d_code(dist) * 2]/*.Freq*/++; + } + +// (!) This block is disabled in zlib defaults, +// don't enable it for binary compatibility + +//#ifdef TRUNCATE_BLOCK +// /* Try to guess if it is profitable to stop the current block here */ +// if ((s.last_lit & 0x1fff) === 0 && s.level > 2) { +// /* Compute an upper bound for the compressed length */ +// out_length = s.last_lit*8; +// in_length = s.strstart - s.block_start; +// +// for (dcode = 0; dcode < D_CODES; dcode++) { +// out_length += s.dyn_dtree[dcode*2]/*.Freq*/ * (5 + extra_dbits[dcode]); +// } +// out_length >>>= 3; +// //Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ", +// // s->last_lit, in_length, out_length, +// // 100L - out_length*100L/in_length)); +// if (s.matches < (s.last_lit>>1)/*int /2*/ && out_length < (in_length>>1)/*int /2*/) { +// return true; +// } +// } +//#endif + + return (s.last_lit === s.lit_bufsize - 1); + /* We avoid equality with lit_bufsize because of wraparound at 64K + * on 16 bit machines and because stored blocks are restricted to + * 64K-1 bytes. + */ +} + +exports._tr_init = _tr_init; +exports._tr_stored_block = _tr_stored_block; +exports._tr_flush_block = _tr_flush_block; +exports._tr_tally = _tr_tally; +exports._tr_align = _tr_align; + + +/***/ }), + +/***/ 2292: +/***/ ((module) => { + +"use strict"; + + +// (C) 1995-2013 Jean-loup Gailly and Mark Adler +// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin +// +// This software is provided 'as-is', without any express or implied +// warranty. In no event will the authors be held liable for any damages +// arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it +// freely, subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; you must not +// claim that you wrote the original software. If you use this software +// in a product, an acknowledgment in the product documentation would be +// appreciated but is not required. +// 2. Altered source versions must be plainly marked as such, and must not be +// misrepresented as being the original software. +// 3. This notice may not be removed or altered from any source distribution. + +function ZStream() { + /* next input byte */ + this.input = null; // JS specific, because we have no pointers + this.next_in = 0; + /* number of bytes available at input */ + this.avail_in = 0; + /* total number of input bytes read so far */ + this.total_in = 0; + /* next output byte should be put there */ + this.output = null; // JS specific, because we have no pointers + this.next_out = 0; + /* remaining free space at output */ + this.avail_out = 0; + /* total number of bytes output so far */ + this.total_out = 0; + /* last error message, NULL if no error */ + this.msg = ''/*Z_NULL*/; + /* not visible by applications */ + this.state = null; + /* best guess about the data type: binary or text */ + this.data_type = 2/*Z_UNKNOWN*/; + /* adler32 value of the uncompressed data */ + this.adler = 0; +} + +module.exports = ZStream; + + +/***/ }), + +/***/ 4155: +/***/ ((module) => { + +// shim for using process in browser +var process = module.exports = {}; + +// cached from whatever global is present so that test runners that stub it +// don't break things. But we need to wrap it in a try catch in case it is +// wrapped in strict mode code which doesn't define any globals. It's inside a +// function because try/catches deoptimize in certain engines. + +var cachedSetTimeout; +var cachedClearTimeout; + +function defaultSetTimout() { + throw new Error('setTimeout has not been defined'); +} +function defaultClearTimeout () { + throw new Error('clearTimeout has not been defined'); +} +(function () { + try { + if (typeof setTimeout === 'function') { + cachedSetTimeout = setTimeout; + } else { + cachedSetTimeout = defaultSetTimout; + } + } catch (e) { + cachedSetTimeout = defaultSetTimout; + } + try { + if (typeof clearTimeout === 'function') { + cachedClearTimeout = clearTimeout; + } else { + cachedClearTimeout = defaultClearTimeout; + } + } catch (e) { + cachedClearTimeout = defaultClearTimeout; + } +} ()) +function runTimeout(fun) { + if (cachedSetTimeout === setTimeout) { + //normal enviroments in sane situations + return setTimeout(fun, 0); + } + // if setTimeout wasn't available but was latter defined + if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { + cachedSetTimeout = setTimeout; + return setTimeout(fun, 0); + } + try { + // when when somebody has screwed with setTimeout but no I.E. maddness + return cachedSetTimeout(fun, 0); + } catch(e){ + try { + // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally + return cachedSetTimeout.call(null, fun, 0); + } catch(e){ + // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error + return cachedSetTimeout.call(this, fun, 0); + } + } + + +} +function runClearTimeout(marker) { + if (cachedClearTimeout === clearTimeout) { + //normal enviroments in sane situations + return clearTimeout(marker); + } + // if clearTimeout wasn't available but was latter defined + if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { + cachedClearTimeout = clearTimeout; + return clearTimeout(marker); + } + try { + // when when somebody has screwed with setTimeout but no I.E. maddness + return cachedClearTimeout(marker); + } catch (e){ + try { + // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally + return cachedClearTimeout.call(null, marker); + } catch (e){ + // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error. + // Some versions of I.E. have different rules for clearTimeout vs setTimeout + return cachedClearTimeout.call(this, marker); + } + } + + + +} +var queue = []; +var draining = false; +var currentQueue; +var queueIndex = -1; + +function cleanUpNextTick() { + if (!draining || !currentQueue) { + return; + } + draining = false; + if (currentQueue.length) { + queue = currentQueue.concat(queue); + } else { + queueIndex = -1; + } + if (queue.length) { + drainQueue(); + } +} + +function drainQueue() { + if (draining) { + return; + } + var timeout = runTimeout(cleanUpNextTick); + draining = true; + + var len = queue.length; + while(len) { + currentQueue = queue; + queue = []; + while (++queueIndex < len) { + if (currentQueue) { + currentQueue[queueIndex].run(); + } + } + queueIndex = -1; + len = queue.length; + } + currentQueue = null; + draining = false; + runClearTimeout(timeout); +} + +process.nextTick = function (fun) { + var args = new Array(arguments.length - 1); + if (arguments.length > 1) { + for (var i = 1; i < arguments.length; i++) { + args[i - 1] = arguments[i]; + } + } + queue.push(new Item(fun, args)); + if (queue.length === 1 && !draining) { + runTimeout(drainQueue); + } +}; + +// v8 likes predictible objects +function Item(fun, array) { + this.fun = fun; + this.array = array; +} +Item.prototype.run = function () { + this.fun.apply(null, this.array); +}; +process.title = 'browser'; +process.browser = true; +process.env = {}; +process.argv = []; +process.version = ''; // empty string to avoid regexp issues +process.versions = {}; + +function noop() {} + +process.on = noop; +process.addListener = noop; +process.once = noop; +process.off = noop; +process.removeListener = noop; +process.removeAllListeners = noop; +process.emit = noop; +process.prependListener = noop; +process.prependOnceListener = noop; + +process.listeners = function (name) { return [] } + +process.binding = function (name) { + throw new Error('process.binding is not supported'); +}; + +process.cwd = function () { return '/' }; +process.chdir = function (dir) { + throw new Error('process.chdir is not supported'); +}; +process.umask = function() { return 0; }; + + +/***/ }), + +/***/ 4585: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; +var __webpack_unused_export__; +/*! + * MIT License + * + * Copyright (c) 2017-2022 Peculiar Ventures, LLC + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + */ + + + +__webpack_unused_export__ = ({ value: true }); + +const ARRAY_BUFFER_NAME = "[object ArrayBuffer]"; +class BufferSourceConverter { + static isArrayBuffer(data) { + return Object.prototype.toString.call(data) === ARRAY_BUFFER_NAME; + } + static toArrayBuffer(data) { + if (this.isArrayBuffer(data)) { + return data; + } + if (data.byteLength === data.buffer.byteLength) { + return data.buffer; + } + return this.toUint8Array(data).slice().buffer; + } + static toUint8Array(data) { + return this.toView(data, Uint8Array); + } + static toView(data, type) { + if (data.constructor === type) { + return data; + } + if (this.isArrayBuffer(data)) { + return new type(data); + } + if (this.isArrayBufferView(data)) { + return new type(data.buffer, data.byteOffset, data.byteLength); + } + throw new TypeError("The provided value is not of type '(ArrayBuffer or ArrayBufferView)'"); + } + static isBufferSource(data) { + return this.isArrayBufferView(data) + || this.isArrayBuffer(data); + } + static isArrayBufferView(data) { + return ArrayBuffer.isView(data) + || (data && this.isArrayBuffer(data.buffer)); + } + static isEqual(a, b) { + const aView = BufferSourceConverter.toUint8Array(a); + const bView = BufferSourceConverter.toUint8Array(b); + if (aView.length !== bView.byteLength) { + return false; + } + for (let i = 0; i < aView.length; i++) { + if (aView[i] !== bView[i]) { + return false; + } + } + return true; + } + static concat(...args) { + if (Array.isArray(args[0])) { + const buffers = args[0]; + let size = 0; + for (const buffer of buffers) { + size += buffer.byteLength; + } + const res = new Uint8Array(size); + let offset = 0; + for (const buffer of buffers) { + const view = this.toUint8Array(buffer); + res.set(view, offset); + offset += view.length; + } + if (args[1]) { + return this.toView(res, args[1]); + } + return res.buffer; + } + else { + return this.concat(args); + } + } +} + +class Utf8Converter { + static fromString(text) { + const s = unescape(encodeURIComponent(text)); + const uintArray = new Uint8Array(s.length); + for (let i = 0; i < s.length; i++) { + uintArray[i] = s.charCodeAt(i); + } + return uintArray.buffer; + } + static toString(buffer) { + const buf = BufferSourceConverter.toUint8Array(buffer); + let encodedString = ""; + for (let i = 0; i < buf.length; i++) { + encodedString += String.fromCharCode(buf[i]); + } + const decodedString = decodeURIComponent(escape(encodedString)); + return decodedString; + } +} +class Utf16Converter { + static toString(buffer, littleEndian = false) { + const arrayBuffer = BufferSourceConverter.toArrayBuffer(buffer); + const dataView = new DataView(arrayBuffer); + let res = ""; + for (let i = 0; i < arrayBuffer.byteLength; i += 2) { + const code = dataView.getUint16(i, littleEndian); + res += String.fromCharCode(code); + } + return res; + } + static fromString(text, littleEndian = false) { + const res = new ArrayBuffer(text.length * 2); + const dataView = new DataView(res); + for (let i = 0; i < text.length; i++) { + dataView.setUint16(i * 2, text.charCodeAt(i), littleEndian); + } + return res; + } +} +class Convert { + static isHex(data) { + return typeof data === "string" + && /^[a-z0-9]+$/i.test(data); + } + static isBase64(data) { + return typeof data === "string" + && /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(data); + } + static isBase64Url(data) { + return typeof data === "string" + && /^[a-zA-Z0-9-_]+$/i.test(data); + } + static ToString(buffer, enc = "utf8") { + const buf = BufferSourceConverter.toUint8Array(buffer); + switch (enc.toLowerCase()) { + case "utf8": + return this.ToUtf8String(buf); + case "binary": + return this.ToBinary(buf); + case "hex": + return this.ToHex(buf); + case "base64": + return this.ToBase64(buf); + case "base64url": + return this.ToBase64Url(buf); + case "utf16le": + return Utf16Converter.toString(buf, true); + case "utf16": + case "utf16be": + return Utf16Converter.toString(buf); + default: + throw new Error(`Unknown type of encoding '${enc}'`); + } + } + static FromString(str, enc = "utf8") { + if (!str) { + return new ArrayBuffer(0); + } + switch (enc.toLowerCase()) { + case "utf8": + return this.FromUtf8String(str); + case "binary": + return this.FromBinary(str); + case "hex": + return this.FromHex(str); + case "base64": + return this.FromBase64(str); + case "base64url": + return this.FromBase64Url(str); + case "utf16le": + return Utf16Converter.fromString(str, true); + case "utf16": + case "utf16be": + return Utf16Converter.fromString(str); + default: + throw new Error(`Unknown type of encoding '${enc}'`); + } + } + static ToBase64(buffer) { + const buf = BufferSourceConverter.toUint8Array(buffer); + if (typeof btoa !== "undefined") { + const binary = this.ToString(buf, "binary"); + return btoa(binary); + } + else { + return Buffer.from(buf).toString("base64"); + } + } + static FromBase64(base64) { + const formatted = this.formatString(base64); + if (!formatted) { + return new ArrayBuffer(0); + } + if (!Convert.isBase64(formatted)) { + throw new TypeError("Argument 'base64Text' is not Base64 encoded"); + } + if (typeof atob !== "undefined") { + return this.FromBinary(atob(formatted)); + } + else { + return new Uint8Array(Buffer.from(formatted, "base64")).buffer; + } + } + static FromBase64Url(base64url) { + const formatted = this.formatString(base64url); + if (!formatted) { + return new ArrayBuffer(0); + } + if (!Convert.isBase64Url(formatted)) { + throw new TypeError("Argument 'base64url' is not Base64Url encoded"); + } + return this.FromBase64(this.Base64Padding(formatted.replace(/\-/g, "+").replace(/\_/g, "/"))); + } + static ToBase64Url(data) { + return this.ToBase64(data).replace(/\+/g, "-").replace(/\//g, "_").replace(/\=/g, ""); + } + static FromUtf8String(text, encoding = Convert.DEFAULT_UTF8_ENCODING) { + switch (encoding) { + case "ascii": + return this.FromBinary(text); + case "utf8": + return Utf8Converter.fromString(text); + case "utf16": + case "utf16be": + return Utf16Converter.fromString(text); + case "utf16le": + case "usc2": + return Utf16Converter.fromString(text, true); + default: + throw new Error(`Unknown type of encoding '${encoding}'`); + } + } + static ToUtf8String(buffer, encoding = Convert.DEFAULT_UTF8_ENCODING) { + switch (encoding) { + case "ascii": + return this.ToBinary(buffer); + case "utf8": + return Utf8Converter.toString(buffer); + case "utf16": + case "utf16be": + return Utf16Converter.toString(buffer); + case "utf16le": + case "usc2": + return Utf16Converter.toString(buffer, true); + default: + throw new Error(`Unknown type of encoding '${encoding}'`); + } + } + static FromBinary(text) { + const stringLength = text.length; + const resultView = new Uint8Array(stringLength); + for (let i = 0; i < stringLength; i++) { + resultView[i] = text.charCodeAt(i); + } + return resultView.buffer; + } + static ToBinary(buffer) { + const buf = BufferSourceConverter.toUint8Array(buffer); + let res = ""; + for (let i = 0; i < buf.length; i++) { + res += String.fromCharCode(buf[i]); + } + return res; + } + static ToHex(buffer) { + const buf = BufferSourceConverter.toUint8Array(buffer); + const splitter = ""; + const res = []; + const len = buf.length; + for (let i = 0; i < len; i++) { + const char = buf[i].toString(16).padStart(2, "0"); + res.push(char); + } + return res.join(splitter); + } + static FromHex(hexString) { + let formatted = this.formatString(hexString); + if (!formatted) { + return new ArrayBuffer(0); + } + if (!Convert.isHex(formatted)) { + throw new TypeError("Argument 'hexString' is not HEX encoded"); + } + if (formatted.length % 2) { + formatted = `0${formatted}`; + } + const res = new Uint8Array(formatted.length / 2); + for (let i = 0; i < formatted.length; i = i + 2) { + const c = formatted.slice(i, i + 2); + res[i / 2] = parseInt(c, 16); + } + return res.buffer; + } + static ToUtf16String(buffer, littleEndian = false) { + return Utf16Converter.toString(buffer, littleEndian); + } + static FromUtf16String(text, littleEndian = false) { + return Utf16Converter.fromString(text, littleEndian); + } + static Base64Padding(base64) { + const padCount = 4 - (base64.length % 4); + if (padCount < 4) { + for (let i = 0; i < padCount; i++) { + base64 += "="; + } + } + return base64; + } + static formatString(data) { + return (data === null || data === void 0 ? void 0 : data.replace(/[\n\r\t ]/g, "")) || ""; + } +} +Convert.DEFAULT_UTF8_ENCODING = "utf8"; + +function assign(target, ...sources) { + const res = arguments[0]; + for (let i = 1; i < arguments.length; i++) { + const obj = arguments[i]; + for (const prop in obj) { + res[prop] = obj[prop]; + } + } + return res; +} +function combine(...buf) { + const totalByteLength = buf.map((item) => item.byteLength).reduce((prev, cur) => prev + cur); + const res = new Uint8Array(totalByteLength); + let currentPos = 0; + buf.map((item) => new Uint8Array(item)).forEach((arr) => { + for (const item2 of arr) { + res[currentPos++] = item2; + } + }); + return res.buffer; +} +function isEqual(bytes1, bytes2) { + if (!(bytes1 && bytes2)) { + return false; + } + if (bytes1.byteLength !== bytes2.byteLength) { + return false; + } + const b1 = new Uint8Array(bytes1); + const b2 = new Uint8Array(bytes2); + for (let i = 0; i < bytes1.byteLength; i++) { + if (b1[i] !== b2[i]) { + return false; + } + } + return true; +} + +exports.vJ = BufferSourceConverter; +exports.ep = Convert; +__webpack_unused_export__ = assign; +exports.$e = combine; +exports.Xy = isEqual; + + +/***/ }), + +/***/ 4281: +/***/ ((module) => { + +"use strict"; + + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; } + +var codes = {}; + +function createErrorType(code, message, Base) { + if (!Base) { + Base = Error; + } + + function getMessage(arg1, arg2, arg3) { + if (typeof message === 'string') { + return message; + } else { + return message(arg1, arg2, arg3); + } + } + + var NodeError = + /*#__PURE__*/ + function (_Base) { + _inheritsLoose(NodeError, _Base); + + function NodeError(arg1, arg2, arg3) { + return _Base.call(this, getMessage(arg1, arg2, arg3)) || this; + } + + return NodeError; + }(Base); + + NodeError.prototype.name = Base.name; + NodeError.prototype.code = code; + codes[code] = NodeError; +} // https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js + + +function oneOf(expected, thing) { + if (Array.isArray(expected)) { + var len = expected.length; + expected = expected.map(function (i) { + return String(i); + }); + + if (len > 2) { + return "one of ".concat(thing, " ").concat(expected.slice(0, len - 1).join(', '), ", or ") + expected[len - 1]; + } else if (len === 2) { + return "one of ".concat(thing, " ").concat(expected[0], " or ").concat(expected[1]); + } else { + return "of ".concat(thing, " ").concat(expected[0]); + } + } else { + return "of ".concat(thing, " ").concat(String(expected)); + } +} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith + + +function startsWith(str, search, pos) { + return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search; +} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith + + +function endsWith(str, search, this_len) { + if (this_len === undefined || this_len > str.length) { + this_len = str.length; + } + + return str.substring(this_len - search.length, this_len) === search; +} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes + + +function includes(str, search, start) { + if (typeof start !== 'number') { + start = 0; + } + + if (start + search.length > str.length) { + return false; + } else { + return str.indexOf(search, start) !== -1; + } +} + +createErrorType('ERR_INVALID_OPT_VALUE', function (name, value) { + return 'The value "' + value + '" is invalid for option "' + name + '"'; +}, TypeError); +createErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) { + // determiner: 'must be' or 'must not be' + var determiner; + + if (typeof expected === 'string' && startsWith(expected, 'not ')) { + determiner = 'must not be'; + expected = expected.replace(/^not /, ''); + } else { + determiner = 'must be'; + } + + var msg; + + if (endsWith(name, ' argument')) { + // For cases like 'first argument' + msg = "The ".concat(name, " ").concat(determiner, " ").concat(oneOf(expected, 'type')); + } else { + var type = includes(name, '.') ? 'property' : 'argument'; + msg = "The \"".concat(name, "\" ").concat(type, " ").concat(determiner, " ").concat(oneOf(expected, 'type')); + } + + msg += ". Received type ".concat(typeof actual); + return msg; +}, TypeError); +createErrorType('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF'); +createErrorType('ERR_METHOD_NOT_IMPLEMENTED', function (name) { + return 'The ' + name + ' method is not implemented'; +}); +createErrorType('ERR_STREAM_PREMATURE_CLOSE', 'Premature close'); +createErrorType('ERR_STREAM_DESTROYED', function (name) { + return 'Cannot call ' + name + ' after a stream was destroyed'; +}); +createErrorType('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times'); +createErrorType('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable'); +createErrorType('ERR_STREAM_WRITE_AFTER_END', 'write after end'); +createErrorType('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError); +createErrorType('ERR_UNKNOWN_ENCODING', function (arg) { + return 'Unknown encoding: ' + arg; +}, TypeError); +createErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event'); +module.exports.q = codes; + + +/***/ }), + +/***/ 6753: +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +"use strict"; +/* provided dependency */ var process = __webpack_require__(4155); +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +// a duplex stream is just a stream that is both readable and writable. +// Since JS doesn't have multiple prototypal inheritance, this class +// prototypally inherits from Readable, and then parasitically from +// Writable. + + + +/**/ +var objectKeys = Object.keys || function (obj) { + var keys = []; + for (var key in obj) keys.push(key); + return keys; +}; +/**/ + +module.exports = Duplex; +var Readable = __webpack_require__(9481); +var Writable = __webpack_require__(4229); +__webpack_require__(5717)(Duplex, Readable); +{ + // Allow the keys array to be GC'ed. + var keys = objectKeys(Writable.prototype); + for (var v = 0; v < keys.length; v++) { + var method = keys[v]; + if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method]; + } +} +function Duplex(options) { + if (!(this instanceof Duplex)) return new Duplex(options); + Readable.call(this, options); + Writable.call(this, options); + this.allowHalfOpen = true; + if (options) { + if (options.readable === false) this.readable = false; + if (options.writable === false) this.writable = false; + if (options.allowHalfOpen === false) { + this.allowHalfOpen = false; + this.once('end', onend); + } + } +} +Object.defineProperty(Duplex.prototype, 'writableHighWaterMark', { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + return this._writableState.highWaterMark; + } +}); +Object.defineProperty(Duplex.prototype, 'writableBuffer', { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + return this._writableState && this._writableState.getBuffer(); + } +}); +Object.defineProperty(Duplex.prototype, 'writableLength', { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + return this._writableState.length; + } +}); + +// the no-half-open enforcer +function onend() { + // If the writable side ended, then we're ok. + if (this._writableState.ended) return; + + // no more data can be written. + // But allow more writes to happen in this tick. + process.nextTick(onEndNT, this); +} +function onEndNT(self) { + self.end(); +} +Object.defineProperty(Duplex.prototype, 'destroyed', { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + if (this._readableState === undefined || this._writableState === undefined) { + return false; + } + return this._readableState.destroyed && this._writableState.destroyed; + }, + set: function set(value) { + // we ignore the value if the stream + // has not been initialized yet + if (this._readableState === undefined || this._writableState === undefined) { + return; + } + + // backward compatibility, the user is explicitly + // managing destroyed + this._readableState.destroyed = value; + this._writableState.destroyed = value; + } +}); + +/***/ }), + +/***/ 2725: +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +"use strict"; +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +// a passthrough stream. +// basically just the most minimal sort of Transform stream. +// Every written chunk gets output as-is. + + + +module.exports = PassThrough; +var Transform = __webpack_require__(4605); +__webpack_require__(5717)(PassThrough, Transform); +function PassThrough(options) { + if (!(this instanceof PassThrough)) return new PassThrough(options); + Transform.call(this, options); +} +PassThrough.prototype._transform = function (chunk, encoding, cb) { + cb(null, chunk); +}; + +/***/ }), + +/***/ 9481: +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +"use strict"; +/* provided dependency */ var process = __webpack_require__(4155); +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + + + +module.exports = Readable; + +/**/ +var Duplex; +/**/ + +Readable.ReadableState = ReadableState; + +/**/ +var EE = (__webpack_require__(7187).EventEmitter); +var EElistenerCount = function EElistenerCount(emitter, type) { + return emitter.listeners(type).length; +}; +/**/ + +/**/ +var Stream = __webpack_require__(2503); +/**/ + +var Buffer = (__webpack_require__(8764).Buffer); +var OurUint8Array = (typeof __webpack_require__.g !== 'undefined' ? __webpack_require__.g : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {}).Uint8Array || function () {}; +function _uint8ArrayToBuffer(chunk) { + return Buffer.from(chunk); +} +function _isUint8Array(obj) { + return Buffer.isBuffer(obj) || obj instanceof OurUint8Array; +} + +/**/ +var debugUtil = __webpack_require__(4616); +var debug; +if (debugUtil && debugUtil.debuglog) { + debug = debugUtil.debuglog('stream'); +} else { + debug = function debug() {}; +} +/**/ + +var BufferList = __webpack_require__(7327); +var destroyImpl = __webpack_require__(1195); +var _require = __webpack_require__(2457), + getHighWaterMark = _require.getHighWaterMark; +var _require$codes = (__webpack_require__(4281)/* .codes */ .q), + ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE, + ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF, + ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED, + ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes.ERR_STREAM_UNSHIFT_AFTER_END_EVENT; + +// Lazy loaded to improve the startup performance. +var StringDecoder; +var createReadableStreamAsyncIterator; +var from; +__webpack_require__(5717)(Readable, Stream); +var errorOrDestroy = destroyImpl.errorOrDestroy; +var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume']; +function prependListener(emitter, event, fn) { + // Sadly this is not cacheable as some libraries bundle their own + // event emitter implementation with them. + if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn); + + // This is a hack to make sure that our error handler is attached before any + // userland ones. NEVER DO THIS. This is here only because this code needs + // to continue to work with older versions of Node.js that do not include + // the prependListener() method. The goal is to eventually remove this hack. + if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (Array.isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]]; +} +function ReadableState(options, stream, isDuplex) { + Duplex = Duplex || __webpack_require__(6753); + options = options || {}; + + // Duplex streams are both readable and writable, but share + // the same options object. + // However, some cases require setting options to different + // values for the readable and the writable sides of the duplex stream. + // These options can be provided separately as readableXXX and writableXXX. + if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; + + // object stream flag. Used to make read(n) ignore n and to + // make all the buffer merging and length checks go away + this.objectMode = !!options.objectMode; + if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode; + + // the point at which it stops calling _read() to fill the buffer + // Note: 0 is a valid value, means "don't call _read preemptively ever" + this.highWaterMark = getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex); + + // A linked list is used to store data chunks instead of an array because the + // linked list can remove elements from the beginning faster than + // array.shift() + this.buffer = new BufferList(); + this.length = 0; + this.pipes = null; + this.pipesCount = 0; + this.flowing = null; + this.ended = false; + this.endEmitted = false; + this.reading = false; + + // a flag to be able to tell if the event 'readable'/'data' is emitted + // immediately, or on a later tick. We set this to true at first, because + // any actions that shouldn't happen until "later" should generally also + // not happen before the first read call. + this.sync = true; + + // whenever we return null, then we set a flag to say + // that we're awaiting a 'readable' event emission. + this.needReadable = false; + this.emittedReadable = false; + this.readableListening = false; + this.resumeScheduled = false; + this.paused = true; + + // Should close be emitted on destroy. Defaults to true. + this.emitClose = options.emitClose !== false; + + // Should .destroy() be called after 'end' (and potentially 'finish') + this.autoDestroy = !!options.autoDestroy; + + // has it been destroyed + this.destroyed = false; + + // Crypto is kind of old and crusty. Historically, its default string + // encoding is 'binary' so we have to make this configurable. + // Everything else in the universe uses 'utf8', though. + this.defaultEncoding = options.defaultEncoding || 'utf8'; + + // the number of writers that are awaiting a drain event in .pipe()s + this.awaitDrain = 0; + + // if true, a maybeReadMore has been scheduled + this.readingMore = false; + this.decoder = null; + this.encoding = null; + if (options.encoding) { + if (!StringDecoder) StringDecoder = (__webpack_require__(2553)/* .StringDecoder */ .s); + this.decoder = new StringDecoder(options.encoding); + this.encoding = options.encoding; + } +} +function Readable(options) { + Duplex = Duplex || __webpack_require__(6753); + if (!(this instanceof Readable)) return new Readable(options); + + // Checking for a Stream.Duplex instance is faster here instead of inside + // the ReadableState constructor, at least with V8 6.5 + var isDuplex = this instanceof Duplex; + this._readableState = new ReadableState(options, this, isDuplex); + + // legacy + this.readable = true; + if (options) { + if (typeof options.read === 'function') this._read = options.read; + if (typeof options.destroy === 'function') this._destroy = options.destroy; + } + Stream.call(this); +} +Object.defineProperty(Readable.prototype, 'destroyed', { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + if (this._readableState === undefined) { + return false; + } + return this._readableState.destroyed; + }, + set: function set(value) { + // we ignore the value if the stream + // has not been initialized yet + if (!this._readableState) { + return; + } + + // backward compatibility, the user is explicitly + // managing destroyed + this._readableState.destroyed = value; + } +}); +Readable.prototype.destroy = destroyImpl.destroy; +Readable.prototype._undestroy = destroyImpl.undestroy; +Readable.prototype._destroy = function (err, cb) { + cb(err); +}; + +// Manually shove something into the read() buffer. +// This returns true if the highWaterMark has not been hit yet, +// similar to how Writable.write() returns true if you should +// write() some more. +Readable.prototype.push = function (chunk, encoding) { + var state = this._readableState; + var skipChunkCheck; + if (!state.objectMode) { + if (typeof chunk === 'string') { + encoding = encoding || state.defaultEncoding; + if (encoding !== state.encoding) { + chunk = Buffer.from(chunk, encoding); + encoding = ''; + } + skipChunkCheck = true; + } + } else { + skipChunkCheck = true; + } + return readableAddChunk(this, chunk, encoding, false, skipChunkCheck); +}; + +// Unshift should *always* be something directly out of read() +Readable.prototype.unshift = function (chunk) { + return readableAddChunk(this, chunk, null, true, false); +}; +function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) { + debug('readableAddChunk', chunk); + var state = stream._readableState; + if (chunk === null) { + state.reading = false; + onEofChunk(stream, state); + } else { + var er; + if (!skipChunkCheck) er = chunkInvalid(state, chunk); + if (er) { + errorOrDestroy(stream, er); + } else if (state.objectMode || chunk && chunk.length > 0) { + if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) { + chunk = _uint8ArrayToBuffer(chunk); + } + if (addToFront) { + if (state.endEmitted) errorOrDestroy(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());else addChunk(stream, state, chunk, true); + } else if (state.ended) { + errorOrDestroy(stream, new ERR_STREAM_PUSH_AFTER_EOF()); + } else if (state.destroyed) { + return false; + } else { + state.reading = false; + if (state.decoder && !encoding) { + chunk = state.decoder.write(chunk); + if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state); + } else { + addChunk(stream, state, chunk, false); + } + } + } else if (!addToFront) { + state.reading = false; + maybeReadMore(stream, state); + } + } + + // We can push more data if we are below the highWaterMark. + // Also, if we have no data yet, we can stand some more bytes. + // This is to work around cases where hwm=0, such as the repl. + return !state.ended && (state.length < state.highWaterMark || state.length === 0); +} +function addChunk(stream, state, chunk, addToFront) { + if (state.flowing && state.length === 0 && !state.sync) { + state.awaitDrain = 0; + stream.emit('data', chunk); + } else { + // update the buffer info. + state.length += state.objectMode ? 1 : chunk.length; + if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk); + if (state.needReadable) emitReadable(stream); + } + maybeReadMore(stream, state); +} +function chunkInvalid(state, chunk) { + var er; + if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) { + er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer', 'Uint8Array'], chunk); + } + return er; +} +Readable.prototype.isPaused = function () { + return this._readableState.flowing === false; +}; + +// backwards compatibility. +Readable.prototype.setEncoding = function (enc) { + if (!StringDecoder) StringDecoder = (__webpack_require__(2553)/* .StringDecoder */ .s); + var decoder = new StringDecoder(enc); + this._readableState.decoder = decoder; + // If setEncoding(null), decoder.encoding equals utf8 + this._readableState.encoding = this._readableState.decoder.encoding; + + // Iterate over current buffer to convert already stored Buffers: + var p = this._readableState.buffer.head; + var content = ''; + while (p !== null) { + content += decoder.write(p.data); + p = p.next; + } + this._readableState.buffer.clear(); + if (content !== '') this._readableState.buffer.push(content); + this._readableState.length = content.length; + return this; +}; + +// Don't raise the hwm > 1GB +var MAX_HWM = 0x40000000; +function computeNewHighWaterMark(n) { + if (n >= MAX_HWM) { + // TODO(ronag): Throw ERR_VALUE_OUT_OF_RANGE. + n = MAX_HWM; + } else { + // Get the next highest power of 2 to prevent increasing hwm excessively in + // tiny amounts + n--; + n |= n >>> 1; + n |= n >>> 2; + n |= n >>> 4; + n |= n >>> 8; + n |= n >>> 16; + n++; + } + return n; +} + +// This function is designed to be inlinable, so please take care when making +// changes to the function body. +function howMuchToRead(n, state) { + if (n <= 0 || state.length === 0 && state.ended) return 0; + if (state.objectMode) return 1; + if (n !== n) { + // Only flow one buffer at a time + if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length; + } + // If we're asking for more than the current hwm, then raise the hwm. + if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n); + if (n <= state.length) return n; + // Don't have enough + if (!state.ended) { + state.needReadable = true; + return 0; + } + return state.length; +} + +// you can override either this method, or the async _read(n) below. +Readable.prototype.read = function (n) { + debug('read', n); + n = parseInt(n, 10); + var state = this._readableState; + var nOrig = n; + if (n !== 0) state.emittedReadable = false; + + // if we're doing read(0) to trigger a readable event, but we + // already have a bunch of data in the buffer, then just trigger + // the 'readable' event and move on. + if (n === 0 && state.needReadable && ((state.highWaterMark !== 0 ? state.length >= state.highWaterMark : state.length > 0) || state.ended)) { + debug('read: emitReadable', state.length, state.ended); + if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this); + return null; + } + n = howMuchToRead(n, state); + + // if we've ended, and we're now clear, then finish it up. + if (n === 0 && state.ended) { + if (state.length === 0) endReadable(this); + return null; + } + + // All the actual chunk generation logic needs to be + // *below* the call to _read. The reason is that in certain + // synthetic stream cases, such as passthrough streams, _read + // may be a completely synchronous operation which may change + // the state of the read buffer, providing enough data when + // before there was *not* enough. + // + // So, the steps are: + // 1. Figure out what the state of things will be after we do + // a read from the buffer. + // + // 2. If that resulting state will trigger a _read, then call _read. + // Note that this may be asynchronous, or synchronous. Yes, it is + // deeply ugly to write APIs this way, but that still doesn't mean + // that the Readable class should behave improperly, as streams are + // designed to be sync/async agnostic. + // Take note if the _read call is sync or async (ie, if the read call + // has returned yet), so that we know whether or not it's safe to emit + // 'readable' etc. + // + // 3. Actually pull the requested chunks out of the buffer and return. + + // if we need a readable event, then we need to do some reading. + var doRead = state.needReadable; + debug('need readable', doRead); + + // if we currently have less than the highWaterMark, then also read some + if (state.length === 0 || state.length - n < state.highWaterMark) { + doRead = true; + debug('length less than watermark', doRead); + } + + // however, if we've ended, then there's no point, and if we're already + // reading, then it's unnecessary. + if (state.ended || state.reading) { + doRead = false; + debug('reading or ended', doRead); + } else if (doRead) { + debug('do read'); + state.reading = true; + state.sync = true; + // if the length is currently zero, then we *need* a readable event. + if (state.length === 0) state.needReadable = true; + // call internal read method + this._read(state.highWaterMark); + state.sync = false; + // If _read pushed data synchronously, then `reading` will be false, + // and we need to re-evaluate how much data we can return to the user. + if (!state.reading) n = howMuchToRead(nOrig, state); + } + var ret; + if (n > 0) ret = fromList(n, state);else ret = null; + if (ret === null) { + state.needReadable = state.length <= state.highWaterMark; + n = 0; + } else { + state.length -= n; + state.awaitDrain = 0; + } + if (state.length === 0) { + // If we have nothing in the buffer, then we want to know + // as soon as we *do* get something into the buffer. + if (!state.ended) state.needReadable = true; + + // If we tried to read() past the EOF, then emit end on the next tick. + if (nOrig !== n && state.ended) endReadable(this); + } + if (ret !== null) this.emit('data', ret); + return ret; +}; +function onEofChunk(stream, state) { + debug('onEofChunk'); + if (state.ended) return; + if (state.decoder) { + var chunk = state.decoder.end(); + if (chunk && chunk.length) { + state.buffer.push(chunk); + state.length += state.objectMode ? 1 : chunk.length; + } + } + state.ended = true; + if (state.sync) { + // if we are sync, wait until next tick to emit the data. + // Otherwise we risk emitting data in the flow() + // the readable code triggers during a read() call + emitReadable(stream); + } else { + // emit 'readable' now to make sure it gets picked up. + state.needReadable = false; + if (!state.emittedReadable) { + state.emittedReadable = true; + emitReadable_(stream); + } + } +} + +// Don't emit readable right away in sync mode, because this can trigger +// another read() call => stack overflow. This way, it might trigger +// a nextTick recursion warning, but that's not so bad. +function emitReadable(stream) { + var state = stream._readableState; + debug('emitReadable', state.needReadable, state.emittedReadable); + state.needReadable = false; + if (!state.emittedReadable) { + debug('emitReadable', state.flowing); + state.emittedReadable = true; + process.nextTick(emitReadable_, stream); + } +} +function emitReadable_(stream) { + var state = stream._readableState; + debug('emitReadable_', state.destroyed, state.length, state.ended); + if (!state.destroyed && (state.length || state.ended)) { + stream.emit('readable'); + state.emittedReadable = false; + } + + // The stream needs another readable event if + // 1. It is not flowing, as the flow mechanism will take + // care of it. + // 2. It is not ended. + // 3. It is below the highWaterMark, so we can schedule + // another readable later. + state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark; + flow(stream); +} + +// at this point, the user has presumably seen the 'readable' event, +// and called read() to consume some data. that may have triggered +// in turn another _read(n) call, in which case reading = true if +// it's in progress. +// However, if we're not ended, or reading, and the length < hwm, +// then go ahead and try to read some more preemptively. +function maybeReadMore(stream, state) { + if (!state.readingMore) { + state.readingMore = true; + process.nextTick(maybeReadMore_, stream, state); + } +} +function maybeReadMore_(stream, state) { + // Attempt to read more data if we should. + // + // The conditions for reading more data are (one of): + // - Not enough data buffered (state.length < state.highWaterMark). The loop + // is responsible for filling the buffer with enough data if such data + // is available. If highWaterMark is 0 and we are not in the flowing mode + // we should _not_ attempt to buffer any extra data. We'll get more data + // when the stream consumer calls read() instead. + // - No data in the buffer, and the stream is in flowing mode. In this mode + // the loop below is responsible for ensuring read() is called. Failing to + // call read here would abort the flow and there's no other mechanism for + // continuing the flow if the stream consumer has just subscribed to the + // 'data' event. + // + // In addition to the above conditions to keep reading data, the following + // conditions prevent the data from being read: + // - The stream has ended (state.ended). + // - There is already a pending 'read' operation (state.reading). This is a + // case where the the stream has called the implementation defined _read() + // method, but they are processing the call asynchronously and have _not_ + // called push() with new data. In this case we skip performing more + // read()s. The execution ends in this method again after the _read() ends + // up calling push() with more data. + while (!state.reading && !state.ended && (state.length < state.highWaterMark || state.flowing && state.length === 0)) { + var len = state.length; + debug('maybeReadMore read 0'); + stream.read(0); + if (len === state.length) + // didn't get any data, stop spinning. + break; + } + state.readingMore = false; +} + +// abstract method. to be overridden in specific implementation classes. +// call cb(er, data) where data is <= n in length. +// for virtual (non-string, non-buffer) streams, "length" is somewhat +// arbitrary, and perhaps not very meaningful. +Readable.prototype._read = function (n) { + errorOrDestroy(this, new ERR_METHOD_NOT_IMPLEMENTED('_read()')); +}; +Readable.prototype.pipe = function (dest, pipeOpts) { + var src = this; + var state = this._readableState; + switch (state.pipesCount) { + case 0: + state.pipes = dest; + break; + case 1: + state.pipes = [state.pipes, dest]; + break; + default: + state.pipes.push(dest); + break; + } + state.pipesCount += 1; + debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts); + var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr; + var endFn = doEnd ? onend : unpipe; + if (state.endEmitted) process.nextTick(endFn);else src.once('end', endFn); + dest.on('unpipe', onunpipe); + function onunpipe(readable, unpipeInfo) { + debug('onunpipe'); + if (readable === src) { + if (unpipeInfo && unpipeInfo.hasUnpiped === false) { + unpipeInfo.hasUnpiped = true; + cleanup(); + } + } + } + function onend() { + debug('onend'); + dest.end(); + } + + // when the dest drains, it reduces the awaitDrain counter + // on the source. This would be more elegant with a .once() + // handler in flow(), but adding and removing repeatedly is + // too slow. + var ondrain = pipeOnDrain(src); + dest.on('drain', ondrain); + var cleanedUp = false; + function cleanup() { + debug('cleanup'); + // cleanup event handlers once the pipe is broken + dest.removeListener('close', onclose); + dest.removeListener('finish', onfinish); + dest.removeListener('drain', ondrain); + dest.removeListener('error', onerror); + dest.removeListener('unpipe', onunpipe); + src.removeListener('end', onend); + src.removeListener('end', unpipe); + src.removeListener('data', ondata); + cleanedUp = true; + + // if the reader is waiting for a drain event from this + // specific writer, then it would cause it to never start + // flowing again. + // So, if this is awaiting a drain, then we just call it now. + // If we don't know, then assume that we are waiting for one. + if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain(); + } + src.on('data', ondata); + function ondata(chunk) { + debug('ondata'); + var ret = dest.write(chunk); + debug('dest.write', ret); + if (ret === false) { + // If the user unpiped during `dest.write()`, it is possible + // to get stuck in a permanently paused state if that write + // also returned false. + // => Check whether `dest` is still a piping destination. + if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) { + debug('false write response, pause', state.awaitDrain); + state.awaitDrain++; + } + src.pause(); + } + } + + // if the dest has an error, then stop piping into it. + // however, don't suppress the throwing behavior for this. + function onerror(er) { + debug('onerror', er); + unpipe(); + dest.removeListener('error', onerror); + if (EElistenerCount(dest, 'error') === 0) errorOrDestroy(dest, er); + } + + // Make sure our error handler is attached before userland ones. + prependListener(dest, 'error', onerror); + + // Both close and finish should trigger unpipe, but only once. + function onclose() { + dest.removeListener('finish', onfinish); + unpipe(); + } + dest.once('close', onclose); + function onfinish() { + debug('onfinish'); + dest.removeListener('close', onclose); + unpipe(); + } + dest.once('finish', onfinish); + function unpipe() { + debug('unpipe'); + src.unpipe(dest); + } + + // tell the dest that it's being piped to + dest.emit('pipe', src); + + // start the flow if it hasn't been started already. + if (!state.flowing) { + debug('pipe resume'); + src.resume(); + } + return dest; +}; +function pipeOnDrain(src) { + return function pipeOnDrainFunctionResult() { + var state = src._readableState; + debug('pipeOnDrain', state.awaitDrain); + if (state.awaitDrain) state.awaitDrain--; + if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) { + state.flowing = true; + flow(src); + } + }; +} +Readable.prototype.unpipe = function (dest) { + var state = this._readableState; + var unpipeInfo = { + hasUnpiped: false + }; + + // if we're not piping anywhere, then do nothing. + if (state.pipesCount === 0) return this; + + // just one destination. most common case. + if (state.pipesCount === 1) { + // passed in one, but it's not the right one. + if (dest && dest !== state.pipes) return this; + if (!dest) dest = state.pipes; + + // got a match. + state.pipes = null; + state.pipesCount = 0; + state.flowing = false; + if (dest) dest.emit('unpipe', this, unpipeInfo); + return this; + } + + // slow case. multiple pipe destinations. + + if (!dest) { + // remove all. + var dests = state.pipes; + var len = state.pipesCount; + state.pipes = null; + state.pipesCount = 0; + state.flowing = false; + for (var i = 0; i < len; i++) dests[i].emit('unpipe', this, { + hasUnpiped: false + }); + return this; + } + + // try to find the right one. + var index = indexOf(state.pipes, dest); + if (index === -1) return this; + state.pipes.splice(index, 1); + state.pipesCount -= 1; + if (state.pipesCount === 1) state.pipes = state.pipes[0]; + dest.emit('unpipe', this, unpipeInfo); + return this; +}; + +// set up data events if they are asked for +// Ensure readable listeners eventually get something +Readable.prototype.on = function (ev, fn) { + var res = Stream.prototype.on.call(this, ev, fn); + var state = this._readableState; + if (ev === 'data') { + // update readableListening so that resume() may be a no-op + // a few lines down. This is needed to support once('readable'). + state.readableListening = this.listenerCount('readable') > 0; + + // Try start flowing on next tick if stream isn't explicitly paused + if (state.flowing !== false) this.resume(); + } else if (ev === 'readable') { + if (!state.endEmitted && !state.readableListening) { + state.readableListening = state.needReadable = true; + state.flowing = false; + state.emittedReadable = false; + debug('on readable', state.length, state.reading); + if (state.length) { + emitReadable(this); + } else if (!state.reading) { + process.nextTick(nReadingNextTick, this); + } + } + } + return res; +}; +Readable.prototype.addListener = Readable.prototype.on; +Readable.prototype.removeListener = function (ev, fn) { + var res = Stream.prototype.removeListener.call(this, ev, fn); + if (ev === 'readable') { + // We need to check if there is someone still listening to + // readable and reset the state. However this needs to happen + // after readable has been emitted but before I/O (nextTick) to + // support once('readable', fn) cycles. This means that calling + // resume within the same tick will have no + // effect. + process.nextTick(updateReadableListening, this); + } + return res; +}; +Readable.prototype.removeAllListeners = function (ev) { + var res = Stream.prototype.removeAllListeners.apply(this, arguments); + if (ev === 'readable' || ev === undefined) { + // We need to check if there is someone still listening to + // readable and reset the state. However this needs to happen + // after readable has been emitted but before I/O (nextTick) to + // support once('readable', fn) cycles. This means that calling + // resume within the same tick will have no + // effect. + process.nextTick(updateReadableListening, this); + } + return res; +}; +function updateReadableListening(self) { + var state = self._readableState; + state.readableListening = self.listenerCount('readable') > 0; + if (state.resumeScheduled && !state.paused) { + // flowing needs to be set to true now, otherwise + // the upcoming resume will not flow. + state.flowing = true; + + // crude way to check if we should resume + } else if (self.listenerCount('data') > 0) { + self.resume(); + } +} +function nReadingNextTick(self) { + debug('readable nexttick read 0'); + self.read(0); +} + +// pause() and resume() are remnants of the legacy readable stream API +// If the user uses them, then switch into old mode. +Readable.prototype.resume = function () { + var state = this._readableState; + if (!state.flowing) { + debug('resume'); + // we flow only if there is no one listening + // for readable, but we still have to call + // resume() + state.flowing = !state.readableListening; + resume(this, state); + } + state.paused = false; + return this; +}; +function resume(stream, state) { + if (!state.resumeScheduled) { + state.resumeScheduled = true; + process.nextTick(resume_, stream, state); + } +} +function resume_(stream, state) { + debug('resume', state.reading); + if (!state.reading) { + stream.read(0); + } + state.resumeScheduled = false; + stream.emit('resume'); + flow(stream); + if (state.flowing && !state.reading) stream.read(0); +} +Readable.prototype.pause = function () { + debug('call pause flowing=%j', this._readableState.flowing); + if (this._readableState.flowing !== false) { + debug('pause'); + this._readableState.flowing = false; + this.emit('pause'); + } + this._readableState.paused = true; + return this; +}; +function flow(stream) { + var state = stream._readableState; + debug('flow', state.flowing); + while (state.flowing && stream.read() !== null); +} + +// wrap an old-style stream as the async data source. +// This is *not* part of the readable stream interface. +// It is an ugly unfortunate mess of history. +Readable.prototype.wrap = function (stream) { + var _this = this; + var state = this._readableState; + var paused = false; + stream.on('end', function () { + debug('wrapped end'); + if (state.decoder && !state.ended) { + var chunk = state.decoder.end(); + if (chunk && chunk.length) _this.push(chunk); + } + _this.push(null); + }); + stream.on('data', function (chunk) { + debug('wrapped data'); + if (state.decoder) chunk = state.decoder.write(chunk); + + // don't skip over falsy values in objectMode + if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return; + var ret = _this.push(chunk); + if (!ret) { + paused = true; + stream.pause(); + } + }); + + // proxy all the other methods. + // important when wrapping filters and duplexes. + for (var i in stream) { + if (this[i] === undefined && typeof stream[i] === 'function') { + this[i] = function methodWrap(method) { + return function methodWrapReturnFunction() { + return stream[method].apply(stream, arguments); + }; + }(i); + } + } + + // proxy certain important events. + for (var n = 0; n < kProxyEvents.length; n++) { + stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n])); + } + + // when we try to consume some more bytes, simply unpause the + // underlying stream. + this._read = function (n) { + debug('wrapped _read', n); + if (paused) { + paused = false; + stream.resume(); + } + }; + return this; +}; +if (typeof Symbol === 'function') { + Readable.prototype[Symbol.asyncIterator] = function () { + if (createReadableStreamAsyncIterator === undefined) { + createReadableStreamAsyncIterator = __webpack_require__(5850); + } + return createReadableStreamAsyncIterator(this); + }; +} +Object.defineProperty(Readable.prototype, 'readableHighWaterMark', { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + return this._readableState.highWaterMark; + } +}); +Object.defineProperty(Readable.prototype, 'readableBuffer', { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + return this._readableState && this._readableState.buffer; + } +}); +Object.defineProperty(Readable.prototype, 'readableFlowing', { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + return this._readableState.flowing; + }, + set: function set(state) { + if (this._readableState) { + this._readableState.flowing = state; + } + } +}); + +// exposed for testing purposes only. +Readable._fromList = fromList; +Object.defineProperty(Readable.prototype, 'readableLength', { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + return this._readableState.length; + } +}); + +// Pluck off n bytes from an array of buffers. +// Length is the combined lengths of all the buffers in the list. +// This function is designed to be inlinable, so please take care when making +// changes to the function body. +function fromList(n, state) { + // nothing buffered + if (state.length === 0) return null; + var ret; + if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) { + // read it all, truncate the list + if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.first();else ret = state.buffer.concat(state.length); + state.buffer.clear(); + } else { + // read part of list + ret = state.buffer.consume(n, state.decoder); + } + return ret; +} +function endReadable(stream) { + var state = stream._readableState; + debug('endReadable', state.endEmitted); + if (!state.endEmitted) { + state.ended = true; + process.nextTick(endReadableNT, state, stream); + } +} +function endReadableNT(state, stream) { + debug('endReadableNT', state.endEmitted, state.length); + + // Check that we didn't get one last unshift. + if (!state.endEmitted && state.length === 0) { + state.endEmitted = true; + stream.readable = false; + stream.emit('end'); + if (state.autoDestroy) { + // In case of duplex streams we need a way to detect + // if the writable side is ready for autoDestroy as well + var wState = stream._writableState; + if (!wState || wState.autoDestroy && wState.finished) { + stream.destroy(); + } + } + } +} +if (typeof Symbol === 'function') { + Readable.from = function (iterable, opts) { + if (from === undefined) { + from = __webpack_require__(5167); + } + return from(Readable, iterable, opts); + }; +} +function indexOf(xs, x) { + for (var i = 0, l = xs.length; i < l; i++) { + if (xs[i] === x) return i; + } + return -1; +} + +/***/ }), + +/***/ 4605: +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +"use strict"; +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +// a transform stream is a readable/writable stream where you do +// something with the data. Sometimes it's called a "filter", +// but that's not a great name for it, since that implies a thing where +// some bits pass through, and others are simply ignored. (That would +// be a valid example of a transform, of course.) +// +// While the output is causally related to the input, it's not a +// necessarily symmetric or synchronous transformation. For example, +// a zlib stream might take multiple plain-text writes(), and then +// emit a single compressed chunk some time in the future. +// +// Here's how this works: +// +// The Transform stream has all the aspects of the readable and writable +// stream classes. When you write(chunk), that calls _write(chunk,cb) +// internally, and returns false if there's a lot of pending writes +// buffered up. When you call read(), that calls _read(n) until +// there's enough pending readable data buffered up. +// +// In a transform stream, the written data is placed in a buffer. When +// _read(n) is called, it transforms the queued up data, calling the +// buffered _write cb's as it consumes chunks. If consuming a single +// written chunk would result in multiple output chunks, then the first +// outputted bit calls the readcb, and subsequent chunks just go into +// the read buffer, and will cause it to emit 'readable' if necessary. +// +// This way, back-pressure is actually determined by the reading side, +// since _read has to be called to start processing a new chunk. However, +// a pathological inflate type of transform can cause excessive buffering +// here. For example, imagine a stream where every byte of input is +// interpreted as an integer from 0-255, and then results in that many +// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in +// 1kb of data being output. In this case, you could write a very small +// amount of input, and end up with a very large amount of output. In +// such a pathological inflating mechanism, there'd be no way to tell +// the system to stop doing the transform. A single 4MB write could +// cause the system to run out of memory. +// +// However, even in such a pathological case, only a single written chunk +// would be consumed, and then the rest would wait (un-transformed) until +// the results of the previous transformed chunk were consumed. + + + +module.exports = Transform; +var _require$codes = (__webpack_require__(4281)/* .codes */ .q), + ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED, + ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK, + ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING, + ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0; +var Duplex = __webpack_require__(6753); +__webpack_require__(5717)(Transform, Duplex); +function afterTransform(er, data) { + var ts = this._transformState; + ts.transforming = false; + var cb = ts.writecb; + if (cb === null) { + return this.emit('error', new ERR_MULTIPLE_CALLBACK()); + } + ts.writechunk = null; + ts.writecb = null; + if (data != null) + // single equals check for both `null` and `undefined` + this.push(data); + cb(er); + var rs = this._readableState; + rs.reading = false; + if (rs.needReadable || rs.length < rs.highWaterMark) { + this._read(rs.highWaterMark); + } +} +function Transform(options) { + if (!(this instanceof Transform)) return new Transform(options); + Duplex.call(this, options); + this._transformState = { + afterTransform: afterTransform.bind(this), + needTransform: false, + transforming: false, + writecb: null, + writechunk: null, + writeencoding: null + }; + + // start out asking for a readable event once data is transformed. + this._readableState.needReadable = true; + + // we have implemented the _read method, and done the other things + // that Readable wants before the first _read call, so unset the + // sync guard flag. + this._readableState.sync = false; + if (options) { + if (typeof options.transform === 'function') this._transform = options.transform; + if (typeof options.flush === 'function') this._flush = options.flush; + } + + // When the writable side finishes, then flush out anything remaining. + this.on('prefinish', prefinish); +} +function prefinish() { + var _this = this; + if (typeof this._flush === 'function' && !this._readableState.destroyed) { + this._flush(function (er, data) { + done(_this, er, data); + }); + } else { + done(this, null, null); + } +} +Transform.prototype.push = function (chunk, encoding) { + this._transformState.needTransform = false; + return Duplex.prototype.push.call(this, chunk, encoding); +}; + +// This is the part where you do stuff! +// override this function in implementation classes. +// 'chunk' is an input chunk. +// +// Call `push(newChunk)` to pass along transformed output +// to the readable side. You may call 'push' zero or more times. +// +// Call `cb(err)` when you are done with this chunk. If you pass +// an error, then that'll put the hurt on the whole operation. If you +// never call cb(), then you'll never get another chunk. +Transform.prototype._transform = function (chunk, encoding, cb) { + cb(new ERR_METHOD_NOT_IMPLEMENTED('_transform()')); +}; +Transform.prototype._write = function (chunk, encoding, cb) { + var ts = this._transformState; + ts.writecb = cb; + ts.writechunk = chunk; + ts.writeencoding = encoding; + if (!ts.transforming) { + var rs = this._readableState; + if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark); + } +}; + +// Doesn't matter what the args are here. +// _transform does all the work. +// That we got here means that the readable side wants more data. +Transform.prototype._read = function (n) { + var ts = this._transformState; + if (ts.writechunk !== null && !ts.transforming) { + ts.transforming = true; + this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform); + } else { + // mark that we need a transform, so that any data that comes in + // will get processed, now that we've asked for it. + ts.needTransform = true; + } +}; +Transform.prototype._destroy = function (err, cb) { + Duplex.prototype._destroy.call(this, err, function (err2) { + cb(err2); + }); +}; +function done(stream, er, data) { + if (er) return stream.emit('error', er); + if (data != null) + // single equals check for both `null` and `undefined` + stream.push(data); + + // TODO(BridgeAR): Write a test for these two error cases + // if there's nothing in the write buffer, then that means + // that nothing more will ever be provided + if (stream._writableState.length) throw new ERR_TRANSFORM_WITH_LENGTH_0(); + if (stream._transformState.transforming) throw new ERR_TRANSFORM_ALREADY_TRANSFORMING(); + return stream.push(null); +} + +/***/ }), + +/***/ 4229: +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +"use strict"; +/* provided dependency */ var process = __webpack_require__(4155); +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +// A bit simpler than readable streams. +// Implement an async ._write(chunk, encoding, cb), and it'll handle all +// the drain event emission and buffering. + + + +module.exports = Writable; + +/* */ +function WriteReq(chunk, encoding, cb) { + this.chunk = chunk; + this.encoding = encoding; + this.callback = cb; + this.next = null; +} + +// It seems a linked list but it is not +// there will be only 2 of these for each stream +function CorkedRequest(state) { + var _this = this; + this.next = null; + this.entry = null; + this.finish = function () { + onCorkedFinish(_this, state); + }; +} +/* */ + +/**/ +var Duplex; +/**/ + +Writable.WritableState = WritableState; + +/**/ +var internalUtil = { + deprecate: __webpack_require__(4927) +}; +/**/ + +/**/ +var Stream = __webpack_require__(2503); +/**/ + +var Buffer = (__webpack_require__(8764).Buffer); +var OurUint8Array = (typeof __webpack_require__.g !== 'undefined' ? __webpack_require__.g : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {}).Uint8Array || function () {}; +function _uint8ArrayToBuffer(chunk) { + return Buffer.from(chunk); +} +function _isUint8Array(obj) { + return Buffer.isBuffer(obj) || obj instanceof OurUint8Array; +} +var destroyImpl = __webpack_require__(1195); +var _require = __webpack_require__(2457), + getHighWaterMark = _require.getHighWaterMark; +var _require$codes = (__webpack_require__(4281)/* .codes */ .q), + ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE, + ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED, + ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK, + ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE, + ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED, + ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES, + ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END, + ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING; +var errorOrDestroy = destroyImpl.errorOrDestroy; +__webpack_require__(5717)(Writable, Stream); +function nop() {} +function WritableState(options, stream, isDuplex) { + Duplex = Duplex || __webpack_require__(6753); + options = options || {}; + + // Duplex streams are both readable and writable, but share + // the same options object. + // However, some cases require setting options to different + // values for the readable and the writable sides of the duplex stream, + // e.g. options.readableObjectMode vs. options.writableObjectMode, etc. + if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; + + // object stream flag to indicate whether or not this stream + // contains buffers or objects. + this.objectMode = !!options.objectMode; + if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode; + + // the point at which write() starts returning false + // Note: 0 is a valid value, means that we always return false if + // the entire buffer is not flushed immediately on write() + this.highWaterMark = getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex); + + // if _final has been called + this.finalCalled = false; + + // drain event flag. + this.needDrain = false; + // at the start of calling end() + this.ending = false; + // when end() has been called, and returned + this.ended = false; + // when 'finish' is emitted + this.finished = false; + + // has it been destroyed + this.destroyed = false; + + // should we decode strings into buffers before passing to _write? + // this is here so that some node-core streams can optimize string + // handling at a lower level. + var noDecode = options.decodeStrings === false; + this.decodeStrings = !noDecode; + + // Crypto is kind of old and crusty. Historically, its default string + // encoding is 'binary' so we have to make this configurable. + // Everything else in the universe uses 'utf8', though. + this.defaultEncoding = options.defaultEncoding || 'utf8'; + + // not an actual buffer we keep track of, but a measurement + // of how much we're waiting to get pushed to some underlying + // socket or file. + this.length = 0; + + // a flag to see when we're in the middle of a write. + this.writing = false; + + // when true all writes will be buffered until .uncork() call + this.corked = 0; + + // a flag to be able to tell if the onwrite cb is called immediately, + // or on a later tick. We set this to true at first, because any + // actions that shouldn't happen until "later" should generally also + // not happen before the first write call. + this.sync = true; + + // a flag to know if we're processing previously buffered items, which + // may call the _write() callback in the same tick, so that we don't + // end up in an overlapped onwrite situation. + this.bufferProcessing = false; + + // the callback that's passed to _write(chunk,cb) + this.onwrite = function (er) { + onwrite(stream, er); + }; + + // the callback that the user supplies to write(chunk,encoding,cb) + this.writecb = null; + + // the amount that is being written when _write is called. + this.writelen = 0; + this.bufferedRequest = null; + this.lastBufferedRequest = null; + + // number of pending user-supplied write callbacks + // this must be 0 before 'finish' can be emitted + this.pendingcb = 0; + + // emit prefinish if the only thing we're waiting for is _write cbs + // This is relevant for synchronous Transform streams + this.prefinished = false; + + // True if the error was already emitted and should not be thrown again + this.errorEmitted = false; + + // Should close be emitted on destroy. Defaults to true. + this.emitClose = options.emitClose !== false; + + // Should .destroy() be called after 'finish' (and potentially 'end') + this.autoDestroy = !!options.autoDestroy; + + // count buffered requests + this.bufferedRequestCount = 0; + + // allocate the first CorkedRequest, there is always + // one allocated and free to use, and we maintain at most two + this.corkedRequestsFree = new CorkedRequest(this); +} +WritableState.prototype.getBuffer = function getBuffer() { + var current = this.bufferedRequest; + var out = []; + while (current) { + out.push(current); + current = current.next; + } + return out; +}; +(function () { + try { + Object.defineProperty(WritableState.prototype, 'buffer', { + get: internalUtil.deprecate(function writableStateBufferGetter() { + return this.getBuffer(); + }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003') + }); + } catch (_) {} +})(); + +// Test _writableState for inheritance to account for Duplex streams, +// whose prototype chain only points to Readable. +var realHasInstance; +if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') { + realHasInstance = Function.prototype[Symbol.hasInstance]; + Object.defineProperty(Writable, Symbol.hasInstance, { + value: function value(object) { + if (realHasInstance.call(this, object)) return true; + if (this !== Writable) return false; + return object && object._writableState instanceof WritableState; + } + }); +} else { + realHasInstance = function realHasInstance(object) { + return object instanceof this; + }; +} +function Writable(options) { + Duplex = Duplex || __webpack_require__(6753); + + // Writable ctor is applied to Duplexes, too. + // `realHasInstance` is necessary because using plain `instanceof` + // would return false, as no `_writableState` property is attached. + + // Trying to use the custom `instanceof` for Writable here will also break the + // Node.js LazyTransform implementation, which has a non-trivial getter for + // `_writableState` that would lead to infinite recursion. + + // Checking for a Stream.Duplex instance is faster here instead of inside + // the WritableState constructor, at least with V8 6.5 + var isDuplex = this instanceof Duplex; + if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options); + this._writableState = new WritableState(options, this, isDuplex); + + // legacy. + this.writable = true; + if (options) { + if (typeof options.write === 'function') this._write = options.write; + if (typeof options.writev === 'function') this._writev = options.writev; + if (typeof options.destroy === 'function') this._destroy = options.destroy; + if (typeof options.final === 'function') this._final = options.final; + } + Stream.call(this); +} + +// Otherwise people can pipe Writable streams, which is just wrong. +Writable.prototype.pipe = function () { + errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE()); +}; +function writeAfterEnd(stream, cb) { + var er = new ERR_STREAM_WRITE_AFTER_END(); + // TODO: defer error events consistently everywhere, not just the cb + errorOrDestroy(stream, er); + process.nextTick(cb, er); +} + +// Checks that a user-supplied chunk is valid, especially for the particular +// mode the stream is in. Currently this means that `null` is never accepted +// and undefined/non-string values are only allowed in object mode. +function validChunk(stream, state, chunk, cb) { + var er; + if (chunk === null) { + er = new ERR_STREAM_NULL_VALUES(); + } else if (typeof chunk !== 'string' && !state.objectMode) { + er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer'], chunk); + } + if (er) { + errorOrDestroy(stream, er); + process.nextTick(cb, er); + return false; + } + return true; +} +Writable.prototype.write = function (chunk, encoding, cb) { + var state = this._writableState; + var ret = false; + var isBuf = !state.objectMode && _isUint8Array(chunk); + if (isBuf && !Buffer.isBuffer(chunk)) { + chunk = _uint8ArrayToBuffer(chunk); + } + if (typeof encoding === 'function') { + cb = encoding; + encoding = null; + } + if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding; + if (typeof cb !== 'function') cb = nop; + if (state.ending) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) { + state.pendingcb++; + ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb); + } + return ret; +}; +Writable.prototype.cork = function () { + this._writableState.corked++; +}; +Writable.prototype.uncork = function () { + var state = this._writableState; + if (state.corked) { + state.corked--; + if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state); + } +}; +Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) { + // node::ParseEncoding() requires lower case. + if (typeof encoding === 'string') encoding = encoding.toLowerCase(); + if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new ERR_UNKNOWN_ENCODING(encoding); + this._writableState.defaultEncoding = encoding; + return this; +}; +Object.defineProperty(Writable.prototype, 'writableBuffer', { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + return this._writableState && this._writableState.getBuffer(); + } +}); +function decodeChunk(state, chunk, encoding) { + if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') { + chunk = Buffer.from(chunk, encoding); + } + return chunk; +} +Object.defineProperty(Writable.prototype, 'writableHighWaterMark', { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + return this._writableState.highWaterMark; + } +}); + +// if we're already writing something, then just put this +// in the queue, and wait our turn. Otherwise, call _write +// If we return false, then we need a drain event, so set that flag. +function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) { + if (!isBuf) { + var newChunk = decodeChunk(state, chunk, encoding); + if (chunk !== newChunk) { + isBuf = true; + encoding = 'buffer'; + chunk = newChunk; + } + } + var len = state.objectMode ? 1 : chunk.length; + state.length += len; + var ret = state.length < state.highWaterMark; + // we must ensure that previous needDrain will not be reset to false. + if (!ret) state.needDrain = true; + if (state.writing || state.corked) { + var last = state.lastBufferedRequest; + state.lastBufferedRequest = { + chunk: chunk, + encoding: encoding, + isBuf: isBuf, + callback: cb, + next: null + }; + if (last) { + last.next = state.lastBufferedRequest; + } else { + state.bufferedRequest = state.lastBufferedRequest; + } + state.bufferedRequestCount += 1; + } else { + doWrite(stream, state, false, len, chunk, encoding, cb); + } + return ret; +} +function doWrite(stream, state, writev, len, chunk, encoding, cb) { + state.writelen = len; + state.writecb = cb; + state.writing = true; + state.sync = true; + if (state.destroyed) state.onwrite(new ERR_STREAM_DESTROYED('write'));else if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite); + state.sync = false; +} +function onwriteError(stream, state, sync, er, cb) { + --state.pendingcb; + if (sync) { + // defer the callback if we are being called synchronously + // to avoid piling up things on the stack + process.nextTick(cb, er); + // this can emit finish, and it will always happen + // after error + process.nextTick(finishMaybe, stream, state); + stream._writableState.errorEmitted = true; + errorOrDestroy(stream, er); + } else { + // the caller expect this to happen before if + // it is async + cb(er); + stream._writableState.errorEmitted = true; + errorOrDestroy(stream, er); + // this can emit finish, but finish must + // always follow error + finishMaybe(stream, state); + } +} +function onwriteStateUpdate(state) { + state.writing = false; + state.writecb = null; + state.length -= state.writelen; + state.writelen = 0; +} +function onwrite(stream, er) { + var state = stream._writableState; + var sync = state.sync; + var cb = state.writecb; + if (typeof cb !== 'function') throw new ERR_MULTIPLE_CALLBACK(); + onwriteStateUpdate(state); + if (er) onwriteError(stream, state, sync, er, cb);else { + // Check if we're actually ready to finish, but don't emit yet + var finished = needFinish(state) || stream.destroyed; + if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) { + clearBuffer(stream, state); + } + if (sync) { + process.nextTick(afterWrite, stream, state, finished, cb); + } else { + afterWrite(stream, state, finished, cb); + } + } +} +function afterWrite(stream, state, finished, cb) { + if (!finished) onwriteDrain(stream, state); + state.pendingcb--; + cb(); + finishMaybe(stream, state); +} + +// Must force callback to be called on nextTick, so that we don't +// emit 'drain' before the write() consumer gets the 'false' return +// value, and has a chance to attach a 'drain' listener. +function onwriteDrain(stream, state) { + if (state.length === 0 && state.needDrain) { + state.needDrain = false; + stream.emit('drain'); + } +} + +// if there's something in the buffer waiting, then process it +function clearBuffer(stream, state) { + state.bufferProcessing = true; + var entry = state.bufferedRequest; + if (stream._writev && entry && entry.next) { + // Fast case, write everything using _writev() + var l = state.bufferedRequestCount; + var buffer = new Array(l); + var holder = state.corkedRequestsFree; + holder.entry = entry; + var count = 0; + var allBuffers = true; + while (entry) { + buffer[count] = entry; + if (!entry.isBuf) allBuffers = false; + entry = entry.next; + count += 1; + } + buffer.allBuffers = allBuffers; + doWrite(stream, state, true, state.length, buffer, '', holder.finish); + + // doWrite is almost always async, defer these to save a bit of time + // as the hot path ends with doWrite + state.pendingcb++; + state.lastBufferedRequest = null; + if (holder.next) { + state.corkedRequestsFree = holder.next; + holder.next = null; + } else { + state.corkedRequestsFree = new CorkedRequest(state); + } + state.bufferedRequestCount = 0; + } else { + // Slow case, write chunks one-by-one + while (entry) { + var chunk = entry.chunk; + var encoding = entry.encoding; + var cb = entry.callback; + var len = state.objectMode ? 1 : chunk.length; + doWrite(stream, state, false, len, chunk, encoding, cb); + entry = entry.next; + state.bufferedRequestCount--; + // if we didn't call the onwrite immediately, then + // it means that we need to wait until it does. + // also, that means that the chunk and cb are currently + // being processed, so move the buffer counter past them. + if (state.writing) { + break; + } + } + if (entry === null) state.lastBufferedRequest = null; + } + state.bufferedRequest = entry; + state.bufferProcessing = false; +} +Writable.prototype._write = function (chunk, encoding, cb) { + cb(new ERR_METHOD_NOT_IMPLEMENTED('_write()')); +}; +Writable.prototype._writev = null; +Writable.prototype.end = function (chunk, encoding, cb) { + var state = this._writableState; + if (typeof chunk === 'function') { + cb = chunk; + chunk = null; + encoding = null; + } else if (typeof encoding === 'function') { + cb = encoding; + encoding = null; + } + if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); + + // .end() fully uncorks + if (state.corked) { + state.corked = 1; + this.uncork(); + } + + // ignore unnecessary end() calls. + if (!state.ending) endWritable(this, state, cb); + return this; +}; +Object.defineProperty(Writable.prototype, 'writableLength', { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + return this._writableState.length; + } +}); +function needFinish(state) { + return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing; +} +function callFinal(stream, state) { + stream._final(function (err) { + state.pendingcb--; + if (err) { + errorOrDestroy(stream, err); + } + state.prefinished = true; + stream.emit('prefinish'); + finishMaybe(stream, state); + }); +} +function prefinish(stream, state) { + if (!state.prefinished && !state.finalCalled) { + if (typeof stream._final === 'function' && !state.destroyed) { + state.pendingcb++; + state.finalCalled = true; + process.nextTick(callFinal, stream, state); + } else { + state.prefinished = true; + stream.emit('prefinish'); + } + } +} +function finishMaybe(stream, state) { + var need = needFinish(state); + if (need) { + prefinish(stream, state); + if (state.pendingcb === 0) { + state.finished = true; + stream.emit('finish'); + if (state.autoDestroy) { + // In case of duplex streams we need a way to detect + // if the readable side is ready for autoDestroy as well + var rState = stream._readableState; + if (!rState || rState.autoDestroy && rState.endEmitted) { + stream.destroy(); + } + } + } + } + return need; +} +function endWritable(stream, state, cb) { + state.ending = true; + finishMaybe(stream, state); + if (cb) { + if (state.finished) process.nextTick(cb);else stream.once('finish', cb); + } + state.ended = true; + stream.writable = false; +} +function onCorkedFinish(corkReq, state, err) { + var entry = corkReq.entry; + corkReq.entry = null; + while (entry) { + var cb = entry.callback; + state.pendingcb--; + cb(err); + entry = entry.next; + } + + // reuse the free corkReq. + state.corkedRequestsFree.next = corkReq; +} +Object.defineProperty(Writable.prototype, 'destroyed', { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + if (this._writableState === undefined) { + return false; + } + return this._writableState.destroyed; + }, + set: function set(value) { + // we ignore the value if the stream + // has not been initialized yet + if (!this._writableState) { + return; + } + + // backward compatibility, the user is explicitly + // managing destroyed + this._writableState.destroyed = value; + } +}); +Writable.prototype.destroy = destroyImpl.destroy; +Writable.prototype._undestroy = destroyImpl.undestroy; +Writable.prototype._destroy = function (err, cb) { + cb(err); +}; + +/***/ }), + +/***/ 5850: +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +"use strict"; +/* provided dependency */ var process = __webpack_require__(4155); + + +var _Object$setPrototypeO; +function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } +var finished = __webpack_require__(8610); +var kLastResolve = Symbol('lastResolve'); +var kLastReject = Symbol('lastReject'); +var kError = Symbol('error'); +var kEnded = Symbol('ended'); +var kLastPromise = Symbol('lastPromise'); +var kHandlePromise = Symbol('handlePromise'); +var kStream = Symbol('stream'); +function createIterResult(value, done) { + return { + value: value, + done: done + }; +} +function readAndResolve(iter) { + var resolve = iter[kLastResolve]; + if (resolve !== null) { + var data = iter[kStream].read(); + // we defer if data is null + // we can be expecting either 'end' or + // 'error' + if (data !== null) { + iter[kLastPromise] = null; + iter[kLastResolve] = null; + iter[kLastReject] = null; + resolve(createIterResult(data, false)); + } + } +} +function onReadable(iter) { + // we wait for the next tick, because it might + // emit an error with process.nextTick + process.nextTick(readAndResolve, iter); +} +function wrapForNext(lastPromise, iter) { + return function (resolve, reject) { + lastPromise.then(function () { + if (iter[kEnded]) { + resolve(createIterResult(undefined, true)); + return; + } + iter[kHandlePromise](resolve, reject); + }, reject); + }; +} +var AsyncIteratorPrototype = Object.getPrototypeOf(function () {}); +var ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = { + get stream() { + return this[kStream]; + }, + next: function next() { + var _this = this; + // if we have detected an error in the meanwhile + // reject straight away + var error = this[kError]; + if (error !== null) { + return Promise.reject(error); + } + if (this[kEnded]) { + return Promise.resolve(createIterResult(undefined, true)); + } + if (this[kStream].destroyed) { + // We need to defer via nextTick because if .destroy(err) is + // called, the error will be emitted via nextTick, and + // we cannot guarantee that there is no error lingering around + // waiting to be emitted. + return new Promise(function (resolve, reject) { + process.nextTick(function () { + if (_this[kError]) { + reject(_this[kError]); + } else { + resolve(createIterResult(undefined, true)); + } + }); + }); + } + + // if we have multiple next() calls + // we will wait for the previous Promise to finish + // this logic is optimized to support for await loops, + // where next() is only called once at a time + var lastPromise = this[kLastPromise]; + var promise; + if (lastPromise) { + promise = new Promise(wrapForNext(lastPromise, this)); + } else { + // fast path needed to support multiple this.push() + // without triggering the next() queue + var data = this[kStream].read(); + if (data !== null) { + return Promise.resolve(createIterResult(data, false)); + } + promise = new Promise(this[kHandlePromise]); + } + this[kLastPromise] = promise; + return promise; + } +}, _defineProperty(_Object$setPrototypeO, Symbol.asyncIterator, function () { + return this; +}), _defineProperty(_Object$setPrototypeO, "return", function _return() { + var _this2 = this; + // destroy(err, cb) is a private API + // we can guarantee we have that here, because we control the + // Readable class this is attached to + return new Promise(function (resolve, reject) { + _this2[kStream].destroy(null, function (err) { + if (err) { + reject(err); + return; + } + resolve(createIterResult(undefined, true)); + }); + }); +}), _Object$setPrototypeO), AsyncIteratorPrototype); +var createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator(stream) { + var _Object$create; + var iterator = Object.create(ReadableStreamAsyncIteratorPrototype, (_Object$create = {}, _defineProperty(_Object$create, kStream, { + value: stream, + writable: true + }), _defineProperty(_Object$create, kLastResolve, { + value: null, + writable: true + }), _defineProperty(_Object$create, kLastReject, { + value: null, + writable: true + }), _defineProperty(_Object$create, kError, { + value: null, + writable: true + }), _defineProperty(_Object$create, kEnded, { + value: stream._readableState.endEmitted, + writable: true + }), _defineProperty(_Object$create, kHandlePromise, { + value: function value(resolve, reject) { + var data = iterator[kStream].read(); + if (data) { + iterator[kLastPromise] = null; + iterator[kLastResolve] = null; + iterator[kLastReject] = null; + resolve(createIterResult(data, false)); + } else { + iterator[kLastResolve] = resolve; + iterator[kLastReject] = reject; + } + }, + writable: true + }), _Object$create)); + iterator[kLastPromise] = null; + finished(stream, function (err) { + if (err && err.code !== 'ERR_STREAM_PREMATURE_CLOSE') { + var reject = iterator[kLastReject]; + // reject if we are waiting for data in the Promise + // returned by next() and store the error + if (reject !== null) { + iterator[kLastPromise] = null; + iterator[kLastResolve] = null; + iterator[kLastReject] = null; + reject(err); + } + iterator[kError] = err; + return; + } + var resolve = iterator[kLastResolve]; + if (resolve !== null) { + iterator[kLastPromise] = null; + iterator[kLastResolve] = null; + iterator[kLastReject] = null; + resolve(createIterResult(undefined, true)); + } + iterator[kEnded] = true; + }); + stream.on('readable', onReadable.bind(null, iterator)); + return iterator; +}; +module.exports = createReadableStreamAsyncIterator; + +/***/ }), + +/***/ 7327: +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +"use strict"; + + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; } +function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } +var _require = __webpack_require__(8764), + Buffer = _require.Buffer; +var _require2 = __webpack_require__(2361), + inspect = _require2.inspect; +var custom = inspect && inspect.custom || 'inspect'; +function copyBuffer(src, target, offset) { + Buffer.prototype.copy.call(src, target, offset); +} +module.exports = /*#__PURE__*/function () { + function BufferList() { + _classCallCheck(this, BufferList); + this.head = null; + this.tail = null; + this.length = 0; + } + _createClass(BufferList, [{ + key: "push", + value: function push(v) { + var entry = { + data: v, + next: null + }; + if (this.length > 0) this.tail.next = entry;else this.head = entry; + this.tail = entry; + ++this.length; + } + }, { + key: "unshift", + value: function unshift(v) { + var entry = { + data: v, + next: this.head + }; + if (this.length === 0) this.tail = entry; + this.head = entry; + ++this.length; + } + }, { + key: "shift", + value: function shift() { + if (this.length === 0) return; + var ret = this.head.data; + if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next; + --this.length; + return ret; + } + }, { + key: "clear", + value: function clear() { + this.head = this.tail = null; + this.length = 0; + } + }, { + key: "join", + value: function join(s) { + if (this.length === 0) return ''; + var p = this.head; + var ret = '' + p.data; + while (p = p.next) ret += s + p.data; + return ret; + } + }, { + key: "concat", + value: function concat(n) { + if (this.length === 0) return Buffer.alloc(0); + var ret = Buffer.allocUnsafe(n >>> 0); + var p = this.head; + var i = 0; + while (p) { + copyBuffer(p.data, ret, i); + i += p.data.length; + p = p.next; + } + return ret; + } + + // Consumes a specified amount of bytes or characters from the buffered data. + }, { + key: "consume", + value: function consume(n, hasStrings) { + var ret; + if (n < this.head.data.length) { + // `slice` is the same for buffers and strings. + ret = this.head.data.slice(0, n); + this.head.data = this.head.data.slice(n); + } else if (n === this.head.data.length) { + // First chunk is a perfect match. + ret = this.shift(); + } else { + // Result spans more than one buffer. + ret = hasStrings ? this._getString(n) : this._getBuffer(n); + } + return ret; + } + }, { + key: "first", + value: function first() { + return this.head.data; + } + + // Consumes a specified amount of characters from the buffered data. + }, { + key: "_getString", + value: function _getString(n) { + var p = this.head; + var c = 1; + var ret = p.data; + n -= ret.length; + while (p = p.next) { + var str = p.data; + var nb = n > str.length ? str.length : n; + if (nb === str.length) ret += str;else ret += str.slice(0, n); + n -= nb; + if (n === 0) { + if (nb === str.length) { + ++c; + if (p.next) this.head = p.next;else this.head = this.tail = null; + } else { + this.head = p; + p.data = str.slice(nb); + } + break; + } + ++c; + } + this.length -= c; + return ret; + } + + // Consumes a specified amount of bytes from the buffered data. + }, { + key: "_getBuffer", + value: function _getBuffer(n) { + var ret = Buffer.allocUnsafe(n); + var p = this.head; + var c = 1; + p.data.copy(ret); + n -= p.data.length; + while (p = p.next) { + var buf = p.data; + var nb = n > buf.length ? buf.length : n; + buf.copy(ret, ret.length - n, 0, nb); + n -= nb; + if (n === 0) { + if (nb === buf.length) { + ++c; + if (p.next) this.head = p.next;else this.head = this.tail = null; + } else { + this.head = p; + p.data = buf.slice(nb); + } + break; + } + ++c; + } + this.length -= c; + return ret; + } + + // Make sure the linked list only shows the minimal necessary information. + }, { + key: custom, + value: function value(_, options) { + return inspect(this, _objectSpread(_objectSpread({}, options), {}, { + // Only inspect one level. + depth: 0, + // It should not recurse. + customInspect: false + })); + } + }]); + return BufferList; +}(); + +/***/ }), + +/***/ 1195: +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +"use strict"; +/* provided dependency */ var process = __webpack_require__(4155); + + +// undocumented cb() API, needed for core, not for public API +function destroy(err, cb) { + var _this = this; + var readableDestroyed = this._readableState && this._readableState.destroyed; + var writableDestroyed = this._writableState && this._writableState.destroyed; + if (readableDestroyed || writableDestroyed) { + if (cb) { + cb(err); + } else if (err) { + if (!this._writableState) { + process.nextTick(emitErrorNT, this, err); + } else if (!this._writableState.errorEmitted) { + this._writableState.errorEmitted = true; + process.nextTick(emitErrorNT, this, err); + } + } + return this; + } + + // we set destroyed to true before firing error callbacks in order + // to make it re-entrance safe in case destroy() is called within callbacks + + if (this._readableState) { + this._readableState.destroyed = true; + } + + // if this is a duplex stream mark the writable part as destroyed as well + if (this._writableState) { + this._writableState.destroyed = true; + } + this._destroy(err || null, function (err) { + if (!cb && err) { + if (!_this._writableState) { + process.nextTick(emitErrorAndCloseNT, _this, err); + } else if (!_this._writableState.errorEmitted) { + _this._writableState.errorEmitted = true; + process.nextTick(emitErrorAndCloseNT, _this, err); + } else { + process.nextTick(emitCloseNT, _this); + } + } else if (cb) { + process.nextTick(emitCloseNT, _this); + cb(err); + } else { + process.nextTick(emitCloseNT, _this); + } + }); + return this; +} +function emitErrorAndCloseNT(self, err) { + emitErrorNT(self, err); + emitCloseNT(self); +} +function emitCloseNT(self) { + if (self._writableState && !self._writableState.emitClose) return; + if (self._readableState && !self._readableState.emitClose) return; + self.emit('close'); +} +function undestroy() { + if (this._readableState) { + this._readableState.destroyed = false; + this._readableState.reading = false; + this._readableState.ended = false; + this._readableState.endEmitted = false; + } + if (this._writableState) { + this._writableState.destroyed = false; + this._writableState.ended = false; + this._writableState.ending = false; + this._writableState.finalCalled = false; + this._writableState.prefinished = false; + this._writableState.finished = false; + this._writableState.errorEmitted = false; + } +} +function emitErrorNT(self, err) { + self.emit('error', err); +} +function errorOrDestroy(stream, err) { + // We have tests that rely on errors being emitted + // in the same tick, so changing this is semver major. + // For now when you opt-in to autoDestroy we allow + // the error to be emitted nextTick. In a future + // semver major update we should change the default to this. + + var rState = stream._readableState; + var wState = stream._writableState; + if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream.destroy(err);else stream.emit('error', err); +} +module.exports = { + destroy: destroy, + undestroy: undestroy, + errorOrDestroy: errorOrDestroy +}; + +/***/ }), + +/***/ 8610: +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +"use strict"; +// Ported from https://github.com/mafintosh/end-of-stream with +// permission from the author, Mathias Buus (@mafintosh). + + + +var ERR_STREAM_PREMATURE_CLOSE = (__webpack_require__(4281)/* .codes.ERR_STREAM_PREMATURE_CLOSE */ .q.ERR_STREAM_PREMATURE_CLOSE); +function once(callback) { + var called = false; + return function () { + if (called) return; + called = true; + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + callback.apply(this, args); + }; +} +function noop() {} +function isRequest(stream) { + return stream.setHeader && typeof stream.abort === 'function'; +} +function eos(stream, opts, callback) { + if (typeof opts === 'function') return eos(stream, null, opts); + if (!opts) opts = {}; + callback = once(callback || noop); + var readable = opts.readable || opts.readable !== false && stream.readable; + var writable = opts.writable || opts.writable !== false && stream.writable; + var onlegacyfinish = function onlegacyfinish() { + if (!stream.writable) onfinish(); + }; + var writableEnded = stream._writableState && stream._writableState.finished; + var onfinish = function onfinish() { + writable = false; + writableEnded = true; + if (!readable) callback.call(stream); + }; + var readableEnded = stream._readableState && stream._readableState.endEmitted; + var onend = function onend() { + readable = false; + readableEnded = true; + if (!writable) callback.call(stream); + }; + var onerror = function onerror(err) { + callback.call(stream, err); + }; + var onclose = function onclose() { + var err; + if (readable && !readableEnded) { + if (!stream._readableState || !stream._readableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE(); + return callback.call(stream, err); + } + if (writable && !writableEnded) { + if (!stream._writableState || !stream._writableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE(); + return callback.call(stream, err); + } + }; + var onrequest = function onrequest() { + stream.req.on('finish', onfinish); + }; + if (isRequest(stream)) { + stream.on('complete', onfinish); + stream.on('abort', onclose); + if (stream.req) onrequest();else stream.on('request', onrequest); + } else if (writable && !stream._writableState) { + // legacy streams + stream.on('end', onlegacyfinish); + stream.on('close', onlegacyfinish); + } + stream.on('end', onend); + stream.on('finish', onfinish); + if (opts.error !== false) stream.on('error', onerror); + stream.on('close', onclose); + return function () { + stream.removeListener('complete', onfinish); + stream.removeListener('abort', onclose); + stream.removeListener('request', onrequest); + if (stream.req) stream.req.removeListener('finish', onfinish); + stream.removeListener('end', onlegacyfinish); + stream.removeListener('close', onlegacyfinish); + stream.removeListener('finish', onfinish); + stream.removeListener('end', onend); + stream.removeListener('error', onerror); + stream.removeListener('close', onclose); + }; +} +module.exports = eos; + +/***/ }), + +/***/ 5167: +/***/ ((module) => { + +module.exports = function () { + throw new Error('Readable.from is not available in the browser') +}; + + +/***/ }), + +/***/ 9946: +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +"use strict"; +// Ported from https://github.com/mafintosh/pump with +// permission from the author, Mathias Buus (@mafintosh). + + + +var eos; +function once(callback) { + var called = false; + return function () { + if (called) return; + called = true; + callback.apply(void 0, arguments); + }; +} +var _require$codes = (__webpack_require__(4281)/* .codes */ .q), + ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS, + ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED; +function noop(err) { + // Rethrow the error if it exists to avoid swallowing it + if (err) throw err; +} +function isRequest(stream) { + return stream.setHeader && typeof stream.abort === 'function'; +} +function destroyer(stream, reading, writing, callback) { + callback = once(callback); + var closed = false; + stream.on('close', function () { + closed = true; + }); + if (eos === undefined) eos = __webpack_require__(8610); + eos(stream, { + readable: reading, + writable: writing + }, function (err) { + if (err) return callback(err); + closed = true; + callback(); + }); + var destroyed = false; + return function (err) { + if (closed) return; + if (destroyed) return; + destroyed = true; + + // request.destroy just do .end - .abort is what we want + if (isRequest(stream)) return stream.abort(); + if (typeof stream.destroy === 'function') return stream.destroy(); + callback(err || new ERR_STREAM_DESTROYED('pipe')); + }; +} +function call(fn) { + fn(); +} +function pipe(from, to) { + return from.pipe(to); +} +function popCallback(streams) { + if (!streams.length) return noop; + if (typeof streams[streams.length - 1] !== 'function') return noop; + return streams.pop(); +} +function pipeline() { + for (var _len = arguments.length, streams = new Array(_len), _key = 0; _key < _len; _key++) { + streams[_key] = arguments[_key]; + } + var callback = popCallback(streams); + if (Array.isArray(streams[0])) streams = streams[0]; + if (streams.length < 2) { + throw new ERR_MISSING_ARGS('streams'); + } + var error; + var destroys = streams.map(function (stream, i) { + var reading = i < streams.length - 1; + var writing = i > 0; + return destroyer(stream, reading, writing, function (err) { + if (!error) error = err; + if (err) destroys.forEach(call); + if (reading) return; + destroys.forEach(call); + callback(error); + }); + }); + return streams.reduce(pipe); +} +module.exports = pipeline; + +/***/ }), + +/***/ 2457: +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +"use strict"; + + +var ERR_INVALID_OPT_VALUE = (__webpack_require__(4281)/* .codes.ERR_INVALID_OPT_VALUE */ .q.ERR_INVALID_OPT_VALUE); +function highWaterMarkFrom(options, isDuplex, duplexKey) { + return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null; +} +function getHighWaterMark(state, options, duplexKey, isDuplex) { + var hwm = highWaterMarkFrom(options, isDuplex, duplexKey); + if (hwm != null) { + if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) { + var name = isDuplex ? duplexKey : 'highWaterMark'; + throw new ERR_INVALID_OPT_VALUE(name, hwm); + } + return Math.floor(hwm); + } + + // Default value + return state.objectMode ? 16 : 16 * 1024; +} +module.exports = { + getHighWaterMark: getHighWaterMark +}; + +/***/ }), + +/***/ 2503: +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +module.exports = __webpack_require__(7187).EventEmitter; + + +/***/ }), + +/***/ 8660: +/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => { + +/* provided dependency */ var process = __webpack_require__(4155); +/*! ***************************************************************************** +Copyright (C) Microsoft. All rights reserved. +Licensed under the Apache License, Version 2.0 (the "License"); you may not use +this file except in compliance with the License. You may obtain a copy of the +License at http://www.apache.org/licenses/LICENSE-2.0 + +THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED +WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, +MERCHANTABLITY OR NON-INFRINGEMENT. + +See the Apache Version 2.0 License for specific language governing permissions +and limitations under the License. +***************************************************************************** */ +var Reflect; +(function (Reflect) { + // Metadata Proposal + // https://rbuckton.github.io/reflect-metadata/ + (function (factory) { + var root = typeof __webpack_require__.g === "object" ? __webpack_require__.g : + typeof self === "object" ? self : + typeof this === "object" ? this : + Function("return this;")(); + var exporter = makeExporter(Reflect); + if (typeof root.Reflect === "undefined") { + root.Reflect = Reflect; + } + else { + exporter = makeExporter(root.Reflect, exporter); + } + factory(exporter); + function makeExporter(target, previous) { + return function (key, value) { + if (typeof target[key] !== "function") { + Object.defineProperty(target, key, { configurable: true, writable: true, value: value }); + } + if (previous) + previous(key, value); + }; + } + })(function (exporter) { + var hasOwn = Object.prototype.hasOwnProperty; + // feature test for Symbol support + var supportsSymbol = typeof Symbol === "function"; + var toPrimitiveSymbol = supportsSymbol && typeof Symbol.toPrimitive !== "undefined" ? Symbol.toPrimitive : "@@toPrimitive"; + var iteratorSymbol = supportsSymbol && typeof Symbol.iterator !== "undefined" ? Symbol.iterator : "@@iterator"; + var supportsCreate = typeof Object.create === "function"; // feature test for Object.create support + var supportsProto = { __proto__: [] } instanceof Array; // feature test for __proto__ support + var downLevel = !supportsCreate && !supportsProto; + var HashMap = { + // create an object in dictionary mode (a.k.a. "slow" mode in v8) + create: supportsCreate + ? function () { return MakeDictionary(Object.create(null)); } + : supportsProto + ? function () { return MakeDictionary({ __proto__: null }); } + : function () { return MakeDictionary({}); }, + has: downLevel + ? function (map, key) { return hasOwn.call(map, key); } + : function (map, key) { return key in map; }, + get: downLevel + ? function (map, key) { return hasOwn.call(map, key) ? map[key] : undefined; } + : function (map, key) { return map[key]; }, + }; + // Load global or shim versions of Map, Set, and WeakMap + var functionPrototype = Object.getPrototypeOf(Function); + var usePolyfill = typeof process === "object" && process.env && process.env["REFLECT_METADATA_USE_MAP_POLYFILL"] === "true"; + var _Map = !usePolyfill && typeof Map === "function" && typeof Map.prototype.entries === "function" ? Map : CreateMapPolyfill(); + var _Set = !usePolyfill && typeof Set === "function" && typeof Set.prototype.entries === "function" ? Set : CreateSetPolyfill(); + var _WeakMap = !usePolyfill && typeof WeakMap === "function" ? WeakMap : CreateWeakMapPolyfill(); + // [[Metadata]] internal slot + // https://rbuckton.github.io/reflect-metadata/#ordinary-object-internal-methods-and-internal-slots + var Metadata = new _WeakMap(); + /** + * Applies a set of decorators to a property of a target object. + * @param decorators An array of decorators. + * @param target The target object. + * @param propertyKey (Optional) The property key to decorate. + * @param attributes (Optional) The property descriptor for the target key. + * @remarks Decorators are applied in reverse order. + * @example + * + * class Example { + * // property declarations are not part of ES6, though they are valid in TypeScript: + * // static staticProperty; + * // property; + * + * constructor(p) { } + * static staticMethod(p) { } + * method(p) { } + * } + * + * // constructor + * Example = Reflect.decorate(decoratorsArray, Example); + * + * // property (on constructor) + * Reflect.decorate(decoratorsArray, Example, "staticProperty"); + * + * // property (on prototype) + * Reflect.decorate(decoratorsArray, Example.prototype, "property"); + * + * // method (on constructor) + * Object.defineProperty(Example, "staticMethod", + * Reflect.decorate(decoratorsArray, Example, "staticMethod", + * Object.getOwnPropertyDescriptor(Example, "staticMethod"))); + * + * // method (on prototype) + * Object.defineProperty(Example.prototype, "method", + * Reflect.decorate(decoratorsArray, Example.prototype, "method", + * Object.getOwnPropertyDescriptor(Example.prototype, "method"))); + * + */ + function decorate(decorators, target, propertyKey, attributes) { + if (!IsUndefined(propertyKey)) { + if (!IsArray(decorators)) + throw new TypeError(); + if (!IsObject(target)) + throw new TypeError(); + if (!IsObject(attributes) && !IsUndefined(attributes) && !IsNull(attributes)) + throw new TypeError(); + if (IsNull(attributes)) + attributes = undefined; + propertyKey = ToPropertyKey(propertyKey); + return DecorateProperty(decorators, target, propertyKey, attributes); + } + else { + if (!IsArray(decorators)) + throw new TypeError(); + if (!IsConstructor(target)) + throw new TypeError(); + return DecorateConstructor(decorators, target); + } + } + exporter("decorate", decorate); + // 4.1.2 Reflect.metadata(metadataKey, metadataValue) + // https://rbuckton.github.io/reflect-metadata/#reflect.metadata + /** + * A default metadata decorator factory that can be used on a class, class member, or parameter. + * @param metadataKey The key for the metadata entry. + * @param metadataValue The value for the metadata entry. + * @returns A decorator function. + * @remarks + * If `metadataKey` is already defined for the target and target key, the + * metadataValue for that key will be overwritten. + * @example + * + * // constructor + * @Reflect.metadata(key, value) + * class Example { + * } + * + * // property (on constructor, TypeScript only) + * class Example { + * @Reflect.metadata(key, value) + * static staticProperty; + * } + * + * // property (on prototype, TypeScript only) + * class Example { + * @Reflect.metadata(key, value) + * property; + * } + * + * // method (on constructor) + * class Example { + * @Reflect.metadata(key, value) + * static staticMethod() { } + * } + * + * // method (on prototype) + * class Example { + * @Reflect.metadata(key, value) + * method() { } + * } + * + */ + function metadata(metadataKey, metadataValue) { + function decorator(target, propertyKey) { + if (!IsObject(target)) + throw new TypeError(); + if (!IsUndefined(propertyKey) && !IsPropertyKey(propertyKey)) + throw new TypeError(); + OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey); + } + return decorator; + } + exporter("metadata", metadata); + /** + * Define a unique metadata entry on the target. + * @param metadataKey A key used to store and retrieve metadata. + * @param metadataValue A value that contains attached metadata. + * @param target The target object on which to define metadata. + * @param propertyKey (Optional) The property key for the target. + * @example + * + * class Example { + * // property declarations are not part of ES6, though they are valid in TypeScript: + * // static staticProperty; + * // property; + * + * constructor(p) { } + * static staticMethod(p) { } + * method(p) { } + * } + * + * // constructor + * Reflect.defineMetadata("custom:annotation", options, Example); + * + * // property (on constructor) + * Reflect.defineMetadata("custom:annotation", options, Example, "staticProperty"); + * + * // property (on prototype) + * Reflect.defineMetadata("custom:annotation", options, Example.prototype, "property"); + * + * // method (on constructor) + * Reflect.defineMetadata("custom:annotation", options, Example, "staticMethod"); + * + * // method (on prototype) + * Reflect.defineMetadata("custom:annotation", options, Example.prototype, "method"); + * + * // decorator factory as metadata-producing annotation. + * function MyAnnotation(options): Decorator { + * return (target, key?) => Reflect.defineMetadata("custom:annotation", options, target, key); + * } + * + */ + function defineMetadata(metadataKey, metadataValue, target, propertyKey) { + if (!IsObject(target)) + throw new TypeError(); + if (!IsUndefined(propertyKey)) + propertyKey = ToPropertyKey(propertyKey); + return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey); + } + exporter("defineMetadata", defineMetadata); + /** + * Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined. + * @param metadataKey A key used to store and retrieve metadata. + * @param target The target object on which the metadata is defined. + * @param propertyKey (Optional) The property key for the target. + * @returns `true` if the metadata key was defined on the target object or its prototype chain; otherwise, `false`. + * @example + * + * class Example { + * // property declarations are not part of ES6, though they are valid in TypeScript: + * // static staticProperty; + * // property; + * + * constructor(p) { } + * static staticMethod(p) { } + * method(p) { } + * } + * + * // constructor + * result = Reflect.hasMetadata("custom:annotation", Example); + * + * // property (on constructor) + * result = Reflect.hasMetadata("custom:annotation", Example, "staticProperty"); + * + * // property (on prototype) + * result = Reflect.hasMetadata("custom:annotation", Example.prototype, "property"); + * + * // method (on constructor) + * result = Reflect.hasMetadata("custom:annotation", Example, "staticMethod"); + * + * // method (on prototype) + * result = Reflect.hasMetadata("custom:annotation", Example.prototype, "method"); + * + */ + function hasMetadata(metadataKey, target, propertyKey) { + if (!IsObject(target)) + throw new TypeError(); + if (!IsUndefined(propertyKey)) + propertyKey = ToPropertyKey(propertyKey); + return OrdinaryHasMetadata(metadataKey, target, propertyKey); + } + exporter("hasMetadata", hasMetadata); + /** + * Gets a value indicating whether the target object has the provided metadata key defined. + * @param metadataKey A key used to store and retrieve metadata. + * @param target The target object on which the metadata is defined. + * @param propertyKey (Optional) The property key for the target. + * @returns `true` if the metadata key was defined on the target object; otherwise, `false`. + * @example + * + * class Example { + * // property declarations are not part of ES6, though they are valid in TypeScript: + * // static staticProperty; + * // property; + * + * constructor(p) { } + * static staticMethod(p) { } + * method(p) { } + * } + * + * // constructor + * result = Reflect.hasOwnMetadata("custom:annotation", Example); + * + * // property (on constructor) + * result = Reflect.hasOwnMetadata("custom:annotation", Example, "staticProperty"); + * + * // property (on prototype) + * result = Reflect.hasOwnMetadata("custom:annotation", Example.prototype, "property"); + * + * // method (on constructor) + * result = Reflect.hasOwnMetadata("custom:annotation", Example, "staticMethod"); + * + * // method (on prototype) + * result = Reflect.hasOwnMetadata("custom:annotation", Example.prototype, "method"); + * + */ + function hasOwnMetadata(metadataKey, target, propertyKey) { + if (!IsObject(target)) + throw new TypeError(); + if (!IsUndefined(propertyKey)) + propertyKey = ToPropertyKey(propertyKey); + return OrdinaryHasOwnMetadata(metadataKey, target, propertyKey); + } + exporter("hasOwnMetadata", hasOwnMetadata); + /** + * Gets the metadata value for the provided metadata key on the target object or its prototype chain. + * @param metadataKey A key used to store and retrieve metadata. + * @param target The target object on which the metadata is defined. + * @param propertyKey (Optional) The property key for the target. + * @returns The metadata value for the metadata key if found; otherwise, `undefined`. + * @example + * + * class Example { + * // property declarations are not part of ES6, though they are valid in TypeScript: + * // static staticProperty; + * // property; + * + * constructor(p) { } + * static staticMethod(p) { } + * method(p) { } + * } + * + * // constructor + * result = Reflect.getMetadata("custom:annotation", Example); + * + * // property (on constructor) + * result = Reflect.getMetadata("custom:annotation", Example, "staticProperty"); + * + * // property (on prototype) + * result = Reflect.getMetadata("custom:annotation", Example.prototype, "property"); + * + * // method (on constructor) + * result = Reflect.getMetadata("custom:annotation", Example, "staticMethod"); + * + * // method (on prototype) + * result = Reflect.getMetadata("custom:annotation", Example.prototype, "method"); + * + */ + function getMetadata(metadataKey, target, propertyKey) { + if (!IsObject(target)) + throw new TypeError(); + if (!IsUndefined(propertyKey)) + propertyKey = ToPropertyKey(propertyKey); + return OrdinaryGetMetadata(metadataKey, target, propertyKey); + } + exporter("getMetadata", getMetadata); + /** + * Gets the metadata value for the provided metadata key on the target object. + * @param metadataKey A key used to store and retrieve metadata. + * @param target The target object on which the metadata is defined. + * @param propertyKey (Optional) The property key for the target. + * @returns The metadata value for the metadata key if found; otherwise, `undefined`. + * @example + * + * class Example { + * // property declarations are not part of ES6, though they are valid in TypeScript: + * // static staticProperty; + * // property; + * + * constructor(p) { } + * static staticMethod(p) { } + * method(p) { } + * } + * + * // constructor + * result = Reflect.getOwnMetadata("custom:annotation", Example); + * + * // property (on constructor) + * result = Reflect.getOwnMetadata("custom:annotation", Example, "staticProperty"); + * + * // property (on prototype) + * result = Reflect.getOwnMetadata("custom:annotation", Example.prototype, "property"); + * + * // method (on constructor) + * result = Reflect.getOwnMetadata("custom:annotation", Example, "staticMethod"); + * + * // method (on prototype) + * result = Reflect.getOwnMetadata("custom:annotation", Example.prototype, "method"); + * + */ + function getOwnMetadata(metadataKey, target, propertyKey) { + if (!IsObject(target)) + throw new TypeError(); + if (!IsUndefined(propertyKey)) + propertyKey = ToPropertyKey(propertyKey); + return OrdinaryGetOwnMetadata(metadataKey, target, propertyKey); + } + exporter("getOwnMetadata", getOwnMetadata); + /** + * Gets the metadata keys defined on the target object or its prototype chain. + * @param target The target object on which the metadata is defined. + * @param propertyKey (Optional) The property key for the target. + * @returns An array of unique metadata keys. + * @example + * + * class Example { + * // property declarations are not part of ES6, though they are valid in TypeScript: + * // static staticProperty; + * // property; + * + * constructor(p) { } + * static staticMethod(p) { } + * method(p) { } + * } + * + * // constructor + * result = Reflect.getMetadataKeys(Example); + * + * // property (on constructor) + * result = Reflect.getMetadataKeys(Example, "staticProperty"); + * + * // property (on prototype) + * result = Reflect.getMetadataKeys(Example.prototype, "property"); + * + * // method (on constructor) + * result = Reflect.getMetadataKeys(Example, "staticMethod"); + * + * // method (on prototype) + * result = Reflect.getMetadataKeys(Example.prototype, "method"); + * + */ + function getMetadataKeys(target, propertyKey) { + if (!IsObject(target)) + throw new TypeError(); + if (!IsUndefined(propertyKey)) + propertyKey = ToPropertyKey(propertyKey); + return OrdinaryMetadataKeys(target, propertyKey); + } + exporter("getMetadataKeys", getMetadataKeys); + /** + * Gets the unique metadata keys defined on the target object. + * @param target The target object on which the metadata is defined. + * @param propertyKey (Optional) The property key for the target. + * @returns An array of unique metadata keys. + * @example + * + * class Example { + * // property declarations are not part of ES6, though they are valid in TypeScript: + * // static staticProperty; + * // property; + * + * constructor(p) { } + * static staticMethod(p) { } + * method(p) { } + * } + * + * // constructor + * result = Reflect.getOwnMetadataKeys(Example); + * + * // property (on constructor) + * result = Reflect.getOwnMetadataKeys(Example, "staticProperty"); + * + * // property (on prototype) + * result = Reflect.getOwnMetadataKeys(Example.prototype, "property"); + * + * // method (on constructor) + * result = Reflect.getOwnMetadataKeys(Example, "staticMethod"); + * + * // method (on prototype) + * result = Reflect.getOwnMetadataKeys(Example.prototype, "method"); + * + */ + function getOwnMetadataKeys(target, propertyKey) { + if (!IsObject(target)) + throw new TypeError(); + if (!IsUndefined(propertyKey)) + propertyKey = ToPropertyKey(propertyKey); + return OrdinaryOwnMetadataKeys(target, propertyKey); + } + exporter("getOwnMetadataKeys", getOwnMetadataKeys); + /** + * Deletes the metadata entry from the target object with the provided key. + * @param metadataKey A key used to store and retrieve metadata. + * @param target The target object on which the metadata is defined. + * @param propertyKey (Optional) The property key for the target. + * @returns `true` if the metadata entry was found and deleted; otherwise, false. + * @example + * + * class Example { + * // property declarations are not part of ES6, though they are valid in TypeScript: + * // static staticProperty; + * // property; + * + * constructor(p) { } + * static staticMethod(p) { } + * method(p) { } + * } + * + * // constructor + * result = Reflect.deleteMetadata("custom:annotation", Example); + * + * // property (on constructor) + * result = Reflect.deleteMetadata("custom:annotation", Example, "staticProperty"); + * + * // property (on prototype) + * result = Reflect.deleteMetadata("custom:annotation", Example.prototype, "property"); + * + * // method (on constructor) + * result = Reflect.deleteMetadata("custom:annotation", Example, "staticMethod"); + * + * // method (on prototype) + * result = Reflect.deleteMetadata("custom:annotation", Example.prototype, "method"); + * + */ + function deleteMetadata(metadataKey, target, propertyKey) { + if (!IsObject(target)) + throw new TypeError(); + if (!IsUndefined(propertyKey)) + propertyKey = ToPropertyKey(propertyKey); + var metadataMap = GetOrCreateMetadataMap(target, propertyKey, /*Create*/ false); + if (IsUndefined(metadataMap)) + return false; + if (!metadataMap.delete(metadataKey)) + return false; + if (metadataMap.size > 0) + return true; + var targetMetadata = Metadata.get(target); + targetMetadata.delete(propertyKey); + if (targetMetadata.size > 0) + return true; + Metadata.delete(target); + return true; + } + exporter("deleteMetadata", deleteMetadata); + function DecorateConstructor(decorators, target) { + for (var i = decorators.length - 1; i >= 0; --i) { + var decorator = decorators[i]; + var decorated = decorator(target); + if (!IsUndefined(decorated) && !IsNull(decorated)) { + if (!IsConstructor(decorated)) + throw new TypeError(); + target = decorated; + } + } + return target; + } + function DecorateProperty(decorators, target, propertyKey, descriptor) { + for (var i = decorators.length - 1; i >= 0; --i) { + var decorator = decorators[i]; + var decorated = decorator(target, propertyKey, descriptor); + if (!IsUndefined(decorated) && !IsNull(decorated)) { + if (!IsObject(decorated)) + throw new TypeError(); + descriptor = decorated; + } + } + return descriptor; + } + function GetOrCreateMetadataMap(O, P, Create) { + var targetMetadata = Metadata.get(O); + if (IsUndefined(targetMetadata)) { + if (!Create) + return undefined; + targetMetadata = new _Map(); + Metadata.set(O, targetMetadata); + } + var metadataMap = targetMetadata.get(P); + if (IsUndefined(metadataMap)) { + if (!Create) + return undefined; + metadataMap = new _Map(); + targetMetadata.set(P, metadataMap); + } + return metadataMap; + } + // 3.1.1.1 OrdinaryHasMetadata(MetadataKey, O, P) + // https://rbuckton.github.io/reflect-metadata/#ordinaryhasmetadata + function OrdinaryHasMetadata(MetadataKey, O, P) { + var hasOwn = OrdinaryHasOwnMetadata(MetadataKey, O, P); + if (hasOwn) + return true; + var parent = OrdinaryGetPrototypeOf(O); + if (!IsNull(parent)) + return OrdinaryHasMetadata(MetadataKey, parent, P); + return false; + } + // 3.1.2.1 OrdinaryHasOwnMetadata(MetadataKey, O, P) + // https://rbuckton.github.io/reflect-metadata/#ordinaryhasownmetadata + function OrdinaryHasOwnMetadata(MetadataKey, O, P) { + var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ false); + if (IsUndefined(metadataMap)) + return false; + return ToBoolean(metadataMap.has(MetadataKey)); + } + // 3.1.3.1 OrdinaryGetMetadata(MetadataKey, O, P) + // https://rbuckton.github.io/reflect-metadata/#ordinarygetmetadata + function OrdinaryGetMetadata(MetadataKey, O, P) { + var hasOwn = OrdinaryHasOwnMetadata(MetadataKey, O, P); + if (hasOwn) + return OrdinaryGetOwnMetadata(MetadataKey, O, P); + var parent = OrdinaryGetPrototypeOf(O); + if (!IsNull(parent)) + return OrdinaryGetMetadata(MetadataKey, parent, P); + return undefined; + } + // 3.1.4.1 OrdinaryGetOwnMetadata(MetadataKey, O, P) + // https://rbuckton.github.io/reflect-metadata/#ordinarygetownmetadata + function OrdinaryGetOwnMetadata(MetadataKey, O, P) { + var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ false); + if (IsUndefined(metadataMap)) + return undefined; + return metadataMap.get(MetadataKey); + } + // 3.1.5.1 OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) + // https://rbuckton.github.io/reflect-metadata/#ordinarydefineownmetadata + function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) { + var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ true); + metadataMap.set(MetadataKey, MetadataValue); + } + // 3.1.6.1 OrdinaryMetadataKeys(O, P) + // https://rbuckton.github.io/reflect-metadata/#ordinarymetadatakeys + function OrdinaryMetadataKeys(O, P) { + var ownKeys = OrdinaryOwnMetadataKeys(O, P); + var parent = OrdinaryGetPrototypeOf(O); + if (parent === null) + return ownKeys; + var parentKeys = OrdinaryMetadataKeys(parent, P); + if (parentKeys.length <= 0) + return ownKeys; + if (ownKeys.length <= 0) + return parentKeys; + var set = new _Set(); + var keys = []; + for (var _i = 0, ownKeys_1 = ownKeys; _i < ownKeys_1.length; _i++) { + var key = ownKeys_1[_i]; + var hasKey = set.has(key); + if (!hasKey) { + set.add(key); + keys.push(key); + } + } + for (var _a = 0, parentKeys_1 = parentKeys; _a < parentKeys_1.length; _a++) { + var key = parentKeys_1[_a]; + var hasKey = set.has(key); + if (!hasKey) { + set.add(key); + keys.push(key); + } + } + return keys; + } + // 3.1.7.1 OrdinaryOwnMetadataKeys(O, P) + // https://rbuckton.github.io/reflect-metadata/#ordinaryownmetadatakeys + function OrdinaryOwnMetadataKeys(O, P) { + var keys = []; + var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ false); + if (IsUndefined(metadataMap)) + return keys; + var keysObj = metadataMap.keys(); + var iterator = GetIterator(keysObj); + var k = 0; + while (true) { + var next = IteratorStep(iterator); + if (!next) { + keys.length = k; + return keys; + } + var nextValue = IteratorValue(next); + try { + keys[k] = nextValue; + } + catch (e) { + try { + IteratorClose(iterator); + } + finally { + throw e; + } + } + k++; + } + } + // 6 ECMAScript Data Typ0es and Values + // https://tc39.github.io/ecma262/#sec-ecmascript-data-types-and-values + function Type(x) { + if (x === null) + return 1 /* Null */; + switch (typeof x) { + case "undefined": return 0 /* Undefined */; + case "boolean": return 2 /* Boolean */; + case "string": return 3 /* String */; + case "symbol": return 4 /* Symbol */; + case "number": return 5 /* Number */; + case "object": return x === null ? 1 /* Null */ : 6 /* Object */; + default: return 6 /* Object */; + } + } + // 6.1.1 The Undefined Type + // https://tc39.github.io/ecma262/#sec-ecmascript-language-types-undefined-type + function IsUndefined(x) { + return x === undefined; + } + // 6.1.2 The Null Type + // https://tc39.github.io/ecma262/#sec-ecmascript-language-types-null-type + function IsNull(x) { + return x === null; + } + // 6.1.5 The Symbol Type + // https://tc39.github.io/ecma262/#sec-ecmascript-language-types-symbol-type + function IsSymbol(x) { + return typeof x === "symbol"; + } + // 6.1.7 The Object Type + // https://tc39.github.io/ecma262/#sec-object-type + function IsObject(x) { + return typeof x === "object" ? x !== null : typeof x === "function"; + } + // 7.1 Type Conversion + // https://tc39.github.io/ecma262/#sec-type-conversion + // 7.1.1 ToPrimitive(input [, PreferredType]) + // https://tc39.github.io/ecma262/#sec-toprimitive + function ToPrimitive(input, PreferredType) { + switch (Type(input)) { + case 0 /* Undefined */: return input; + case 1 /* Null */: return input; + case 2 /* Boolean */: return input; + case 3 /* String */: return input; + case 4 /* Symbol */: return input; + case 5 /* Number */: return input; + } + var hint = PreferredType === 3 /* String */ ? "string" : PreferredType === 5 /* Number */ ? "number" : "default"; + var exoticToPrim = GetMethod(input, toPrimitiveSymbol); + if (exoticToPrim !== undefined) { + var result = exoticToPrim.call(input, hint); + if (IsObject(result)) + throw new TypeError(); + return result; + } + return OrdinaryToPrimitive(input, hint === "default" ? "number" : hint); + } + // 7.1.1.1 OrdinaryToPrimitive(O, hint) + // https://tc39.github.io/ecma262/#sec-ordinarytoprimitive + function OrdinaryToPrimitive(O, hint) { + if (hint === "string") { + var toString_1 = O.toString; + if (IsCallable(toString_1)) { + var result = toString_1.call(O); + if (!IsObject(result)) + return result; + } + var valueOf = O.valueOf; + if (IsCallable(valueOf)) { + var result = valueOf.call(O); + if (!IsObject(result)) + return result; + } + } + else { + var valueOf = O.valueOf; + if (IsCallable(valueOf)) { + var result = valueOf.call(O); + if (!IsObject(result)) + return result; + } + var toString_2 = O.toString; + if (IsCallable(toString_2)) { + var result = toString_2.call(O); + if (!IsObject(result)) + return result; + } + } + throw new TypeError(); + } + // 7.1.2 ToBoolean(argument) + // https://tc39.github.io/ecma262/2016/#sec-toboolean + function ToBoolean(argument) { + return !!argument; + } + // 7.1.12 ToString(argument) + // https://tc39.github.io/ecma262/#sec-tostring + function ToString(argument) { + return "" + argument; + } + // 7.1.14 ToPropertyKey(argument) + // https://tc39.github.io/ecma262/#sec-topropertykey + function ToPropertyKey(argument) { + var key = ToPrimitive(argument, 3 /* String */); + if (IsSymbol(key)) + return key; + return ToString(key); + } + // 7.2 Testing and Comparison Operations + // https://tc39.github.io/ecma262/#sec-testing-and-comparison-operations + // 7.2.2 IsArray(argument) + // https://tc39.github.io/ecma262/#sec-isarray + function IsArray(argument) { + return Array.isArray + ? Array.isArray(argument) + : argument instanceof Object + ? argument instanceof Array + : Object.prototype.toString.call(argument) === "[object Array]"; + } + // 7.2.3 IsCallable(argument) + // https://tc39.github.io/ecma262/#sec-iscallable + function IsCallable(argument) { + // NOTE: This is an approximation as we cannot check for [[Call]] internal method. + return typeof argument === "function"; + } + // 7.2.4 IsConstructor(argument) + // https://tc39.github.io/ecma262/#sec-isconstructor + function IsConstructor(argument) { + // NOTE: This is an approximation as we cannot check for [[Construct]] internal method. + return typeof argument === "function"; + } + // 7.2.7 IsPropertyKey(argument) + // https://tc39.github.io/ecma262/#sec-ispropertykey + function IsPropertyKey(argument) { + switch (Type(argument)) { + case 3 /* String */: return true; + case 4 /* Symbol */: return true; + default: return false; + } + } + // 7.3 Operations on Objects + // https://tc39.github.io/ecma262/#sec-operations-on-objects + // 7.3.9 GetMethod(V, P) + // https://tc39.github.io/ecma262/#sec-getmethod + function GetMethod(V, P) { + var func = V[P]; + if (func === undefined || func === null) + return undefined; + if (!IsCallable(func)) + throw new TypeError(); + return func; + } + // 7.4 Operations on Iterator Objects + // https://tc39.github.io/ecma262/#sec-operations-on-iterator-objects + function GetIterator(obj) { + var method = GetMethod(obj, iteratorSymbol); + if (!IsCallable(method)) + throw new TypeError(); // from Call + var iterator = method.call(obj); + if (!IsObject(iterator)) + throw new TypeError(); + return iterator; + } + // 7.4.4 IteratorValue(iterResult) + // https://tc39.github.io/ecma262/2016/#sec-iteratorvalue + function IteratorValue(iterResult) { + return iterResult.value; + } + // 7.4.5 IteratorStep(iterator) + // https://tc39.github.io/ecma262/#sec-iteratorstep + function IteratorStep(iterator) { + var result = iterator.next(); + return result.done ? false : result; + } + // 7.4.6 IteratorClose(iterator, completion) + // https://tc39.github.io/ecma262/#sec-iteratorclose + function IteratorClose(iterator) { + var f = iterator["return"]; + if (f) + f.call(iterator); + } + // 9.1 Ordinary Object Internal Methods and Internal Slots + // https://tc39.github.io/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots + // 9.1.1.1 OrdinaryGetPrototypeOf(O) + // https://tc39.github.io/ecma262/#sec-ordinarygetprototypeof + function OrdinaryGetPrototypeOf(O) { + var proto = Object.getPrototypeOf(O); + if (typeof O !== "function" || O === functionPrototype) + return proto; + // TypeScript doesn't set __proto__ in ES5, as it's non-standard. + // Try to determine the superclass constructor. Compatible implementations + // must either set __proto__ on a subclass constructor to the superclass constructor, + // or ensure each class has a valid `constructor` property on its prototype that + // points back to the constructor. + // If this is not the same as Function.[[Prototype]], then this is definately inherited. + // This is the case when in ES6 or when using __proto__ in a compatible browser. + if (proto !== functionPrototype) + return proto; + // If the super prototype is Object.prototype, null, or undefined, then we cannot determine the heritage. + var prototype = O.prototype; + var prototypeProto = prototype && Object.getPrototypeOf(prototype); + if (prototypeProto == null || prototypeProto === Object.prototype) + return proto; + // If the constructor was not a function, then we cannot determine the heritage. + var constructor = prototypeProto.constructor; + if (typeof constructor !== "function") + return proto; + // If we have some kind of self-reference, then we cannot determine the heritage. + if (constructor === O) + return proto; + // we have a pretty good guess at the heritage. + return constructor; + } + // naive Map shim + function CreateMapPolyfill() { + var cacheSentinel = {}; + var arraySentinel = []; + var MapIterator = /** @class */ (function () { + function MapIterator(keys, values, selector) { + this._index = 0; + this._keys = keys; + this._values = values; + this._selector = selector; + } + MapIterator.prototype["@@iterator"] = function () { return this; }; + MapIterator.prototype[iteratorSymbol] = function () { return this; }; + MapIterator.prototype.next = function () { + var index = this._index; + if (index >= 0 && index < this._keys.length) { + var result = this._selector(this._keys[index], this._values[index]); + if (index + 1 >= this._keys.length) { + this._index = -1; + this._keys = arraySentinel; + this._values = arraySentinel; + } + else { + this._index++; + } + return { value: result, done: false }; + } + return { value: undefined, done: true }; + }; + MapIterator.prototype.throw = function (error) { + if (this._index >= 0) { + this._index = -1; + this._keys = arraySentinel; + this._values = arraySentinel; + } + throw error; + }; + MapIterator.prototype.return = function (value) { + if (this._index >= 0) { + this._index = -1; + this._keys = arraySentinel; + this._values = arraySentinel; + } + return { value: value, done: true }; + }; + return MapIterator; + }()); + return /** @class */ (function () { + function Map() { + this._keys = []; + this._values = []; + this._cacheKey = cacheSentinel; + this._cacheIndex = -2; + } + Object.defineProperty(Map.prototype, "size", { + get: function () { return this._keys.length; }, + enumerable: true, + configurable: true + }); + Map.prototype.has = function (key) { return this._find(key, /*insert*/ false) >= 0; }; + Map.prototype.get = function (key) { + var index = this._find(key, /*insert*/ false); + return index >= 0 ? this._values[index] : undefined; + }; + Map.prototype.set = function (key, value) { + var index = this._find(key, /*insert*/ true); + this._values[index] = value; + return this; + }; + Map.prototype.delete = function (key) { + var index = this._find(key, /*insert*/ false); + if (index >= 0) { + var size = this._keys.length; + for (var i = index + 1; i < size; i++) { + this._keys[i - 1] = this._keys[i]; + this._values[i - 1] = this._values[i]; + } + this._keys.length--; + this._values.length--; + if (key === this._cacheKey) { + this._cacheKey = cacheSentinel; + this._cacheIndex = -2; + } + return true; + } + return false; + }; + Map.prototype.clear = function () { + this._keys.length = 0; + this._values.length = 0; + this._cacheKey = cacheSentinel; + this._cacheIndex = -2; + }; + Map.prototype.keys = function () { return new MapIterator(this._keys, this._values, getKey); }; + Map.prototype.values = function () { return new MapIterator(this._keys, this._values, getValue); }; + Map.prototype.entries = function () { return new MapIterator(this._keys, this._values, getEntry); }; + Map.prototype["@@iterator"] = function () { return this.entries(); }; + Map.prototype[iteratorSymbol] = function () { return this.entries(); }; + Map.prototype._find = function (key, insert) { + if (this._cacheKey !== key) { + this._cacheIndex = this._keys.indexOf(this._cacheKey = key); + } + if (this._cacheIndex < 0 && insert) { + this._cacheIndex = this._keys.length; + this._keys.push(key); + this._values.push(undefined); + } + return this._cacheIndex; + }; + return Map; + }()); + function getKey(key, _) { + return key; + } + function getValue(_, value) { + return value; + } + function getEntry(key, value) { + return [key, value]; + } + } + // naive Set shim + function CreateSetPolyfill() { + return /** @class */ (function () { + function Set() { + this._map = new _Map(); + } + Object.defineProperty(Set.prototype, "size", { + get: function () { return this._map.size; }, + enumerable: true, + configurable: true + }); + Set.prototype.has = function (value) { return this._map.has(value); }; + Set.prototype.add = function (value) { return this._map.set(value, value), this; }; + Set.prototype.delete = function (value) { return this._map.delete(value); }; + Set.prototype.clear = function () { this._map.clear(); }; + Set.prototype.keys = function () { return this._map.keys(); }; + Set.prototype.values = function () { return this._map.values(); }; + Set.prototype.entries = function () { return this._map.entries(); }; + Set.prototype["@@iterator"] = function () { return this.keys(); }; + Set.prototype[iteratorSymbol] = function () { return this.keys(); }; + return Set; + }()); + } + // naive WeakMap shim + function CreateWeakMapPolyfill() { + var UUID_SIZE = 16; + var keys = HashMap.create(); + var rootKey = CreateUniqueKey(); + return /** @class */ (function () { + function WeakMap() { + this._key = CreateUniqueKey(); + } + WeakMap.prototype.has = function (target) { + var table = GetOrCreateWeakMapTable(target, /*create*/ false); + return table !== undefined ? HashMap.has(table, this._key) : false; + }; + WeakMap.prototype.get = function (target) { + var table = GetOrCreateWeakMapTable(target, /*create*/ false); + return table !== undefined ? HashMap.get(table, this._key) : undefined; + }; + WeakMap.prototype.set = function (target, value) { + var table = GetOrCreateWeakMapTable(target, /*create*/ true); + table[this._key] = value; + return this; + }; + WeakMap.prototype.delete = function (target) { + var table = GetOrCreateWeakMapTable(target, /*create*/ false); + return table !== undefined ? delete table[this._key] : false; + }; + WeakMap.prototype.clear = function () { + // NOTE: not a real clear, just makes the previous data unreachable + this._key = CreateUniqueKey(); + }; + return WeakMap; + }()); + function CreateUniqueKey() { + var key; + do + key = "@@WeakMap@@" + CreateUUID(); + while (HashMap.has(keys, key)); + keys[key] = true; + return key; + } + function GetOrCreateWeakMapTable(target, create) { + if (!hasOwn.call(target, rootKey)) { + if (!create) + return undefined; + Object.defineProperty(target, rootKey, { value: HashMap.create() }); + } + return target[rootKey]; + } + function FillRandomBytes(buffer, size) { + for (var i = 0; i < size; ++i) + buffer[i] = Math.random() * 0xff | 0; + return buffer; + } + function GenRandomBytes(size) { + if (typeof Uint8Array === "function") { + if (typeof crypto !== "undefined") + return crypto.getRandomValues(new Uint8Array(size)); + if (typeof msCrypto !== "undefined") + return msCrypto.getRandomValues(new Uint8Array(size)); + return FillRandomBytes(new Uint8Array(size), size); + } + return FillRandomBytes(new Array(size), size); + } + function CreateUUID() { + var data = GenRandomBytes(UUID_SIZE); + // mark as random - RFC 4122 § 4.4 + data[6] = data[6] & 0x4f | 0x40; + data[8] = data[8] & 0xbf | 0x80; + var result = ""; + for (var offset = 0; offset < UUID_SIZE; ++offset) { + var byte = data[offset]; + if (offset === 4 || offset === 6 || offset === 8) + result += "-"; + if (byte < 16) + result += "0"; + result += byte.toString(16).toLowerCase(); + } + return result; + } + } + // uses a heuristic used by v8 and chakra to force an object into dictionary mode. + function MakeDictionary(obj) { + obj.__ = undefined; + delete obj.__; + return obj; + } + }); +})(Reflect || (Reflect = {})); + + +/***/ }), + +/***/ 9509: +/***/ ((module, exports, __webpack_require__) => { + +/*! safe-buffer. MIT License. Feross Aboukhadijeh */ +/* eslint-disable node/no-deprecated-api */ +var buffer = __webpack_require__(8764) +var Buffer = buffer.Buffer + +// alternative to using Object.keys for old browsers +function copyProps (src, dst) { + for (var key in src) { + dst[key] = src[key] + } +} +if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) { + module.exports = buffer +} else { + // Copy properties from require('buffer') + copyProps(buffer, exports) + exports.Buffer = SafeBuffer +} + +function SafeBuffer (arg, encodingOrOffset, length) { + return Buffer(arg, encodingOrOffset, length) +} + +SafeBuffer.prototype = Object.create(Buffer.prototype) + +// Copy static methods from Buffer +copyProps(Buffer, SafeBuffer) + +SafeBuffer.from = function (arg, encodingOrOffset, length) { + if (typeof arg === 'number') { + throw new TypeError('Argument must not be a number') + } + return Buffer(arg, encodingOrOffset, length) +} + +SafeBuffer.alloc = function (size, fill, encoding) { + if (typeof size !== 'number') { + throw new TypeError('Argument must be a number') + } + var buf = Buffer(size) + if (fill !== undefined) { + if (typeof encoding === 'string') { + buf.fill(fill, encoding) + } else { + buf.fill(fill) + } + } else { + buf.fill(0) + } + return buf +} + +SafeBuffer.allocUnsafe = function (size) { + if (typeof size !== 'number') { + throw new TypeError('Argument must be a number') + } + return Buffer(size) +} + +SafeBuffer.allocUnsafeSlow = function (size) { + if (typeof size !== 'number') { + throw new TypeError('Argument must be a number') + } + return buffer.SlowBuffer(size) +} + + +/***/ }), + +/***/ 2830: +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +module.exports = Stream; + +var EE = (__webpack_require__(7187).EventEmitter); +var inherits = __webpack_require__(5717); + +inherits(Stream, EE); +Stream.Readable = __webpack_require__(9481); +Stream.Writable = __webpack_require__(4229); +Stream.Duplex = __webpack_require__(6753); +Stream.Transform = __webpack_require__(4605); +Stream.PassThrough = __webpack_require__(2725); +Stream.finished = __webpack_require__(8610) +Stream.pipeline = __webpack_require__(9946) + +// Backwards-compat with node 0.4.x +Stream.Stream = Stream; + + + +// old-style streams. Note that the pipe method (the only relevant +// part of this class) is overridden in the Readable class. + +function Stream() { + EE.call(this); +} + +Stream.prototype.pipe = function(dest, options) { + var source = this; + + function ondata(chunk) { + if (dest.writable) { + if (false === dest.write(chunk) && source.pause) { + source.pause(); + } + } + } + + source.on('data', ondata); + + function ondrain() { + if (source.readable && source.resume) { + source.resume(); + } + } + + dest.on('drain', ondrain); + + // If the 'end' option is not supplied, dest.end() will be called when + // source gets the 'end' or 'close' events. Only dest.end() once. + if (!dest._isStdio && (!options || options.end !== false)) { + source.on('end', onend); + source.on('close', onclose); + } + + var didOnEnd = false; + function onend() { + if (didOnEnd) return; + didOnEnd = true; + + dest.end(); + } + + + function onclose() { + if (didOnEnd) return; + didOnEnd = true; + + if (typeof dest.destroy === 'function') dest.destroy(); + } + + // don't leave dangling pipes when there are errors. + function onerror(er) { + cleanup(); + if (EE.listenerCount(this, 'error') === 0) { + throw er; // Unhandled stream error in pipe. + } + } + + source.on('error', onerror); + dest.on('error', onerror); + + // remove all the event listeners that were added. + function cleanup() { + source.removeListener('data', ondata); + dest.removeListener('drain', ondrain); + + source.removeListener('end', onend); + source.removeListener('close', onclose); + + source.removeListener('error', onerror); + dest.removeListener('error', onerror); + + source.removeListener('end', cleanup); + source.removeListener('close', cleanup); + + dest.removeListener('close', cleanup); + } + + source.on('end', cleanup); + source.on('close', cleanup); + + dest.on('close', cleanup); + + dest.emit('pipe', source); + + // Allow for unix-like usage: A.pipe(B).pipe(C) + return dest; +}; + + +/***/ }), + +/***/ 2553: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + + + +/**/ + +var Buffer = (__webpack_require__(9509).Buffer); +/**/ + +var isEncoding = Buffer.isEncoding || function (encoding) { + encoding = '' + encoding; + switch (encoding && encoding.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 true; + default: + return false; + } +}; + +function _normalizeEncoding(enc) { + if (!enc) return 'utf8'; + var retried; + while (true) { + switch (enc) { + case 'utf8': + case 'utf-8': + return 'utf8'; + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + return 'utf16le'; + case 'latin1': + case 'binary': + return 'latin1'; + case 'base64': + case 'ascii': + case 'hex': + return enc; + default: + if (retried) return; // undefined + enc = ('' + enc).toLowerCase(); + retried = true; + } + } +}; + +// Do not cache `Buffer.isEncoding` when checking encoding names as some +// modules monkey-patch it to support additional encodings +function normalizeEncoding(enc) { + var nenc = _normalizeEncoding(enc); + if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc); + return nenc || enc; +} + +// StringDecoder provides an interface for efficiently splitting a series of +// buffers into a series of JS strings without breaking apart multi-byte +// characters. +exports.s = StringDecoder; +function StringDecoder(encoding) { + this.encoding = normalizeEncoding(encoding); + var nb; + switch (this.encoding) { + case 'utf16le': + this.text = utf16Text; + this.end = utf16End; + nb = 4; + break; + case 'utf8': + this.fillLast = utf8FillLast; + nb = 4; + break; + case 'base64': + this.text = base64Text; + this.end = base64End; + nb = 3; + break; + default: + this.write = simpleWrite; + this.end = simpleEnd; + return; + } + this.lastNeed = 0; + this.lastTotal = 0; + this.lastChar = Buffer.allocUnsafe(nb); +} + +StringDecoder.prototype.write = function (buf) { + if (buf.length === 0) return ''; + var r; + var i; + if (this.lastNeed) { + r = this.fillLast(buf); + if (r === undefined) return ''; + i = this.lastNeed; + this.lastNeed = 0; + } else { + i = 0; + } + if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i); + return r || ''; +}; + +StringDecoder.prototype.end = utf8End; + +// Returns only complete characters in a Buffer +StringDecoder.prototype.text = utf8Text; + +// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer +StringDecoder.prototype.fillLast = function (buf) { + if (this.lastNeed <= buf.length) { + buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed); + return this.lastChar.toString(this.encoding, 0, this.lastTotal); + } + buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length); + this.lastNeed -= buf.length; +}; + +// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a +// continuation byte. If an invalid byte is detected, -2 is returned. +function utf8CheckByte(byte) { + if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4; + return byte >> 6 === 0x02 ? -1 : -2; +} + +// Checks at most 3 bytes at the end of a Buffer in order to detect an +// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4) +// needed to complete the UTF-8 character (if applicable) are returned. +function utf8CheckIncomplete(self, buf, i) { + var j = buf.length - 1; + if (j < i) return 0; + var nb = utf8CheckByte(buf[j]); + if (nb >= 0) { + if (nb > 0) self.lastNeed = nb - 1; + return nb; + } + if (--j < i || nb === -2) return 0; + nb = utf8CheckByte(buf[j]); + if (nb >= 0) { + if (nb > 0) self.lastNeed = nb - 2; + return nb; + } + if (--j < i || nb === -2) return 0; + nb = utf8CheckByte(buf[j]); + if (nb >= 0) { + if (nb > 0) { + if (nb === 2) nb = 0;else self.lastNeed = nb - 3; + } + return nb; + } + return 0; +} + +// Validates as many continuation bytes for a multi-byte UTF-8 character as +// needed or are available. If we see a non-continuation byte where we expect +// one, we "replace" the validated continuation bytes we've seen so far with +// a single UTF-8 replacement character ('\ufffd'), to match v8's UTF-8 decoding +// behavior. The continuation byte check is included three times in the case +// where all of the continuation bytes for a character exist in the same buffer. +// It is also done this way as a slight performance increase instead of using a +// loop. +function utf8CheckExtraBytes(self, buf, p) { + if ((buf[0] & 0xC0) !== 0x80) { + self.lastNeed = 0; + return '\ufffd'; + } + if (self.lastNeed > 1 && buf.length > 1) { + if ((buf[1] & 0xC0) !== 0x80) { + self.lastNeed = 1; + return '\ufffd'; + } + if (self.lastNeed > 2 && buf.length > 2) { + if ((buf[2] & 0xC0) !== 0x80) { + self.lastNeed = 2; + return '\ufffd'; + } + } + } +} + +// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer. +function utf8FillLast(buf) { + var p = this.lastTotal - this.lastNeed; + var r = utf8CheckExtraBytes(this, buf, p); + if (r !== undefined) return r; + if (this.lastNeed <= buf.length) { + buf.copy(this.lastChar, p, 0, this.lastNeed); + return this.lastChar.toString(this.encoding, 0, this.lastTotal); + } + buf.copy(this.lastChar, p, 0, buf.length); + this.lastNeed -= buf.length; +} + +// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a +// partial character, the character's bytes are buffered until the required +// number of bytes are available. +function utf8Text(buf, i) { + var total = utf8CheckIncomplete(this, buf, i); + if (!this.lastNeed) return buf.toString('utf8', i); + this.lastTotal = total; + var end = buf.length - (total - this.lastNeed); + buf.copy(this.lastChar, 0, end); + return buf.toString('utf8', i, end); +} + +// For UTF-8, a replacement character is added when ending on a partial +// character. +function utf8End(buf) { + var r = buf && buf.length ? this.write(buf) : ''; + if (this.lastNeed) return r + '\ufffd'; + return r; +} + +// UTF-16LE typically needs two bytes per character, but even if we have an even +// number of bytes available, we need to check if we end on a leading/high +// surrogate. In that case, we need to wait for the next two bytes in order to +// decode the last character properly. +function utf16Text(buf, i) { + if ((buf.length - i) % 2 === 0) { + var r = buf.toString('utf16le', i); + if (r) { + var c = r.charCodeAt(r.length - 1); + if (c >= 0xD800 && c <= 0xDBFF) { + this.lastNeed = 2; + this.lastTotal = 4; + this.lastChar[0] = buf[buf.length - 2]; + this.lastChar[1] = buf[buf.length - 1]; + return r.slice(0, -1); + } + } + return r; + } + this.lastNeed = 1; + this.lastTotal = 2; + this.lastChar[0] = buf[buf.length - 1]; + return buf.toString('utf16le', i, buf.length - 1); +} + +// For UTF-16LE we do not explicitly append special replacement characters if we +// end on a partial character, we simply let v8 handle that. +function utf16End(buf) { + var r = buf && buf.length ? this.write(buf) : ''; + if (this.lastNeed) { + var end = this.lastTotal - this.lastNeed; + return r + this.lastChar.toString('utf16le', 0, end); + } + return r; +} + +function base64Text(buf, i) { + var n = (buf.length - i) % 3; + if (n === 0) return buf.toString('base64', i); + this.lastNeed = 3 - n; + this.lastTotal = 3; + if (n === 1) { + this.lastChar[0] = buf[buf.length - 1]; + } else { + this.lastChar[0] = buf[buf.length - 2]; + this.lastChar[1] = buf[buf.length - 1]; + } + return buf.toString('base64', i, buf.length - n); +} + +function base64End(buf) { + var r = buf && buf.length ? this.write(buf) : ''; + if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed); + return r; +} + +// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex) +function simpleWrite(buf) { + return buf.toString(this.encoding); +} + +function simpleEnd(buf) { + return buf && buf.length ? this.write(buf) : ''; +} + +/***/ }), + +/***/ 4153: +/***/ ((module) => { + +const hexRegex = /^[-+]?0x[a-fA-F0-9]+$/; +const numRegex = /^([\-\+])?(0*)(\.[0-9]+([eE]\-?[0-9]+)?|[0-9]+(\.[0-9]+([eE]\-?[0-9]+)?)?)$/; +// const octRegex = /0x[a-z0-9]+/; +// const binRegex = /0x[a-z0-9]+/; + + +//polyfill +if (!Number.parseInt && window.parseInt) { + Number.parseInt = window.parseInt; +} +if (!Number.parseFloat && window.parseFloat) { + Number.parseFloat = window.parseFloat; +} + + +const consider = { + hex : true, + leadingZeros: true, + decimalPoint: "\.", + eNotation: true + //skipLike: /regex/ +}; + +function toNumber(str, options = {}){ + // const options = Object.assign({}, consider); + // if(opt.leadingZeros === false){ + // options.leadingZeros = false; + // }else if(opt.hex === false){ + // options.hex = false; + // } + + options = Object.assign({}, consider, options ); + if(!str || typeof str !== "string" ) return str; + + let trimmedStr = str.trim(); + // if(trimmedStr === "0.0") return 0; + // else if(trimmedStr === "+0.0") return 0; + // else if(trimmedStr === "-0.0") return -0; + + if(options.skipLike !== undefined && options.skipLike.test(trimmedStr)) return str; + else if (options.hex && hexRegex.test(trimmedStr)) { + return Number.parseInt(trimmedStr, 16); + // } else if (options.parseOct && octRegex.test(str)) { + // return Number.parseInt(val, 8); + // }else if (options.parseBin && binRegex.test(str)) { + // return Number.parseInt(val, 2); + }else{ + //separate negative sign, leading zeros, and rest number + const match = numRegex.exec(trimmedStr); + if(match){ + const sign = match[1]; + const leadingZeros = match[2]; + let numTrimmedByZeros = trimZeros(match[3]); //complete num without leading zeros + //trim ending zeros for floating number + + const eNotation = match[4] || match[6]; + if(!options.leadingZeros && leadingZeros.length > 0 && sign && trimmedStr[2] !== ".") return str; //-0123 + else if(!options.leadingZeros && leadingZeros.length > 0 && !sign && trimmedStr[1] !== ".") return str; //0123 + else{//no leading zeros or leading zeros are allowed + const num = Number(trimmedStr); + const numStr = "" + num; + if(numStr.search(/[eE]/) !== -1){ //given number is long and parsed to eNotation + if(options.eNotation) return num; + else return str; + }else if(eNotation){ //given number has enotation + if(options.eNotation) return num; + else return str; + }else if(trimmedStr.indexOf(".") !== -1){ //floating number + // const decimalPart = match[5].substr(1); + // const intPart = trimmedStr.substr(0,trimmedStr.indexOf(".")); + + + // const p = numStr.indexOf("."); + // const givenIntPart = numStr.substr(0,p); + // const givenDecPart = numStr.substr(p+1); + if(numStr === "0" && (numTrimmedByZeros === "") ) return num; //0.0 + else if(numStr === numTrimmedByZeros) return num; //0.456. 0.79000 + else if( sign && numStr === "-"+numTrimmedByZeros) return num; + else return str; + } + + if(leadingZeros){ + // if(numTrimmedByZeros === numStr){ + // if(options.leadingZeros) return num; + // else return str; + // }else return str; + if(numTrimmedByZeros === numStr) return num; + else if(sign+numTrimmedByZeros === numStr) return num; + else return str; + } + + if(trimmedStr === numStr) return num; + else if(trimmedStr === sign+numStr) return num; + // else{ + // //number with +/- sign + // trimmedStr.test(/[-+][0-9]); + + // } + return str; + } + // else if(!eNotation && trimmedStr && trimmedStr !== Number(trimmedStr) ) return str; + + }else{ //non-numeric string + return str; + } + } +} + +/** + * + * @param {string} numStr without leading zeros + * @returns + */ +function trimZeros(numStr){ + if(numStr && numStr.indexOf(".") !== -1){//float + numStr = numStr.replace(/0+$/, ""); //remove ending zeros + if(numStr === ".") numStr = "0"; + else if(numStr[0] === ".") numStr = "0"+numStr; + else if(numStr[numStr.length-1] === ".") numStr = numStr.substr(0,numStr.length-1); + return numStr; + } + return numStr; +} +module.exports = toNumber + + +/***/ }), + +/***/ 4927: +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + + +/** + * Module exports. + */ + +module.exports = deprecate; + +/** + * Mark that a method should not be used. + * Returns a modified function which warns once by default. + * + * If `localStorage.noDeprecation = true` is set, then it is a no-op. + * + * If `localStorage.throwDeprecation = true` is set, then deprecated functions + * will throw an Error when invoked. + * + * If `localStorage.traceDeprecation = true` is set, then deprecated functions + * will invoke `console.trace()` instead of `console.error()`. + * + * @param {Function} fn - the function to deprecate + * @param {String} msg - the string to print to the console when `fn` is invoked + * @returns {Function} a new "deprecated" version of `fn` + * @api public + */ + +function deprecate (fn, msg) { + if (config('noDeprecation')) { + return fn; + } + + var warned = false; + function deprecated() { + if (!warned) { + if (config('throwDeprecation')) { + throw new Error(msg); + } else if (config('traceDeprecation')) { + console.trace(msg); + } else { + console.warn(msg); + } + warned = true; + } + return fn.apply(this, arguments); + } + + return deprecated; +} + +/** + * Checks `localStorage` for boolean values for the given `name`. + * + * @param {String} name + * @returns {Boolean} + * @api private + */ + +function config (name) { + // accessing global.localStorage can trigger a DOMException in sandboxed iframes + try { + if (!__webpack_require__.g.localStorage) return false; + } catch (_) { + return false; + } + var val = __webpack_require__.g.localStorage[name]; + if (null == val) return false; + return String(val).toLowerCase() === 'true'; +} + + +/***/ }), + +/***/ 2043: +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +"use strict"; + + +(function(){ + + var + buf, + bufIdx = 0, + hexBytes = [], + i + ; + + // Pre-calculate toString(16) for speed + for (i = 0; i < 256; i++) { + hexBytes[i] = (i + 0x100).toString(16).substr(1); + } + + // Buffer random numbers for speed + // Reduce memory usage by decreasing this number (min 16) + // or improve speed by increasing this number (try 16384) + uuid.BUFFER_SIZE = 4096; + + // Binary uuids + uuid.bin = uuidBin; + + // Clear buffer + uuid.clearBuffer = function() { + buf = null; + bufIdx = 0; + }; + + // Test for uuid + uuid.test = function(uuid) { + if (typeof uuid === 'string') { + return /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(uuid); + } + return false; + }; + + // Node & Browser support + var crypt0; + if (typeof crypto !== 'undefined') { + crypt0 = crypto; + } else if( (typeof window !== 'undefined') && (typeof window.msCrypto !== 'undefined')) { + crypt0 = window.msCrypto; // IE11 + } + + if (true) { + crypt0 = crypt0 || __webpack_require__(9061); + module.exports = uuid; + } else {} + + // Use best available PRNG + // Also expose this so you can override it. + uuid.randomBytes = (function(){ + if (crypt0) { + if (crypt0.randomBytes) { + return crypt0.randomBytes; + } + if (crypt0.getRandomValues) { + if (typeof Uint8Array.prototype.slice !== 'function') { + return function(n) { + var bytes = new Uint8Array(n); + crypt0.getRandomValues(bytes); + return Array.from(bytes); + }; + } + return function(n) { + var bytes = new Uint8Array(n); + crypt0.getRandomValues(bytes); + return bytes; + }; + } + } + return function(n) { + var i, r = []; + for (i = 0; i < n; i++) { + r.push(Math.floor(Math.random() * 256)); + } + return r; + }; + })(); + + // Buffer some random bytes for speed + function randomBytesBuffered(n) { + if (!buf || ((bufIdx + n) > uuid.BUFFER_SIZE)) { + bufIdx = 0; + buf = uuid.randomBytes(uuid.BUFFER_SIZE); + } + return buf.slice(bufIdx, bufIdx += n); + } + + // uuid.bin + function uuidBin() { + var b = randomBytesBuffered(16); + b[6] = (b[6] & 0x0f) | 0x40; + b[8] = (b[8] & 0x3f) | 0x80; + return b; + } + + // String UUIDv4 (Random) + function uuid() { + var b = uuidBin(); + return hexBytes[b[0]] + hexBytes[b[1]] + + hexBytes[b[2]] + hexBytes[b[3]] + '-' + + hexBytes[b[4]] + hexBytes[b[5]] + '-' + + hexBytes[b[6]] + hexBytes[b[7]] + '-' + + hexBytes[b[8]] + hexBytes[b[9]] + '-' + + hexBytes[b[10]] + hexBytes[b[11]] + + hexBytes[b[12]] + hexBytes[b[13]] + + hexBytes[b[14]] + hexBytes[b[15]] + ; + } + +})(); + + +/***/ }), + +/***/ 2361: +/***/ (() => { + +/* (ignored) */ + +/***/ }), + +/***/ 4616: +/***/ (() => { + +/* (ignored) */ + +/***/ }), + +/***/ 9061: +/***/ (() => { + +/* (ignored) */ + +/***/ }) + +/******/ }); +/************************************************************************/ +/******/ // The module cache +/******/ var __webpack_module_cache__ = {}; +/******/ +/******/ // The require function +/******/ function __webpack_require__(moduleId) { +/******/ // Check if module is in cache +/******/ var cachedModule = __webpack_module_cache__[moduleId]; +/******/ if (cachedModule !== undefined) { +/******/ return cachedModule.exports; +/******/ } +/******/ // Create a new module (and put it into the cache) +/******/ var module = __webpack_module_cache__[moduleId] = { +/******/ // no module.id needed +/******/ // no module.loaded needed +/******/ exports: {} +/******/ }; +/******/ +/******/ // Execute the module function +/******/ __webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__); +/******/ +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } +/******/ +/************************************************************************/ +/******/ /* webpack/runtime/define property getters */ +/******/ (() => { +/******/ // define getter functions for harmony exports +/******/ __webpack_require__.d = (exports, definition) => { +/******/ for(var key in definition) { +/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) { +/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] }); +/******/ } +/******/ } +/******/ }; +/******/ })(); +/******/ +/******/ /* webpack/runtime/global */ +/******/ (() => { +/******/ __webpack_require__.g = (function() { +/******/ if (typeof globalThis === 'object') return globalThis; +/******/ try { +/******/ return this || new Function('return this')(); +/******/ } catch (e) { +/******/ if (typeof window === 'object') return window; +/******/ } +/******/ })(); +/******/ })(); +/******/ +/******/ /* webpack/runtime/hasOwnProperty shorthand */ +/******/ (() => { +/******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop)) +/******/ })(); +/******/ +/******/ /* webpack/runtime/make namespace object */ +/******/ (() => { +/******/ // define __esModule on exports +/******/ __webpack_require__.r = (exports) => { +/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { +/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); +/******/ } +/******/ Object.defineProperty(exports, '__esModule', { value: true }); +/******/ }; +/******/ })(); +/******/ +/************************************************************************/ +var __webpack_exports__ = {}; +// This entry need to be wrapped in an IIFE because it need to be in strict mode. +(() => { +"use strict"; + +// NAMESPACE OBJECT: ./node_modules/asn1js/build/index.es.js +var index_es_namespaceObject = {}; +__webpack_require__.r(index_es_namespaceObject); +__webpack_require__.d(index_es_namespaceObject, { + Any: () => (Any), + BaseBlock: () => (BaseBlock), + BaseStringBlock: () => (BaseStringBlock), + BitString: () => (index_es_BitString), + BmpString: () => (BmpString), + Boolean: () => (index_es_Boolean), + CharacterString: () => (CharacterString), + Choice: () => (Choice), + Constructed: () => (Constructed), + DATE: () => (DATE), + DateTime: () => (DateTime), + Duration: () => (Duration), + EndOfContent: () => (EndOfContent), + Enumerated: () => (Enumerated), + GeneralString: () => (GeneralString), + GeneralizedTime: () => (GeneralizedTime), + GraphicString: () => (GraphicString), + HexBlock: () => (HexBlock), + IA5String: () => (IA5String), + Integer: () => (Integer), + Null: () => (Null), + NumericString: () => (NumericString), + ObjectIdentifier: () => (ObjectIdentifier), + OctetString: () => (index_es_OctetString), + Primitive: () => (Primitive), + PrintableString: () => (PrintableString), + RawData: () => (RawData), + RelativeObjectIdentifier: () => (RelativeObjectIdentifier), + Repeated: () => (Repeated), + Sequence: () => (Sequence), + Set: () => (index_es_Set), + TIME: () => (TIME), + TeletexString: () => (TeletexString), + TimeOfDay: () => (TimeOfDay), + UTCTime: () => (UTCTime), + UniversalString: () => (UniversalString), + Utf8String: () => (Utf8String), + ValueBlock: () => (ValueBlock), + VideotexString: () => (VideotexString), + ViewWriter: () => (ViewWriter), + VisibleString: () => (VisibleString), + compareSchema: () => (compareSchema), + fromBER: () => (fromBER), + verifySchema: () => (verifySchema) +}); + +// EXTERNAL MODULE: ./node_modules/http-link-header/lib/link.js +var lib_link = __webpack_require__(2475); +;// CONCATENATED MODULE: ./node_modules/http-status-codes/build/es/utils.js +// Generated file. Do not edit +var statusCodeToReasonPhrase = { + "202": "Accepted", + "502": "Bad Gateway", + "400": "Bad Request", + "409": "Conflict", + "100": "Continue", + "201": "Created", + "417": "Expectation Failed", + "424": "Failed Dependency", + "403": "Forbidden", + "504": "Gateway Timeout", + "410": "Gone", + "505": "HTTP Version Not Supported", + "418": "I'm a teapot", + "419": "Insufficient Space on Resource", + "507": "Insufficient Storage", + "500": "Internal Server Error", + "411": "Length Required", + "423": "Locked", + "420": "Method Failure", + "405": "Method Not Allowed", + "301": "Moved Permanently", + "302": "Moved Temporarily", + "207": "Multi-Status", + "300": "Multiple Choices", + "511": "Network Authentication Required", + "204": "No Content", + "203": "Non Authoritative Information", + "406": "Not Acceptable", + "404": "Not Found", + "501": "Not Implemented", + "304": "Not Modified", + "200": "OK", + "206": "Partial Content", + "402": "Payment Required", + "308": "Permanent Redirect", + "412": "Precondition Failed", + "428": "Precondition Required", + "102": "Processing", + "407": "Proxy Authentication Required", + "431": "Request Header Fields Too Large", + "408": "Request Timeout", + "413": "Request Entity Too Large", + "414": "Request-URI Too Long", + "416": "Requested Range Not Satisfiable", + "205": "Reset Content", + "303": "See Other", + "503": "Service Unavailable", + "101": "Switching Protocols", + "307": "Temporary Redirect", + "429": "Too Many Requests", + "401": "Unauthorized", + "451": "Unavailable For Legal Reasons", + "422": "Unprocessable Entity", + "415": "Unsupported Media Type", + "305": "Use Proxy", + "421": "Misdirected Request" +}; +var utils_reasonPhraseToStatusCode = { + "Accepted": 202, + "Bad Gateway": 502, + "Bad Request": 400, + "Conflict": 409, + "Continue": 100, + "Created": 201, + "Expectation Failed": 417, + "Failed Dependency": 424, + "Forbidden": 403, + "Gateway Timeout": 504, + "Gone": 410, + "HTTP Version Not Supported": 505, + "I'm a teapot": 418, + "Insufficient Space on Resource": 419, + "Insufficient Storage": 507, + "Internal Server Error": 500, + "Length Required": 411, + "Locked": 423, + "Method Failure": 420, + "Method Not Allowed": 405, + "Moved Permanently": 301, + "Moved Temporarily": 302, + "Multi-Status": 207, + "Multiple Choices": 300, + "Network Authentication Required": 511, + "No Content": 204, + "Non Authoritative Information": 203, + "Not Acceptable": 406, + "Not Found": 404, + "Not Implemented": 501, + "Not Modified": 304, + "OK": 200, + "Partial Content": 206, + "Payment Required": 402, + "Permanent Redirect": 308, + "Precondition Failed": 412, + "Precondition Required": 428, + "Processing": 102, + "Proxy Authentication Required": 407, + "Request Header Fields Too Large": 431, + "Request Timeout": 408, + "Request Entity Too Large": 413, + "Request-URI Too Long": 414, + "Requested Range Not Satisfiable": 416, + "Reset Content": 205, + "See Other": 303, + "Service Unavailable": 503, + "Switching Protocols": 101, + "Temporary Redirect": 307, + "Too Many Requests": 429, + "Unauthorized": 401, + "Unavailable For Legal Reasons": 451, + "Unprocessable Entity": 422, + "Unsupported Media Type": 415, + "Use Proxy": 305, + "Misdirected Request": 421 +}; + +;// CONCATENATED MODULE: ./node_modules/http-status-codes/build/es/utils-functions.js + +/** + * Returns the reason phrase for the given status code. + * If the given status code does not exist, an error is thrown. + * + * @param {number|string} statusCode The HTTP status code + * @returns {string} The associated reason phrase (e.g. "Bad Request", "OK") + * */ +function getReasonPhrase(statusCode) { + var result = statusCodeToReasonPhrase[statusCode.toString()]; + if (!result) { + throw new Error("Status code does not exist: " + statusCode); + } + return result; +} +/** + * Returns the status code for the given reason phrase. + * If the given reason phrase does not exist, undefined is returned. + * + * @param {string} reasonPhrase The HTTP reason phrase (e.g. "Bad Request", "OK") + * @returns {string} The associated status code + * */ +function getStatusCode(reasonPhrase) { + var result = reasonPhraseToStatusCode[reasonPhrase]; + if (!result) { + throw new Error("Reason phrase does not exist: " + reasonPhrase); + } + return result; +} +/** + * @deprecated + * + * Returns the reason phrase for the given status code. + * If the given status code does not exist, undefined is returned. + * + * Deprecated in favor of getReasonPhrase + * + * @param {number|string} statusCode The HTTP status code + * @returns {string|undefined} The associated reason phrase (e.g. "Bad Request", "OK") + * */ +var getStatusText = (/* unused pure expression or super */ null && (getReasonPhrase)); + +;// CONCATENATED MODULE: ./src/utils.js + + +// Threshold size for switching to range requests +const MAX_FULL_DOWNLOAD_SIZE = 25000000; + +const PAGE_STATE_NOT_FINISHED = 0x00; +const PAGE_STATE_NEED_REMOTE_SYNC = 0x10; +const PAGE_STATE_NEED_LOCAL_SYNC = 0x01; +const PAGE_STATE_SYNCED = 0x11; + +const MAX_STREAM_CHUNK_SIZE = 65536 * 4; + +const REPLAY_TOP_FRAME_NAME = "___wb_replay_top_frame"; + +const REMOVE_EXPIRES = /Expires=\w{3},\s\d[^;,]+(?:;\s*)?/gi; + +function startsWithAny(value, iter) { + for (const str of iter) { + if (value.startsWith(str)) { + return true; + } + } + + return false; +} + +function containsAny(value, iter) { + for (const str of iter) { + if (value.indexOf(str) >= 0) { + return true; + } + } + + return false; +} + +function getTS(iso) { + return iso.replace(/[-:T]/g, "").slice(0, 14); +} + +function getTSMillis(iso) { + return iso.replace(/[-:.TZ]/g, ""); +} + +function tsToDate(ts) { + if (!ts) { + return new Date(); + } + + if (ts.length < 17) { + ts += "00000101000000000".substr(ts.length); + } + + const datestr = (ts.substring(0, 4) + "-" + + ts.substring(4, 6) + "-" + + ts.substring(6, 8) + "T" + + ts.substring(8, 10) + ":" + + ts.substring(10, 12) + ":" + + ts.substring(12, 14) + "." + + ts.substring(14) + "Z"); + + return new Date(datestr); +} + +function tsToSec(ts) { + return tsToDate(ts).getTime() / 1000; +} + +function getSecondsStr(date) { + if (!date) { + return ""; + } + + try { + return "" + parseInt(date.getTime() / 1000); + } catch (e) { + return ""; + } +} + +function base16(hashBuffer) { + const hashArray = Array.from(new Uint8Array(hashBuffer)); + return hashArray.map(b => b.toString(16).padStart(2, "0")).join(""); +} + +async function digestMessage(message, hashtype, prefix = null) { + const msgUint8 = typeof(message) === "string" ? new TextEncoder().encode(message) : message; + const hashBuffer = await crypto.subtle.digest(hashtype, msgUint8); + if (prefix === "") { + return base16(hashBuffer); + } + return (prefix || hashtype) + ":" + base16(hashBuffer); + +} + +function decodeLatin1(buf) { + let str = ""; + for (let i = 0; i < buf.length; i++) { + str += String.fromCharCode(buf[i]); + } + return str; +} + +function encodeLatin1(str) { + const buf = new Uint8Array(str.length); + for (let i = 0; i < str.length; i++) { + buf[i] = str.charCodeAt(i) & 0xFF; + } + return buf; +} + + +//from http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript +function randomId() { + return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15); +} + +function makeHeaders(headers) { + try { + return new Headers(headers); + } catch (e) { + // try to sanitize the headers, if any errors + for (let key of Object.keys(headers)) { + const value = headers[key]; + const newValue = value.replace(/[\r\n]+/g, ", "); + if (value != newValue) { + headers[key] = newValue; + } + } + return new Headers(headers); + } +} + +function parseSetCookie(setCookie, scheme) { + setCookie = setCookie.replace(REMOVE_EXPIRES, ""); + const cookies = []; + + for (const cookie of setCookie.split(",")) { + const cookieCore = cookie.split(";", 1)[0]; + // if has cookie flags + if (cookieCore !== cookie) { + const cookieRemainder = cookie.slice(cookieCore.length).toLowerCase(); + if (cookieRemainder.indexOf("httponly") > 0) { + continue; + } + if (scheme === "http" && cookieRemainder.indexOf("secure") > 0) { + continue; + } + } + + cookies.push(cookieCore); + } + + return cookies.join(";"); +} + +const NULL_STATUS = [101, 204, 205, 304]; + +function isNullBodyStatus(status) { + return NULL_STATUS.includes(status); +} + +function utils_getStatusText(status) { + try { + return getReasonPhrase(status); + } catch (e) { + return "Unknown Status"; + } +} + +function isAjaxRequest(request) { + if (request.headers.get("X-Pywb-Requested-With") === "XMLHttpRequest") { + return true; + } + + if (request.mode === "cors") { + // if 'mod' is esm_, then likely a module import + if (request.destination === "script" && request.mod === "esm_") { + return false; + } + return true; + } + + return false; +} + +async function handleAuthNeeded(e, config) { + if (e instanceof AuthNeededError) { + //const client = await self.clients.get(event.clientId || event.resultingClientId); + const clients = await self.clients.matchAll({ "type": "window" }); + for (const client of clients) { + const url = new URL(client.url); + if (url.searchParams.get("source") === config.sourceUrl) { + client.postMessage({ + source: config.sourceUrl, + coll: config.dbname.slice(3), + type: "authneeded", + fileHandle: e.info && e.info.fileHandle, + }); + } + } + return true; + } + + return false; +} + + +function notFound(request, msg, status = 404) { + let content; + let contentType; + + if (!msg) { + msg = "Sorry, this url was not found in the archive."; + } + + if (request.destination === "script" || request.headers.get("x-pywb-requested-with")) { + content = JSON.stringify(msg); + contentType = "application/json"; + } else { + content = msg; + contentType = "text/html"; + } + + //console.log(`Not Found ${request.destination} - ${msg}`); + + const initOpt = { + "status": status, + "statusText": utils_getStatusText(status), + "headers": { "Content-Type": contentType } + }; + + return new Response(content, initOpt); +} + + +function getCollData(coll) { + const metadata = coll.config.metadata ? coll.config.metadata : {}; + + const res = { + "title": metadata.title || "", + "desc": metadata.desc || "", + "size": metadata.size || 0, + "filename": coll.config.sourceName, + "loadUrl": coll.config.loadUrl, + "sourceUrl": coll.config.sourceUrl, + "id": coll.name, + "ctime": coll.config.ctime, + "mtime": metadata.mtime || coll.config.ctime, + "onDemand": coll.config.onDemand, + }; + + if (metadata.ipfsPins) { + res.ipfsPins = metadata.ipfsPins; + } + + return res; +} + + +// =========================================================================== +class utils_RangeError +{ + constructor(info = {}) { + this.info = info; + } + + toString() { + return JSON.stringify(this.info); + } +} + +class AuthNeededError extends utils_RangeError +{ +} + +class AccessDeniedError extends utils_RangeError +{ +} + +class Canceled +{ +} + +function sleep(millis) { + return new Promise((resolve) => setTimeout(resolve, millis)); +} + + +// EXTERNAL MODULE: ./node_modules/brotli/decompress.js +var decompress = __webpack_require__(7709); +// EXTERNAL MODULE: ./node_modules/pako/lib/inflate.js +var inflate = __webpack_require__(8843); +// EXTERNAL MODULE: ./node_modules/pako/index.js +var pako = __webpack_require__(9591); +// EXTERNAL MODULE: ./node_modules/uuid-random/index.js +var uuid_random = __webpack_require__(2043); +;// CONCATENATED MODULE: ./node_modules/warcio/dist/index.js +function G(i){let s;typeof i=="string"?s=i:i&&i.length?s=i.reduce((e,t)=>(e+=String.fromCharCode(t),e),""):i?s=i.toString():s="";try{return"__wb_post_data="+btoa(s)}catch{return"__wb_post_data="}}function Z(i){return i.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}function P(i){try{if(!i.startsWith("https:")&&!i.startsWith("http:"))return i;i=i.replace(/^(https?:\/\/)www\d*\./,"$1");let s=i.toLowerCase(),e=new URL(s),r=e.hostname.split(".").reverse().join(",");if(e.port&&(r+=":"+e.port),r+=")",r+=e.pathname,e.search){e.searchParams.sort(),r+=e.search;for(let[n,a]of e.searchParams.entries())if(!a){let o=new RegExp(`(?<=[&?])${Z(n)}=(?=&|$)`);o.exec(s)||(r=r.replace(o,n))}}return r}catch{return i}}function L(i){let{method:s,headers:e,postData:t}=i;if(s==="GET")return!1;let r=(e.get("content-type")||"").split(";")[0];function n(o){return o instanceof Uint8Array&&(o=new TextDecoder().decode(o)),o}let a="";switch(r){case"application/x-www-form-urlencoded":a=n(t);break;case"application/json":a=H(n(t));break;case"text/plain":try{a=H(n(t),!1)}catch{a=G(t)}break;case"multipart/form-data":{let o=e.get("content-type");if(!o)throw new Error("utils cannot call postToGetURL when missing content-type header");a=q(n(t),o);break}default:a=G(t)}return a!==null?(i.url=F(i.url,a,i.method),i.method="GET",i.requestBody=a,!0):!1}function F(i,s,e){if(!e)return i;let t=i.indexOf("?")>0?"&":"?";return`${i}${t}__wb_method=${e}&${s}`}function E(i,s=!0){if(typeof i=="string")try{i=JSON.parse(i)}catch{i={}}let e=new URLSearchParams,t={},r=n=>e.has(n)?(n in t||(t[n]=1),n+"."+ ++t[n]+"_"):n;try{JSON.stringify(i,(n,a)=>(["object","function"].includes(typeof a)||e.set(r(n),a),a))}catch(n){if(!s)throw n}return e}function B(i,s){let e=new URLSearchParams;i instanceof Uint8Array&&(i=new TextDecoder().decode(i));try{let t=s.split("boundary=")[1],r=i.split(new RegExp("-*"+t+"-*","mi"));for(let n of r){let a=n.trim().match(/name="([^"]+)"\r\n\r\n(.*)/im);a&&e.set(a[1],a[2])}}catch{}return e}function H(i,s=!0){return E(i,s).toString()}function q(i,s){return B(i,s).toString()}function y(i,s){if(i.length===1)return i[0];let e=new Uint8Array(s),t=0;for(let r of i)e.set(r,t),t+=r.byteLength;return e}function R(i,s){return[i.slice(0,s),i.slice(s)]}var X=new TextDecoder("utf-8"),b=class extends pako.Inflate{constructor(e,t){super(e);this.ended=!1;this.chunks=[];this.reader=t}onEnd(e){this.err=e,this.err||(this.reader._rawOffset+=this.strm.total_in)}},h=class{static async readFully(s){let e=[],t=0;for await(let r of s)e.push(r),t+=r.byteLength;return y(e,t)}getReadableStream(){let s=this[Symbol.asyncIterator]();return new ReadableStream({pull(e){return s.next().then(t=>{t.done||!t.value?e.close():e.enqueue(t.value)})}})}async readFully(){return await h.readFully(this)}async readline(s=0){let e=await this.readlineRaw(s);return e?X.decode(e):""}async*iterLines(s=0){let e=null;for(;e=await this.readline(s);)yield e}};function te(i){return i&&Symbol.iterator in Object(i)}function re(i){return i&&Symbol.asyncIterator in Object(i)}var c=class extends h{constructor(e,t="gzip",r=!1){super();this.compressed=t,this.opts={raw:t==="deflateRaw"},this.inflator=t?new b(this.opts,this):null;let n;if(re(e))n=e;else if(typeof e=="object"&&"read"in e&&typeof e.read=="function")n=c.fromReadable(e);else if(e instanceof ReadableStream)n=c.fromReadable(e.getReader());else if(te(e))n=c.fromIter(e);else throw new TypeError("Invalid Stream Source");r?this._sourceIter=this.dechunk(n):this._sourceIter=n[Symbol.asyncIterator](),this.lastValue=null,this.errored=!1,this._savedChunk=null,this._rawOffset=0,this._readOffset=0,this.numChunks=0}async _loadNext(){let e=await this._sourceIter.next();return e.done?null:e.value}async*dechunk(e){let t=e instanceof c?e:new c(e,null),r=-1,n=!0;for(;r!=0;){let a=await t.readlineRaw(64),o=new Uint8Array;if(r=a?parseInt(X.decode(a),16):0,!r||r>2**32){if(Number.isNaN(r)||r>2**32){n||(this.errored=!0),yield a;break}}else if(o=await t.readSize(r),o.length!=r){n?yield a:this.errored=!0,yield o;break}let l=await t.readSize(2);if(l[0]!=13||l[1]!=10){n?yield a:this.errored=!0,yield o,yield l;break}else{if(n=!1,!o||r===0)return;yield o}}yield*t}unread(e){!e.length||(this._readOffset-=e.length,this._savedChunk&&console.log("Already have chunk!"),this._savedChunk=e)}async _next(){if(this._savedChunk){let t=this._savedChunk;return this._savedChunk=null,t}if(this.compressed){let t=this._getNextChunk();if(t)return t}let e=await this._loadNext();for(;this.compressed&&e;){this._push(e);let t=this._getNextChunk(e);if(t)return t;e=await this._loadNext()}return e}_push(e){if(!this.inflator)throw new Error("AsyncIterReader cannot call _push when this.compressed is null");this.lastValue=e,this.inflator.ended&&(this.inflator=new b(this.opts,this)),this.inflator.push(e),this.inflator.err&&this.inflator.ended&&this.compressed==="deflate"&&this.opts.raw===!1&&this.numChunks===0&&(this.opts.raw=!0,this.compressed="deflateRaw",this.inflator=new b(this.opts,this),this.inflator.push(e))}_getNextChunk(e){if(!this.inflator)throw new Error("AsyncIterReader cannot call _getNextChunk when this.compressed is null");for(;;){if(this.inflator.chunks.length>0)return this.numChunks++,this.inflator.chunks.shift();if(this.inflator.ended){if(this.inflator.err!==0)return this.compressed=null,e;let t=this.inflator.strm.avail_in;if(t&&this.lastValue){this._push(this.lastValue.slice(-t));continue}}return null}}async*[Symbol.asyncIterator](){let e=null;for(;e=await this._next();)this._readOffset+=e.length,yield e}async readlineRaw(e){let t=[],r=0,n=-1,a=null;for await(let o of this){if(e&&r+o.byteLength>e){a=o,n=e-r-1;let l=o.slice(0,n+1).indexOf(10);l>=0&&(n=l);break}if(n=o.indexOf(10),n>=0){a=o;break}t.push(o),r+=o.byteLength}if(a){let[o,l]=R(a,n+1);t.push(o),r+=o.byteLength,this.unread(l)}else if(!t.length)return null;return y(t,r)}async readFully(){return(await this._readOrSkip())[1]}async readSize(e){return(await this._readOrSkip(e))[1]}async skipSize(e){return(await this._readOrSkip(e,!0))[0]}async _readOrSkip(e=-1,t=!1){let r=[],n=0;for await(let a of this){if(e>=0)if(a.length>e){let[o,l]=R(a,e);t||r.push(o),n+=o.byteLength,this.unread(l);break}else if(a.length===e){t||r.push(a),n+=a.byteLength,e=0;break}else e-=a.length;t||r.push(a),n+=a.byteLength}return t?[n,new Uint8Array]:[n,y(r,n)]}getReadOffset(){return this._readOffset}getRawOffset(){return this.compressed?this._rawOffset:this._readOffset}getRawLength(e){return this.compressed?this.inflator.strm.total_in:this._readOffset-e}static fromReadable(e){return{async*[Symbol.asyncIterator](){let r=null;for(;(r=await e.read())&&!r.done;)yield r.value}}}static fromIter(e){return{async*[Symbol.asyncIterator](){for(let r of e)yield r}}}},m=class extends h{constructor(e,t,r=0){super();this.sourceIter=e,this.length=t,this.limit=t,this.skip=r}setLimitSkip(e,t=0){this.limit=e,this.skip=t}async*[Symbol.asyncIterator](){if(!(this.limit<=0))for await(let e of this.sourceIter){if(this.skip>0)if(e.length>=this.skip){let[,t]=R(e,this.skip);e=t,this.skip=0}else{this.skip-=e.length;continue}if(e.length>this.limit){let[t,r]=R(e,this.limit);e=t,this.sourceIter.unread&&this.sourceIter.unread(r)}if(e.length&&(this.limit-=e.length,yield e),this.limit<=0)break}}async readlineRaw(e){if(this.limit<=0)return null;let t=await this.sourceIter.readlineRaw(e?Math.min(e,this.limit):this.limit);return this.limit-=t?.length||0,t}async skipFully(){let e=this.limit;for(;this.limit>0;)this.limit-=await this.sourceIter.skipSize(this.limit);return e}};var z=new Uint8Array([13,10]),J=new Uint8Array([13,10,13,10]),se=new TextDecoder("utf-8"),_=class{constructor({statusline:s,headers:e}){this.statusline=s,this.headers=e}toString(){let s=[this.statusline];for(let[e,t]of this.headers)s.push(`${e}: ${t}`);return s.join(`\r +`)+`\r +`}async*iterSerialize(s){yield s.encode(this.statusline),yield z;for(let[e,t]of this.headers)yield s.encode(`${e}: ${t}\r +`)}_parseResponseStatusLine(){let s=ne(this.statusline," ",2);this._protocol=s[0]??"",this._statusCode=s.length>1?Number(s[1]):"",this._statusText=s.length>2?s[2]:""}get statusCode(){return this._statusCode===void 0&&this._parseResponseStatusLine(),this._statusCode}get protocol(){return this._protocol===void 0&&this._parseResponseStatusLine(),this._protocol}get statusText(){return this._statusText===void 0&&this._parseResponseStatusLine(),this._statusText}_parseRequestStatusLine(){let s=this.statusline.split(" ",2);this._method=s[0]??"",this._requestPath=s.length>1?s[1]:""}get method(){return this._method===void 0&&this._parseRequestStatusLine(),this._method}get requestPath(){return this._requestPath===void 0&&this._parseRequestStatusLine(),this._requestPath}},k=class{async parse(s,{headersClass:e,firstLine:t}={headersClass:Map}){let r=t||await s.readline();if(!r)return null;let n=r.trimEnd();if(!n)return null;let a=new e,o=await ae(s),l=0,d,f,p,T="",u;for(;l=0&&d0&&r.push(t.slice(e).join(s)),r}async function ie(i,s){let e=0;for(let t=0;t=i.length){let{value:n}=await s.next();if(!n)break;let a=new Uint8Array(n.length+i.length);a.set(i,0),a.set(n,i.length),i=a}if(i[r+1]===10&&i[r+2]===13&&i[r+3]===10)return[r+3,i];e=r+1}return[-1,i]}async function ae(i){let s=[],e=0,t=0,r=null,n=i[Symbol.asyncIterator]();for await(let a of n){if([t,a]=await ie(a,n),t>=0){r=a;break}s.push(a),e+=a.byteLength}if(r){let[a,o]=R(r,t+1);s.push(a),e+=a.byteLength,i.unread(o)}else if(!s.length)return"";return se.decode(y(s,e))}var le=new TextDecoder("utf-8"),de=new TextEncoder,N="WARC/1.1",v="WARC/1.0",ce="http://netpreserve.org/warc/1.0/revisit/identical-payload-digest",ue="http://netpreserve.org/warc/1.1/revisit/identical-payload-digest",he={warcinfo:"application/warc-fields",response:"application/http; msgtype=response",revisit:"application/http; msgtype=response",request:"application/http; msgtype=request",metadata:"application/warc-fields"},g=class extends h{constructor({warcHeaders:e,reader:t}){super();this._offset=0;this._length=0;this.method="";this.requestBody="";this._urlkey="";this.warcHeaders=e,this._reader=t,this._contentReader=null,this.payload=null,this.httpHeaders=null,this.consumed="",this.fixUp()}static create({url:e,date:t,type:r,warcHeaders:n={},filename:a="",httpHeaders:o={},statusline:l="HTTP/1.1 200 OK",warcVersion:d=v,keepHeadersCase:f=!0,refersToUrl:p=void 0,refersToDate:T=void 0}={},u){function U(x){let Y=x;return d===v&&(x=x.split(".")[0],x.charAt(Y.length-1)!="Z"&&(x+="Z")),x}t=U(t||new Date().toISOString()),n={...n},r==="warcinfo"?a&&(n["WARC-Filename"]=a):n["WARC-Target-URI"]=e,n["WARC-Date"]=t,n["WARC-Type"]=r,r==="revisit"&&(n["WARC-Profile"]=d===N?ue:ce,n["WARC-Refers-To-Target-URI"]=p,n["WARC-Refers-To-Date"]=U(T||new Date().toISOString())),n=new _({statusline:d,headers:f?new Map(Object.entries(n)):new Headers(n)}),n.headers.get("WARC-Record-ID")||n.headers.set("WARC-Record-ID",``),n.headers.get("Content-Type")||n.headers.set("Content-Type",r&&he[r]||"application/octet-stream"),u||(u=async function*(){}());let M=new g({warcHeaders:n,reader:u}),Q=null,D=[];switch(r){case"response":case"request":case"revisit":D=Object.entries(o),Q=f?new Map(D):new Headers(o),(D.length>0||r!=="revisit")&&(M.httpHeaders=new _({statusline:l,headers:Q}));break}return M}static createWARCInfo(e={},t){async function*r(){for(let[n,a]of Object.entries(t))yield de.encode(`${n}: ${a}\r +`)}return e.type="warcinfo",g.create(e,r())}getResponseInfo(){let e=this.httpHeaders;return e?{headers:e.headers,status:e.statusCode,statusText:e.statusText}:null}fixUp(){let e=this.warcHeaders.headers.get("WARC-Target-URI");e&&e.startsWith("<")&&e.endsWith(">")&&this.warcHeaders.headers.set("WARC-Target-URI",e.slice(1,-1))}async readFully(e=!1){if(this.httpHeaders){if(this.payload&&!this.payload.length)return this.payload;if(this._contentReader&&!e)throw new TypeError("WARC Record decoding already started, but requesting raw payload");if(e&&this.consumed==="raw"&&this.payload)return await this._createDecodingReader([this.payload]).readFully()}return this.payload?this.payload:(e?(this.payload=await super.readFully(),this.consumed="content"):(this.payload=await g.readFully(this._reader),this.consumed="raw"),this.payload)}get reader(){if(this._contentReader)throw new TypeError("WARC Record decoding already started, but requesting raw payload");return this._reader}get contentReader(){return this.httpHeaders?(this._contentReader||(this._contentReader=this._createDecodingReader(this._reader)),this._contentReader):this._reader}_createDecodingReader(e){if(!this.httpHeaders)throw new Error("WARCRecord cannot call _createDecodingReader when this.httpHeaders === null");let t=this.httpHeaders.headers.get("Content-Encoding"),r=this.httpHeaders.headers.get("Transfer-Encoding"),n=r==="chunked";return!t&&!n&&(t=r),new c(e,t,n)}async readlineRaw(e){if(this.consumed)throw new Error("Record already consumed.. Perhaps a promise was not awaited?");if(this.contentReader instanceof h)return this.contentReader.readlineRaw(e);throw new Error("WARCRecord cannot call readlineRaw on this.contentReader if it does not extend BaseAsyncIterReader")}async contentText(){let e=await this.readFully(!0);return le.decode(e)}async*[Symbol.asyncIterator](){for await(let e of this.contentReader)if(yield e,this.consumed)throw new Error("Record already consumed.. Perhaps a promise was not awaited?");this.consumed="content"}async skipFully(){if(!this.consumed){if(this._reader instanceof m){let e=await this._reader.skipFully();return this.consumed="skipped",e}throw new Error("WARCRecord cannot call skipFully on this._reader if it is not a LimitReader")}}warcHeader(e){return this.warcHeaders.headers.get(e)}get warcType(){return this.warcHeaders.headers.get("WARC-Type")}get warcTargetURI(){return this.warcHeaders.headers.get("WARC-Target-URI")}get warcDate(){return this.warcHeaders.headers.get("WARC-Date")}get warcRefersToTargetURI(){return this.warcHeaders.headers.get("WARC-Refers-To-Target-URI")}get warcRefersToDate(){return this.warcHeaders.headers.get("WARC-Refers-To-Date")}get warcPayloadDigest(){return this.warcHeaders.headers.get("WARC-Payload-Digest")}get warcBlockDigest(){return this.warcHeaders.headers.get("WARC-Block-Digest")}get warcContentType(){return this.warcHeaders.headers.get("Content-Type")}get warcContentLength(){return Number(this.warcHeaders.headers.get("Content-Length"))}};var V=new TextDecoder,dist_$=new Uint8Array([]),w=class{static parse(s,e){return new w(s,e).parse()}static iterRecords(s,e){return new w(s,e)[Symbol.asyncIterator]()}constructor(s,{keepHeadersCase:e=!1,parseHttp:t=!0}={}){this._offset=0,this._warcHeadersLength=0,this._headersClass=e?Map:Headers,this._parseHttp=t,s instanceof c?this._reader=s:this._reader=new c(s),this._record=null}async readToNextRecord(){if(!this._reader||!this._record)return dist_$;await this._record.skipFully(),this._reader.compressed&&(this._offset=this._reader.getRawOffset());let s=await this._reader.readlineRaw(),e=0;if(!s)s=dist_$;else{if(e=s.byteLength-1,e===9&&V.decode(s).startsWith("WARC/"))return s;for(;e>0;){let t=s[e-1];if(t!==10&&t!==13)break;e--}e&&console.warn(`Content-Length Too Small: Record not followed by newline, Remainder Length: ${e}, Offset: ${this._reader.getRawOffset()-s.byteLength}`)}if(this._reader.compressed)await this._reader.skipSize(2),s=dist_$;else{for(s=await this._reader.readlineRaw();s&&s.byteLength===2;)s=await this._reader.readlineRaw();this._offset=this._reader.getRawOffset(),s&&(this._offset-=s.length)}return s}_initRecordReader(s){return new m(this._reader,Number(s.headers.get("Content-Length")||0))}async parse(){let s=await this.readToNextRecord(),e=s?V.decode(s):"",t=new k,r=await t.parse(this._reader,{firstLine:e,headersClass:this._headersClass});if(!r)return null;this._warcHeadersLength=this._reader.getReadOffset();let n=new g({warcHeaders:r,reader:this._initRecordReader(r)});if(this._record=n,this._parseHttp)switch(n.warcType){case"response":case"request":await this._addHttpHeaders(n,t);break;case"revisit":n.warcContentLength>0&&await this._addHttpHeaders(n,t);break}return n}get offset(){return this._offset}get recordLength(){return this._reader.getRawLength(this._offset)}async*[Symbol.asyncIterator](){let s=null;for(;(s=await this.parse())!==null;)yield s;this._record=null}async _addHttpHeaders(s,e){let t=await e.parse(this._reader,{headersClass:this._headersClass});s.httpHeaders=t;let r=this._reader.getReadOffset()-this._warcHeadersLength;s.reader instanceof m&&s.reader.setLimitSkip(s.warcContentLength-r)}};var K=new TextEncoder,S=class extends (/* unused pure expression or super */ null && (h)){constructor(e,t={}){super();this.gzip=!1;this.digestAlgo="";this.digestAlgoPrefix="";this.digestBase32=!1;this.record=e,this.gzip=Boolean(t.gzip);let r=t&&t.digest||{};e.warcType!=="revisit"&&e.warcType!=="warcinfo"&&(!e.warcPayloadDigest||!e.warcBlockDigest)?(this.digestAlgo=r?.algo||"sha-256",this.digestAlgoPrefix=r?.prefix||"sha256:",this.digestBase32=Boolean(r?.base32)):this.digestAlgo=""}static async serialize(e,t){return await new S(e,t).readFully()}static base16(e){return Array.from(new Uint8Array(e)).map(r=>r.toString(16).padStart(2,"0")).join("")}async*[Symbol.asyncIterator](){if(!this.gzip){yield*this.generateRecord();return}let e=null;"CompressionStream"in globalThis?(e=new globalThis.CompressionStream("gzip"),yield*this.streamCompress(e)):yield*this.pakoCompress()}async readlineRaw(e){return null}async*pakoCompress(){let e=new pe.Deflate({gzip:!0}),t=null;for await(let r of this.generateRecord())for(t&&t.length>0&&e.push(t),t=r;e.chunks.length;)yield e.chunks.shift();t&&e.push(t,!0),yield e.result}async*streamCompress(e){let t=this.generateRecord();new ReadableStream({async pull(o){let l=await t.next();l.done?o.close():o.enqueue(l.value)}}).pipeThrough(e);let n=null,a=e.readable.getReader();for(;(n=await a.read())&&!n.done;)yield n.value}async digestMessage(e){let t=await crypto.subtle.digest(this.digestAlgo,e);return this.digestAlgoPrefix+(this.digestBase32?fe(t,"RFC4648"):S.base16(t))}async*generateRecord(){let e=0,t=null;this.record.httpHeaders&&(t=K.encode(this.record.httpHeaders.toString()+`\r +`),e+=t.length);let r=await this.record.readFully();if(e+=r.length,this.digestAlgo){let a=await this.digestMessage(r),o=t?await this.digestMessage(y([t,r],e)):a;this.record.warcHeaders.headers.set("WARC-Payload-Digest",a),this.record.warcHeaders.headers.set("WARC-Block-Digest",o)}this.record.warcHeaders.headers.set("Content-Length",e.toString()),yield K.encode(this.record.warcHeaders.toString()),yield z,t&&(yield t),yield r,yield J}};var ye=["offset","warc-type","warc-target-uri"],j=class{constructor(s={}){this.opts=s,this.fields=s&&s.fields?s.fields.split(","):ye,this.parseHttp=!1}serialize(s){return JSON.stringify(s)+` +`}write(s,e){e.write(this.serialize(s))}async writeAll(s,e){for await(let t of this.iterIndex(s))this.write(t,e)}async*iterIndex(s){let e={strictHeaders:!0,parseHttp:this.parseHttp};for(let{filename:t,reader:r}of s){let n=new w(r,e);yield*this.iterRecords(n,t)}}async*iterRecords(s,e){for await(let t of s){await t.skipFully();let r=this.indexRecord(t,s,e);r&&(yield r)}}indexRecord(s,e,t){if(this.filterRecord&&!this.filterRecord(s))return null;let r={},n=e.offset,a=e.recordLength,o={offset:n,length:a,filename:t};for(let l of this.fields)l in o?r[l]=o[l]:this.setField(l,s,r);return r}setField(s,e,t){let r=this.getField(s,e);r!==null&&(t[s]=r)}getField(s,e){return s==="http:status"?e.httpHeaders&&(e.warcType==="response"||e.warcType==="revisit")?e.httpHeaders.statusCode:null:s.startsWith("http:")?e.httpHeaders?e.httpHeaders.headers.get(s.slice(5)):null:e.warcHeaders.headers.get(s)||null}},I=class extends j{constructor(s){super(s);for(let e of this.fields)if(e.startsWith("http:")){this.parseHttp=!0;break}}},ge="urlkey,timestamp,url,mime,status,digest,length,offset,filename".split(","),Re="urlkey,timestamp,url,mime,status,digest,redirect,meta,length,offset,filename".split(","),W=class extends I{constructor(e){super(e);switch(this.includeAll=Boolean(e?.all),this.overrideIndexForAll=Boolean(e?.all),this.fields=ge,this.parseHttp=!0,this.noSurt=Boolean(e?.noSurt),this._lastRecord=null,e?.format){case"cdxj":this.serialize=this.serializeCDXJ;break;case"cdx":this.serialize=this.serializeCDX11;break;case"json":default:break}}async*iterRecords(e,t){this._lastRecord=null;for await(let n of e){await n.readFully();let a=this.indexRecord(n,e,t);a&&(yield a)}let r=this.indexRecord(null,e,t);r&&(yield r)}filterRecord(e){if(this.includeAll)return!0;let t=e.warcType;return!(t==="request"||t==="warcinfo"||(t==="metadata"||t==="resource")&&e.warcContentType==="application/warc-fields")}indexRecord(e,t,r){if(this.overrideIndexForAll)return e?super.indexRecord(e,t,r):null;let n=this._lastRecord;if(this._lastRecord=e,e&&(e._offset=t.offset,e._length=t.recordLength),!n)return null;if(!e||n.warcTargetURI!=e.warcTargetURI)return this.indexRecordPair(n,null,t,r);let a=e.warcType,o=n.warcType;return a==="request"&&(o==="response"||o==="revisit")?(this._lastRecord=null,this.indexRecordPair(n,e,t,r)):(a==="response"||a==="revisit")&&o==="request"?(this._lastRecord=null,this.indexRecordPair(e,n,t,r)):this.indexRecordPair(n,null,t,r)}indexRecordPair(e,t,r,n){let a,o,l=e.warcTargetURI||"";if(t&&t.httpHeaders&&t.httpHeaders.method!=="GET"){let f={url:l,method:t.httpHeaders.method,headers:t.httpHeaders.headers,postData:t.payload};a=f.method,L(f)&&(o=f.requestBody,e.method=a,e.requestBody=o,l=f.url)}e._urlkey=l;let d=super.indexRecord(e,r,n);return d&&(e&&e._offset!==void 0&&(d.offset=e._offset,d.length=e._length),a&&(d.method=a),o&&(d.requestBody=o)),d}serializeCDXJ(e){let{urlkey:t,timestamp:r}=e;return delete e.urlkey,delete e.timestamp,`${t} ${r} ${JSON.stringify(e)} +`}serializeCDX11(e){let t=[];for(let r of Re)t.push(e[r]!=null?e[r]:"-");return t.join(" ")+` +`}getField(e,t){let r=null;switch(e){case"urlkey":return r=t._urlkey||t.warcTargetURI||null,this.noSurt||r===null?r:P(r);case"timestamp":return r=t.warcDate??"",r.replace(/[-:T]/g,"").slice(0,14);case"url":return t.warcTargetURI;case"mime":switch(t.warcType){case"revisit":return"warc/revisit";case"response":case"request":e="http:content-type";break;default:e="content-type"}return r=super.getField(e,t),r?r.toString().split(";",1)[0]?.trim():null;case"status":return super.getField("http:status",t);case"digest":return r=t.warcPayloadDigest,r?r.split(":",2)[1]:null;default:return null}}},O=class extends (/* unused pure expression or super */ null && (W)){constructor(s){super(s),this.overrideIndexForAll=!1}indexRecordPair(s,e,t,r){let n=super.indexRecordPair(s,e,t,r);return n&&{cdx:n,record:s,reqRecord:e}}}; + +;// CONCATENATED MODULE: ./src/rewrite/decoder.js + + + + + + + +// =========================================================================== +async function decodeResponse(response, contentEncoding, transferEncoding, noRW) { + + // use the streaming decoder if gzip only and no rewriting + if (response.reader && noRW && + ((contentEncoding === "gzip" && !transferEncoding) || + (!contentEncoding && transferEncoding === "gzip"))) { + response.setReader(new c(response.reader)); + return response; + } + + const origContent = new Uint8Array(await response.getBuffer()); + + const content = await decodeContent(origContent, contentEncoding, transferEncoding); + + if (origContent !== content) { + response.setBuffer(content); + } + + return response; +} + + +// =========================================================================== +async function decodeContent(content, contentEncoding, transferEncoding) { + const origContent = content; + + try { + if (transferEncoding === "chunked") { + content = dechunkArrayBuffer(content); + } + } catch (e) { + console.log("Chunk-Encoding Ignored: " + e); + } + + try { + if (contentEncoding === "br") { + content = decompress(content); + + // if ended up with zero-length, probably not valid, just use original + if (content.length === 0) { + content = origContent; + } + + } else if (contentEncoding === "gzip" || transferEncoding === "gzip") { + const inflator = new inflate.Inflate(); + + inflator.push(content, true); + + // if error occurs (eg. not gzip), use original arraybuffer + if (inflator.result && !inflator.err) { + content = inflator.result; + } + } + } catch(e) { + console.log("Content-Encoding Ignored: " + e); + } + + return content; +} + + +// =========================================================================== +function dechunkArrayBuffer(data) { + let readOffset = 0; + let writeOffset = 0; + + const decoder = new TextDecoder("utf-8"); + + while (readOffset < data.length) { + let i = readOffset; + + // check hex digits, 0-9, A-Z, a-z + while ((data[i] >= 48 && data[i] <= 57) || + (data[i] >= 65 && data[i] <= 70) || + (data[i] >= 97 && data[i] <= 102)) { + i++; + } + + // doesn't start with number, return original + if (i === 0) { + return data; + } + + // ensure \r\n\r\n + if (data[i] != 13 || data[i + 1] != 10) { + return data; + } + + i += 2; + + var chunkLength = parseInt(decoder.decode(data.subarray(readOffset, i)), 16); + + if (chunkLength == 0) { + break; + } + + data.set(data.subarray(i, i + chunkLength), writeOffset); + + i += chunkLength; + + writeOffset += chunkLength; + + if (data[i] == 13 && data[i + 1] == 10) { + i += 2; + } + + readOffset = i; + } + + return data.subarray(0, writeOffset); +} + + + + + +;// CONCATENATED MODULE: ./src/response.js + + + +const encoder = new TextEncoder(); +const decoder = new TextDecoder(); + + +// =========================================================================== +class ArchiveResponse +{ + + static fromResponse({url, response, date, noRW, isLive}) { + const payload = response.body ? new c(response.body.getReader(), false) : null; + const status = Number(response.headers.get("x-redirect-status") || response.status); + const statusText = response.headers.get("x-redirect-statusText") || response.statusText; + + let headers = new Headers(response.headers); + + let origLoc = headers.get("x-orig-location"); + if (origLoc) { + if (origLoc.startsWith(self.location.origin)) { + origLoc = origLoc.slice(self.location.origin.length); + } + headers.set("location", origLoc); + headers.delete("x-orig-location"); + headers.delete("x-redirect-status"); + headers.delete("x-redirect-statusText"); + } + + let updateTS = null; + + const origTs = headers.get("x-orig-ts"); + if (origTs) { + date = tsToDate(origTs); + headers.delete("x-orig-ts"); + + // force TS update downstream + if (origTs && origLoc) { + updateTS = origTs; + } + } + const mementoDt = headers.get("memento-datetime"); + if (mementoDt) { + date = new Date(mementoDt); + } + + const cookie = (headers.get("x-proxy-set-cookie")); + if (cookie) { + const cookies = []; + cookie.split(",").forEach((c) => { + const cval = c.split(";", 1)[0].trim(); + if (cval.indexOf("=") > 0) { + cookies.push(cval); + } + }); + headers.delete("x-proxy-set-cookie"); + + if (cookies.length) { + headers.set("x-wabac-preset-cookie", cookies.join(";")); + //console.log("cookies", cookies.join(";")); + } + } + + return new ArchiveResponse({payload, status, statusText, headers, url, date, noRW, isLive, updateTS}); + } + + constructor({payload, status, statusText, headers, url, date, extraOpts = null, noRW = false, isLive = false, updateTS = null}) { + this.reader = null; + this.buffer = null; + + if (payload && (payload[Symbol.asyncIterator] || payload instanceof h)) { + this.reader = payload; + } else { + this.buffer = payload; + } + + this.status = status; + this.statusText = statusText; + this.headers = headers; + this.url = url; + this.date = date; + this.extraOpts = extraOpts; + this.noRW = noRW; + this.isLive = isLive; + this.updateTS = updateTS; + } + + async getText(isUTF8 = false) { + const buff = await this.getBuffer(); + if (typeof(buff) === "string") { + return buff; + } + + return isUTF8 ? decoder.decode(buff) : decodeLatin1(buff); + } + + setText(text, isUTF8 = false) { + this.setBuffer(isUTF8 ? encoder.encode(text) : encodeLatin1(text)); + } + + async getBuffer() { + if (this.buffer) { + return this.buffer; + } + + this.buffer = await this.reader.readFully(); + return this.buffer; + } + + setBuffer(buffer) { + this.buffer = buffer; + this.reader = null; + } + + setReader(reader) { + if (reader instanceof h) { + this.reader = reader; + this.buffer = null; + } else if (reader.getReader) { + this.reader = new c(reader.getReader()); + this.buffer = null; + } + } + + expectedLength() { + if (this.buffer) { + return this.buffer.length; + } else if (this.reader && this.reader.reader) { + return this.reader.reader.length; + } + } + + createIter() { + const buffer = this.buffer; + const reader = this.reader; + + async function* iter() { + if (buffer) { + for (let i = 0; i < buffer.length; i += MAX_STREAM_CHUNK_SIZE) { + yield buffer.slice(i, i + MAX_STREAM_CHUNK_SIZE); + } + + } else if (reader) { + yield* reader; + } + } + + return iter(); + } + + async* [Symbol.asyncIterator]() { + yield* this.createIter(); + } + + setRange(range) { + if (this.status === 206) { + const currRange = this.headers.get("Content-Range"); + if (currRange && !currRange.startsWith("bytes 0-")) { + return false; + } + } + + const bytes = range.match(/^bytes=(\d+)-(\d+)?$/); + + let length = 0; + + if (this.buffer) { + length = this.buffer.length; + } else if (this.reader) { + //length = this.reader.length; + length = Number(this.headers.get("content-length")); + + // if length is not known, keep as 200 + if (!length) { + return false; + } + } + + if (!bytes) { + this.status = 416; + this.statusText = "Range Not Satisfiable"; + this.headers.set("Content-Range", `*/${length}`); + return false; + } + + const start = Number(bytes[1]); + const end = Number(bytes[2]) || (length - 1); + + if (this.buffer) { + this.buffer = this.buffer.slice(start, end + 1); + + } else if (this.reader) { + if (!this.reader.setLimitSkip) { + return false; + } + if (start !== 0 || end !== (length - 1)) { + this.reader.setLimitSkip(end - start + 1, start); + } else if (this.reader.setRangeAll) { + this.reader.setRangeAll(length); + } + } + + this.headers.set("Content-Range", `bytes ${start}-${end}/${length}`); + this.headers.set("Content-Length", end - start + 1); + + this.status = 206; + this.statusText = "Partial Content"; + + return true; + } + + makeResponse(coHeaders = false) { + let body = null; + if (!isNullBodyStatus(this.status)) { + body = this.buffer || !this.reader ? this.buffer : this.reader.getReadableStream(); + } + + const response = new Response(body, {status: this.status, + statusText: this.statusText, + headers: this.headers}); + response.date = this.date; + if (coHeaders) { + response.headers.set("Cross-Origin-Opener-Policy", "same-origin"); + response.headers.set("Cross-Origin-Embedder-Policy", "require-corp"); + } + return response; + } +} + + + + + +// EXTERNAL MODULE: ./node_modules/fast-xml-parser/src/parser.js +var parser = __webpack_require__(6965); +;// CONCATENATED MODULE: ./src/rewrite/rewriteVideo.js + + +// orig pywb defaults +const OLD_DEFAULT_MAX_BAND = 2000000; +const OLD_DEFAULT_MAX_RES = 1280 * 720; + +// lower defaults +const DEFAULT_MAX_BAND = 1000000; +const DEFAULT_MAX_RES = 860 * 480; + + +// =========================================================================== +function getMaxResAndBand(opts = {}) { + // read opts from warc, if any + let maxRes, maxBand; + + const extraOpts = (opts && opts.response && opts.response.extraOpts); + + if (extraOpts) { + maxRes = extraOpts.adaptive_max_resolution || extraOpts.maxRes; + maxBand = extraOpts.adaptive_max_bandwidth || extraOpts.maxBand; + if (maxRes && maxBand) { + return {maxRes, maxBand}; + } + } + + const isReplay = opts && opts.response && !opts.response.isLive; + let res; + + // if not replay, or unknown, use new lower setting + if (!isReplay) { + res = {maxRes: DEFAULT_MAX_RES, maxBand: DEFAULT_MAX_BAND}; + } else { + // use existing pywb defaults + res = {maxRes: OLD_DEFAULT_MAX_RES, maxBand: OLD_DEFAULT_MAX_BAND}; + } + + if (opts && opts.save) { + opts.save.maxRes = res.maxRes; + opts.save.maxBand = res.maxBand; + } + + return res; +} + + +// =========================================================================== +//HLS +function rewriteHLS(text, opts) { + const EXT_INF = /#EXT-X-STREAM-INF:(?:.*[,])?BANDWIDTH=([\d]+)/; + const EXT_RESOLUTION = /RESOLUTION=([\d]+)x([\d]+)/; + + const { maxRes, maxBand} = getMaxResAndBand(opts); + + let indexes = []; + let count = 0; + let bestIndex = null; + + let bestBand = 0; + let bestRes = 0; + + let lines = text.trimEnd().split("\n"); + + for (const line of lines) { + const m = line.match(EXT_INF); + if (!m) { + // if has rewriteUrl (not-ajax), then rewrite HLS urls + if (opts && opts.rewriteUrl && !line.startsWith("#")) { + lines[count] = opts.rewriteUrl(line); + } + count += 1; + continue; + } + + indexes.push(count); + + const currBand = Number(m[1]); + + const m2 = line.match(EXT_RESOLUTION); + const currRes = m2 ? Number(m2[1]) * Number(m2[2]) : 0; + + if (currRes && maxRes) { + if (currRes <= maxRes && currRes > bestRes) { + bestRes = currRes; + bestBand = currBand; + bestIndex = count; + } + } else if (currBand <= maxBand && currBand > bestBand) { + bestRes = currRes; + bestBand = currBand; + bestIndex = count; + } + + count += 1; + } + + indexes.reverse(); + + for (const inx of indexes) { + if (inx !== bestIndex) { + lines.splice(inx, 2); + } + } + + return lines.join("\n"); +} + +// =========================================================================== +// DASH +const dashOutputOpts = {ignoreAttributes: false, ignoreNameSpace: false, format: false, supressEmptyNode: true}; + + +function rewriteDASH(text, opts, bestIds) { + try { + return _rewriteDASH(text, opts, bestIds); + } catch (e) { + console.log(e); + return text; + } +} + + +function _rewriteDASH(text, opts, bestIds) { + const options = dashOutputOpts; + const root = parser.parse(text, options); + + const { maxRes, maxBand} = getMaxResAndBand(opts); + + let best = null; + let bestRes = 0; + let bestBand = 0; + + let adaptSets = null; + + if (!Array.isArray(root.MPD.Period.AdaptationSet)) { + adaptSets = [root.MPD.Period.AdaptationSet]; + } else { + adaptSets = root.MPD.Period.AdaptationSet; + } + + for (const adaptset of adaptSets) { + best = null; + bestRes = 0; + bestBand = 0; + + let reps = null; + + if (!Array.isArray(adaptset.Representation)) { + reps = [adaptset.Representation]; + } else { + reps = adaptset.Representation; + } + + for (const repres of reps) { + const currRes = Number(repres["@_width"] || "0") * Number(repres["@_height"] || "0"); + const currBand = Number(repres["@_bandwidth"] || "0"); + + if (currRes && maxRes) { + if (currRes <= maxRes && currRes > bestRes) { + bestRes = currRes; + bestBand = currBand; + best = repres; + } + } else if (currBand <= maxBand && currBand > bestBand) { + bestRes = currRes; + bestBand = currBand; + best = repres; + } + } + + if (best && Array.isArray(bestIds)) { + bestIds.push(best["@_id"]); + } + + if (best) { + adaptset.Representation = [best]; + } + } + + const toXML = new parser.j2xParser(options); + const xml = toXML.parse(root); + + return "\n" + xml.trim(); +} + + +// =========================================================================== + + + +;// CONCATENATED MODULE: ./src/rewrite/dsruleset.js +//import unescapeJs from "unescape-js"; +const MAX_BITRATE = 5000000; + +// =========================================================================== +const DEFAULT_RULES = [ + { + contains: ["youtube.com", "youtube-nocookie.com"], + rxRules: [ + [/ytplayer.load\(\);/, ruleReplace("ytplayer.config.args.dash = \"0\"; ytplayer.config.args.dashmpd = \"\"; {0}")], + [/yt\.setConfig.*PLAYER_CONFIG.*args":\s*{/, ruleReplace("{0} \"dash\": \"0\", dashmpd: \"\", ")], + [/(?:"player":|ytplayer\.config).*"args":\s*{/, ruleReplace("{0}\"dash\":\"0\",\"dashmpd\":\"\",")], + [/yt\.setConfig.*PLAYER_VARS.*?{/, ruleReplace("{0}\"dash\":\"0\",\"dashmpd\":\"\",")], + [/ytplayer.config={args:\s*{/, ruleReplace("{0}\"dash\":\"0\",\"dashmpd\":\"\",")], + [/"0"\s*?==\s*?\w+\.dash&&/m, ruleReplace("1&&")], + ] + }, + { + contains: ["player.vimeo.com/video/"], + rxRules: [ + [/.+/, ruleRewriteVimeoConfig] + ] + }, + { + contains: ["master.json?query_string_ranges=0", "master.json?base64"], + rxRules: [ + [/.+/, ruleRewriteVimeoDashManifest] + ] + }, + { + contains: ["facebook.com/"], + rxRules: [ + //[/"dash_manifest":"?.*dash_prefetched_representation_ids"?:(\[.*\]|[^,]+)/, ruleRewriteFBDash], + //[/"dash_manifest":"?.*?dash_prefetched_representation_ids"?:(?:null|(?:.+?\]))/, ruleRewriteFBDash], + + [/"dash_/, ruleReplace("\"__nodash__")], + [/_dash"/, ruleReplace("__nodash__\"")], + [/_dash_/, ruleReplace("__nodash__")], + [/"debugNoBatching\s?":(?:false|0)/, ruleReplace("\"debugNoBatching\":true")] + ] + }, + + { + contains: ["instagram.com/"], + rxRules: [ + [/"is_dash_eligible":(?:true|1)/, ruleReplace("\"is_dash_eligible\":false")], + [/"debugNoBatching\s?":(?:false|0)/, ruleReplace("\"debugNoBatching\":true")] + ] + }, + + { + contains: ["api.twitter.com/2/", "twitter.com/i/api/2/", "twitter.com/i/api/graphql/"], + rxRules: [ + [/"video_info":.*?}]}/, ruleRewriteTwitterVideo("\"video_info\":")] + ] + }, + + { + contains: ["cdn.syndication.twimg.com/tweet-result"], + rxRules: [ + [/"video":.*?viewCount":\d+}/, ruleRewriteTwitterVideo("\"video\":")] + ] + }, + + { + contains: ["/vqlweb.js"], + rxRules: [ + [/\b\w+\.updatePortSize\(\);this\.updateApplicationSize\(\)(?![*])/img, ruleReplace("/*{0}*/")] + ] + } +]; + +// =========================================================================== +function ruleReplace(string) { + return x => string.replace("{0}", x); +} + +// =========================================================================== +function setMaxBitrate(opts) +{ + let maxBitrate = MAX_BITRATE; + const extraOpts = opts.response && opts.response.extraOpts; + + if (opts.save) { + opts.save.maxBitrate = maxBitrate; + } else if (extraOpts && extraOpts.maxBitrate) { + maxBitrate = extraOpts.maxBitrate; + } + + return maxBitrate; +} + +// =========================================================================== +function ruleRewriteTwitterVideo(prefix) { + + return (string, opts) => { + if (!opts) { + return string; + } + + const origString = string; + + try { + const W_X_H = /([\d]+)x([\d]+)/; + + const maxBitrate = setMaxBitrate(opts); + + string = string.slice(prefix.length); + + const data = JSON.parse(string); + + let bestVariant = null; + let bestBitrate = 0; + + for (const variant of data.variants) { + if ((variant.content_type && variant.content_type !== "video/mp4") || + (variant.type && variant.type !== "video/mp4")) { + continue; + } + + if (variant.bitrate && variant.bitrate > bestBitrate && variant.bitrate <= maxBitrate) { + bestVariant = variant; + bestBitrate = variant.bitrate; + } else if (variant.src) { + const matched = W_X_H.exec(variant.src); + if (matched) { + const bitrate = Number(matched[1]) * Number(matched[2]); + if (bitrate > bestBitrate) { + bestBitrate = bitrate; + bestVariant = variant; + } + } + } + } + + if (bestVariant) { + data.variants = [bestVariant]; + } + + return prefix + JSON.stringify(data); + + } catch (e) { + console.warn("rewriter error: ", e); + return origString; + } + }; +} + +// =========================================================================== +function ruleRewriteVimeoConfig(string) { + let config; + try { + config = JSON.parse(string); + } catch (e) { + return string; + } + + if (config && config.request && config.request.files) { + const files = config.request.files; + if (typeof(files.progressive) === "object" && files.progressive.length) { + if (files.dash) { + files.__dash = files.dash; + delete files.dash; + } + if (files.hls) { + files.__hls = files.hls; + delete files.hls; + } + return JSON.stringify(config); + } + } + + return string.replace(/query_string_ranges=1/g, "query_string_ranges=0"); +} + +// =========================================================================== +function ruleRewriteVimeoDashManifest(string, opts) { + if (!opts) { + return string; + } + + let vimeoManifest = null; + + const maxBitrate = setMaxBitrate(opts); + + try { + vimeoManifest = JSON.parse(string); + console.log("manifest", vimeoManifest); + } catch (e) { + return string; + } + + function filterByBitrate(array, max, mime) { + let bestVariant = 0; + let bestBitrate = null; + + for (const variant of array) { + if (variant.mime_type == mime && variant.bitrate > bestBitrate && variant.bitrate <= max) { + bestBitrate = variant.bitrate; + bestVariant = variant; + } + } + + return bestVariant ? [bestVariant] : array; + } + + vimeoManifest.video = filterByBitrate(vimeoManifest.video, maxBitrate, "video/mp4"); + vimeoManifest.audio = filterByBitrate(vimeoManifest.audio, maxBitrate, "audio/mp4"); + + return JSON.stringify(vimeoManifest); +} + +// =========================================================================== + +// =========================================================================== +class DomainSpecificRuleSet +{ + + constructor(RewriterCls, rwRules) { + this.rwRules = rwRules || DEFAULT_RULES; + this.RewriterCls = RewriterCls; + + this._initRules(); + } + + _initRules() { + this.rewriters = new Map(); + + for (const rule of this.rwRules) { + if (rule.rxRules) { + this.rewriters.set(rule, new this.RewriterCls(rule.rxRules)); + } + } + this.defaultRewriter = new this.RewriterCls(); + } + + getRewriter(url) { + for (const rule of this.rwRules) { + if (!rule.contains) { + continue; + } + + for (const containsStr of rule.contains) { + if (url.indexOf(containsStr) >= 0) { + const rewriter = this.rewriters.get(rule); + if (rewriter) { + return rewriter; + } + } + } + } + + return this.defaultRewriter; + } +} + + + + +;// CONCATENATED MODULE: ./src/rewrite/rxrewriter.js + +// =========================================================================== +class RxRewriter +{ + constructor(rules) { + this.rules = rules || null; + if (this.rules) { + this.compileRules(); + } else { + this.rx = null; + } + } + + compileRules() { + let rxBuff = ""; + + for (let rule of this.rules) { + if (rxBuff) { + rxBuff += "|"; + } + rxBuff += `(${rule[0].source})`; + } + + const rxString = `(?:${rxBuff})`; + + this.rx = new RegExp(rxString, "gm"); + } + + doReplace(params, opts) { + const offset = params[params.length - 2]; + const string = params[params.length - 1]; + + for (let i = 0; i < this.rules.length; i++) { + const curr = params[i]; + if (!curr) { + continue; + } + + const result = this.rules[i][1].call(this, curr, opts, offset, string); + if (result) { + return result; + } + } + } + + rewrite(text, opts) { + if (!this.rx) { + return text; + } + + return text.replace(this.rx, (match, ...params) => this.doReplace(params, opts)); + } +} + + + + +;// CONCATENATED MODULE: ./src/rewrite/jsrewriter.js + + +const IMPORT_RX = /^\s*?import\s*?[{"'*]/; +const EXPORT_RX = /^\s*?export\s*?({([\s\w,$\n]+?)}[\s;]*|default|class)\s+/m; + +const IMPORT_MATCH_RX = /^\s*?import(?:['"\s]*(?:[\w*${}\s,]+from\s*)?['"\s]?['"\s])(?:.*?)['"\s]/; + +const IMPORT_HTTP_RX = /(import(?:['"\s]*(?:[\w*${}\s,]+from\s*)?['"\s]?['"\s]))((?:https?|[./]).*?)(['"\s])/; + + +const GLOBAL_OVERRIDES = [ + "window", + "globalThis", + "self", + "document", + "location", + "top", + "parent", + "frames", + "opener" +]; + +const GLOBALS_CONCAT_STR = GLOBAL_OVERRIDES.map((x) => `(?:^|[^$.])\\b${x}\\b(?:$|[^$])`).join("|"); + +const GLOBALS_RX = new RegExp(`(${GLOBALS_CONCAT_STR})`); + +// =========================================================================== +const createJSRules = () => { + + const thisRw = "_____WB$wombat$check$this$function_____(this)"; + + const checkLoc = "((self.__WB_check_loc && self.__WB_check_loc(location, arguments)) || {}).href = "; + + const evalStr = "WB_wombat_runEval2((_______eval_arg, isGlobal) => { var ge = eval; return isGlobal ? ge(_______eval_arg) : eval(_______eval_arg); }).eval(this, (function() { return arguments })(),"; + + function addPrefix(prefix) { + return x => prefix + x; + } + + function replacePrefixFrom(prefix, match) { + return (x) => { + const start = x.indexOf(match); + if (start === 0) { + return prefix; + } else { + return x.slice(0, start) + prefix; + } + }; + } + + function addSuffix(suffix) { + return (x, _opts, offset, string) => { + if (offset > 0) { + const prev = string[offset - 1]; + if (prev === "." || prev === "$") { + return x; + } + } + return x + suffix; + }; + } + + function replaceThis() { + return x => x.replace("this", thisRw); + } + + function replace(src, target) { + return x => x.replace(src, target); + } + + function replaceThisProp() { + return (x, _opts, offset, string) => { + const prev = (offset > 0 ? string[offset - 1] : ""); + if (prev === "\n") { + return x.replace("this", ";" + thisRw); + } else if (prev !== "." && prev !== "$") { + return x.replace("this", thisRw); + } else { + return x; + } + }; + } + + function replaceImport(src, target) { + return (x, opts) => { + let res = x.replace(src, target); + // if not module, add empty string, otherwise, import.meta.url + res += (opts.isModule ? "import.meta.url, " : "\"\", "); + return res; + }; + } + + return [ + // rewriting 'eval(...)' - invocation + [/(?:^|\s)\beval\s*\(/, replacePrefixFrom(evalStr, "eval")], + + // rewriting 'x = eval' - no invocation + [/[=]\s*\beval\b(?![(:.$])/, replace("eval", "self.eval")], + + // rewriting .postMessage -> __WB_pmw(self).postMessage + [/\.postMessage\b\(/, addPrefix(".__WB_pmw(self)")], + + // rewriting 'location = ' to custom expression '(...).href =' assignment + [/[^$.]?\s?\blocation\b\s*[=]\s*(?![\s=])/, addSuffix(checkLoc)], + + // rewriting 'return this' + [/\breturn\s+this\b\s*(?![\s\w.$])/, replaceThis()], + + // rewriting 'this.' special properties access on new line, with ; prepended + // if prev char is '\n', or if prev is not '.' or '$', no semi + [new RegExp(`[^$.]\\s?\\bthis\\b(?=(?:\\.(?:${GLOBAL_OVERRIDES.join("|")})\\b))`), replaceThisProp()], + + // rewrite '= this' or ', this' + [/[=,]\s*\bthis\b\s*(?![\s\w:.$])/, replaceThis()], + + // rewrite '})(this)' + [/\}(?:\s*\))?\s*\(this\)/, replaceThis()], + + // rewrite this in && or || expr? + [/[^|&][|&]{2}\s*this\b\s*(?![|\s&.$](?:[^|&]|$))/, replaceThis()], + + // esm dynamic import, if found, mark as module + [/[^$.]\bimport\s*\(/, replaceImport("import", "____wb_rewrite_import__")] + ]; +}; + +// =========================================================================== +const jsrewriter_DEFAULT_RULES = createJSRules(); + + +// =========================================================================== +class JSRewriter extends RxRewriter { + constructor(extraRules) { + super(); + this.extraRules = extraRules; + + this.firstBuff = this.initLocalDecl(GLOBAL_OVERRIDES); + this.lastBuff = "\n\n}"; + } + + initLocalDecl(localDecls) { + const assignFunc = "_____WB$wombat$assign$function_____"; + + let buffer = `\ +var ${assignFunc} = function(name) {return (self._wb_wombat && self._wb_wombat.local_init && self._wb_wombat.local_init(name)) || self[name]; }; +if (!self.__WB_pmw) { self.__WB_pmw = function(obj) { this.__WB_source = obj; return this; } } +{ +`; + + for (let decl of localDecls) { + buffer += `let ${decl} = ${assignFunc}("${decl}");\n`; + } + buffer += "let arguments;\n"; + + return buffer + "\n"; + } + + getModuleDecl(localDecls, prefix) { + return `import { ${localDecls.join(", ")} } from "${prefix}__wb_module_decl.js";\n`; + } + + detectIsModule(text) { + if (text.indexOf("import") >= 0 && text.match(IMPORT_RX)) { + return true; + } + + if (text.indexOf("export") >= 0 && text.match(EXPORT_RX)) { + return true; + } + + return false; + } + + rewrite(text, opts) { + opts = opts || {}; + if (opts.isModule === undefined || opts.isModule === null) { + opts.isModule = this.detectIsModule(text, opts); + } + + let rules = jsrewriter_DEFAULT_RULES; + + if (opts.isModule) { + rules = [...rules, this.getESMImportRule()]; + } + + if (this.extraRules && this.extraRules.length) { + this.rules = [...rules, ...this.extraRules]; + } else { + this.rules = rules; + } + + this.compileRules(); + + let newText = super.rewrite(text, opts); + + if (opts.isModule) { + return this.getModuleDecl(GLOBAL_OVERRIDES, opts.prefix) + newText; + } + + const wrapGlobals = GLOBALS_RX.exec(text); + + if (wrapGlobals) { + newText = this.firstBuff + newText + this.lastBuff; + } + + if (opts && opts.inline) { + newText = newText.replace(/\n/g, " ") ; + } + + return newText; + } + + getESMImportRule() { + // mark as module side-effect + rewrite if http[s] url + function rewriteImport() { + return (x, opts) => { + const prefix = opts.prefix.replace("mp_/", "esm_/"); + + return x.replace(IMPORT_HTTP_RX, (_, g1, g2, g3) => { + try { + g2 = new URL(g2, opts.baseUrl).href; + g2 = prefix + g2; + } catch (e) { + // ignore, keep same url + } + return g1 + g2 + g3; + }); + }; + } + + // match and rewrite import statements + return [IMPORT_MATCH_RX, rewriteImport()]; + } +} + + + +;// CONCATENATED MODULE: ./node_modules/parse5/dist/common/unicode.js +const UNDEFINED_CODE_POINTS = new Set([ + 65534, 65535, 131070, 131071, 196606, 196607, 262142, 262143, 327678, 327679, 393214, + 393215, 458750, 458751, 524286, 524287, 589822, 589823, 655358, 655359, 720894, + 720895, 786430, 786431, 851966, 851967, 917502, 917503, 983038, 983039, 1048574, + 1048575, 1114110, 1114111, +]); +const REPLACEMENT_CHARACTER = '\uFFFD'; +var CODE_POINTS; +(function (CODE_POINTS) { + CODE_POINTS[CODE_POINTS["EOF"] = -1] = "EOF"; + CODE_POINTS[CODE_POINTS["NULL"] = 0] = "NULL"; + CODE_POINTS[CODE_POINTS["TABULATION"] = 9] = "TABULATION"; + CODE_POINTS[CODE_POINTS["CARRIAGE_RETURN"] = 13] = "CARRIAGE_RETURN"; + CODE_POINTS[CODE_POINTS["LINE_FEED"] = 10] = "LINE_FEED"; + CODE_POINTS[CODE_POINTS["FORM_FEED"] = 12] = "FORM_FEED"; + CODE_POINTS[CODE_POINTS["SPACE"] = 32] = "SPACE"; + CODE_POINTS[CODE_POINTS["EXCLAMATION_MARK"] = 33] = "EXCLAMATION_MARK"; + CODE_POINTS[CODE_POINTS["QUOTATION_MARK"] = 34] = "QUOTATION_MARK"; + CODE_POINTS[CODE_POINTS["NUMBER_SIGN"] = 35] = "NUMBER_SIGN"; + CODE_POINTS[CODE_POINTS["AMPERSAND"] = 38] = "AMPERSAND"; + CODE_POINTS[CODE_POINTS["APOSTROPHE"] = 39] = "APOSTROPHE"; + CODE_POINTS[CODE_POINTS["HYPHEN_MINUS"] = 45] = "HYPHEN_MINUS"; + CODE_POINTS[CODE_POINTS["SOLIDUS"] = 47] = "SOLIDUS"; + CODE_POINTS[CODE_POINTS["DIGIT_0"] = 48] = "DIGIT_0"; + CODE_POINTS[CODE_POINTS["DIGIT_9"] = 57] = "DIGIT_9"; + CODE_POINTS[CODE_POINTS["SEMICOLON"] = 59] = "SEMICOLON"; + CODE_POINTS[CODE_POINTS["LESS_THAN_SIGN"] = 60] = "LESS_THAN_SIGN"; + CODE_POINTS[CODE_POINTS["EQUALS_SIGN"] = 61] = "EQUALS_SIGN"; + CODE_POINTS[CODE_POINTS["GREATER_THAN_SIGN"] = 62] = "GREATER_THAN_SIGN"; + CODE_POINTS[CODE_POINTS["QUESTION_MARK"] = 63] = "QUESTION_MARK"; + CODE_POINTS[CODE_POINTS["LATIN_CAPITAL_A"] = 65] = "LATIN_CAPITAL_A"; + CODE_POINTS[CODE_POINTS["LATIN_CAPITAL_F"] = 70] = "LATIN_CAPITAL_F"; + CODE_POINTS[CODE_POINTS["LATIN_CAPITAL_X"] = 88] = "LATIN_CAPITAL_X"; + CODE_POINTS[CODE_POINTS["LATIN_CAPITAL_Z"] = 90] = "LATIN_CAPITAL_Z"; + CODE_POINTS[CODE_POINTS["RIGHT_SQUARE_BRACKET"] = 93] = "RIGHT_SQUARE_BRACKET"; + CODE_POINTS[CODE_POINTS["GRAVE_ACCENT"] = 96] = "GRAVE_ACCENT"; + CODE_POINTS[CODE_POINTS["LATIN_SMALL_A"] = 97] = "LATIN_SMALL_A"; + CODE_POINTS[CODE_POINTS["LATIN_SMALL_F"] = 102] = "LATIN_SMALL_F"; + CODE_POINTS[CODE_POINTS["LATIN_SMALL_X"] = 120] = "LATIN_SMALL_X"; + CODE_POINTS[CODE_POINTS["LATIN_SMALL_Z"] = 122] = "LATIN_SMALL_Z"; + CODE_POINTS[CODE_POINTS["REPLACEMENT_CHARACTER"] = 65533] = "REPLACEMENT_CHARACTER"; +})(CODE_POINTS = CODE_POINTS || (CODE_POINTS = {})); +const SEQUENCES = { + DASH_DASH: '--', + CDATA_START: '[CDATA[', + DOCTYPE: 'doctype', + SCRIPT: 'script', + PUBLIC: 'public', + SYSTEM: 'system', +}; +//Surrogates +function isSurrogate(cp) { + return cp >= 55296 && cp <= 57343; +} +function isSurrogatePair(cp) { + return cp >= 56320 && cp <= 57343; +} +function getSurrogatePairCodePoint(cp1, cp2) { + return (cp1 - 55296) * 1024 + 9216 + cp2; +} +//NOTE: excluding NULL and ASCII whitespace +function isControlCodePoint(cp) { + return ((cp !== 0x20 && cp !== 0x0a && cp !== 0x0d && cp !== 0x09 && cp !== 0x0c && cp >= 0x01 && cp <= 0x1f) || + (cp >= 0x7f && cp <= 0x9f)); +} +function isUndefinedCodePoint(cp) { + return (cp >= 64976 && cp <= 65007) || UNDEFINED_CODE_POINTS.has(cp); +} +//# sourceMappingURL=unicode.js.map +;// CONCATENATED MODULE: ./node_modules/parse5/dist/common/error-codes.js +var error_codes_ERR; +(function (ERR) { + ERR["controlCharacterInInputStream"] = "control-character-in-input-stream"; + ERR["noncharacterInInputStream"] = "noncharacter-in-input-stream"; + ERR["surrogateInInputStream"] = "surrogate-in-input-stream"; + ERR["nonVoidHtmlElementStartTagWithTrailingSolidus"] = "non-void-html-element-start-tag-with-trailing-solidus"; + ERR["endTagWithAttributes"] = "end-tag-with-attributes"; + ERR["endTagWithTrailingSolidus"] = "end-tag-with-trailing-solidus"; + ERR["unexpectedSolidusInTag"] = "unexpected-solidus-in-tag"; + ERR["unexpectedNullCharacter"] = "unexpected-null-character"; + ERR["unexpectedQuestionMarkInsteadOfTagName"] = "unexpected-question-mark-instead-of-tag-name"; + ERR["invalidFirstCharacterOfTagName"] = "invalid-first-character-of-tag-name"; + ERR["unexpectedEqualsSignBeforeAttributeName"] = "unexpected-equals-sign-before-attribute-name"; + ERR["missingEndTagName"] = "missing-end-tag-name"; + ERR["unexpectedCharacterInAttributeName"] = "unexpected-character-in-attribute-name"; + ERR["unknownNamedCharacterReference"] = "unknown-named-character-reference"; + ERR["missingSemicolonAfterCharacterReference"] = "missing-semicolon-after-character-reference"; + ERR["unexpectedCharacterAfterDoctypeSystemIdentifier"] = "unexpected-character-after-doctype-system-identifier"; + ERR["unexpectedCharacterInUnquotedAttributeValue"] = "unexpected-character-in-unquoted-attribute-value"; + ERR["eofBeforeTagName"] = "eof-before-tag-name"; + ERR["eofInTag"] = "eof-in-tag"; + ERR["missingAttributeValue"] = "missing-attribute-value"; + ERR["missingWhitespaceBetweenAttributes"] = "missing-whitespace-between-attributes"; + ERR["missingWhitespaceAfterDoctypePublicKeyword"] = "missing-whitespace-after-doctype-public-keyword"; + ERR["missingWhitespaceBetweenDoctypePublicAndSystemIdentifiers"] = "missing-whitespace-between-doctype-public-and-system-identifiers"; + ERR["missingWhitespaceAfterDoctypeSystemKeyword"] = "missing-whitespace-after-doctype-system-keyword"; + ERR["missingQuoteBeforeDoctypePublicIdentifier"] = "missing-quote-before-doctype-public-identifier"; + ERR["missingQuoteBeforeDoctypeSystemIdentifier"] = "missing-quote-before-doctype-system-identifier"; + ERR["missingDoctypePublicIdentifier"] = "missing-doctype-public-identifier"; + ERR["missingDoctypeSystemIdentifier"] = "missing-doctype-system-identifier"; + ERR["abruptDoctypePublicIdentifier"] = "abrupt-doctype-public-identifier"; + ERR["abruptDoctypeSystemIdentifier"] = "abrupt-doctype-system-identifier"; + ERR["cdataInHtmlContent"] = "cdata-in-html-content"; + ERR["incorrectlyOpenedComment"] = "incorrectly-opened-comment"; + ERR["eofInScriptHtmlCommentLikeText"] = "eof-in-script-html-comment-like-text"; + ERR["eofInDoctype"] = "eof-in-doctype"; + ERR["nestedComment"] = "nested-comment"; + ERR["abruptClosingOfEmptyComment"] = "abrupt-closing-of-empty-comment"; + ERR["eofInComment"] = "eof-in-comment"; + ERR["incorrectlyClosedComment"] = "incorrectly-closed-comment"; + ERR["eofInCdata"] = "eof-in-cdata"; + ERR["absenceOfDigitsInNumericCharacterReference"] = "absence-of-digits-in-numeric-character-reference"; + ERR["nullCharacterReference"] = "null-character-reference"; + ERR["surrogateCharacterReference"] = "surrogate-character-reference"; + ERR["characterReferenceOutsideUnicodeRange"] = "character-reference-outside-unicode-range"; + ERR["controlCharacterReference"] = "control-character-reference"; + ERR["noncharacterCharacterReference"] = "noncharacter-character-reference"; + ERR["missingWhitespaceBeforeDoctypeName"] = "missing-whitespace-before-doctype-name"; + ERR["missingDoctypeName"] = "missing-doctype-name"; + ERR["invalidCharacterSequenceAfterDoctypeName"] = "invalid-character-sequence-after-doctype-name"; + ERR["duplicateAttribute"] = "duplicate-attribute"; + ERR["nonConformingDoctype"] = "non-conforming-doctype"; + ERR["missingDoctype"] = "missing-doctype"; + ERR["misplacedDoctype"] = "misplaced-doctype"; + ERR["endTagWithoutMatchingOpenElement"] = "end-tag-without-matching-open-element"; + ERR["closingOfElementWithOpenChildElements"] = "closing-of-element-with-open-child-elements"; + ERR["disallowedContentInNoscriptInHead"] = "disallowed-content-in-noscript-in-head"; + ERR["openElementsLeftAfterEof"] = "open-elements-left-after-eof"; + ERR["abandonedHeadElementChild"] = "abandoned-head-element-child"; + ERR["misplacedStartTagForHeadElement"] = "misplaced-start-tag-for-head-element"; + ERR["nestedNoscriptInHead"] = "nested-noscript-in-head"; + ERR["eofInElementThatCanContainOnlyText"] = "eof-in-element-that-can-contain-only-text"; +})(error_codes_ERR = error_codes_ERR || (error_codes_ERR = {})); +//# sourceMappingURL=error-codes.js.map +;// CONCATENATED MODULE: ./node_modules/parse5/dist/tokenizer/preprocessor.js + + +//Const +const DEFAULT_BUFFER_WATERLINE = 1 << 16; +//Preprocessor +//NOTE: HTML input preprocessing +//(see: http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#preprocessing-the-input-stream) +class Preprocessor { + constructor(handler) { + this.handler = handler; + this.html = ''; + this.pos = -1; + // NOTE: Initial `lastGapPos` is -2, to ensure `col` on initialisation is 0 + this.lastGapPos = -2; + this.gapStack = []; + this.skipNextNewLine = false; + this.lastChunkWritten = false; + this.endOfChunkHit = false; + this.bufferWaterline = DEFAULT_BUFFER_WATERLINE; + this.isEol = false; + this.lineStartPos = 0; + this.droppedBufferSize = 0; + this.line = 1; + //NOTE: avoid reporting errors twice on advance/retreat + this.lastErrOffset = -1; + } + /** The column on the current line. If we just saw a gap (eg. a surrogate pair), return the index before. */ + get col() { + return this.pos - this.lineStartPos + Number(this.lastGapPos !== this.pos); + } + get offset() { + return this.droppedBufferSize + this.pos; + } + getError(code) { + const { line, col, offset } = this; + return { + code, + startLine: line, + endLine: line, + startCol: col, + endCol: col, + startOffset: offset, + endOffset: offset, + }; + } + _err(code) { + if (this.handler.onParseError && this.lastErrOffset !== this.offset) { + this.lastErrOffset = this.offset; + this.handler.onParseError(this.getError(code)); + } + } + _addGap() { + this.gapStack.push(this.lastGapPos); + this.lastGapPos = this.pos; + } + _processSurrogate(cp) { + //NOTE: try to peek a surrogate pair + if (this.pos !== this.html.length - 1) { + const nextCp = this.html.charCodeAt(this.pos + 1); + if (isSurrogatePair(nextCp)) { + //NOTE: we have a surrogate pair. Peek pair character and recalculate code point. + this.pos++; + //NOTE: add a gap that should be avoided during retreat + this._addGap(); + return getSurrogatePairCodePoint(cp, nextCp); + } + } + //NOTE: we are at the end of a chunk, therefore we can't infer the surrogate pair yet. + else if (!this.lastChunkWritten) { + this.endOfChunkHit = true; + return CODE_POINTS.EOF; + } + //NOTE: isolated surrogate + this._err(error_codes_ERR.surrogateInInputStream); + return cp; + } + willDropParsedChunk() { + return this.pos > this.bufferWaterline; + } + dropParsedChunk() { + if (this.willDropParsedChunk()) { + this.html = this.html.substring(this.pos); + this.lineStartPos -= this.pos; + this.droppedBufferSize += this.pos; + this.pos = 0; + this.lastGapPos = -2; + this.gapStack.length = 0; + } + } + write(chunk, isLastChunk) { + if (this.html.length > 0) { + this.html += chunk; + } + else { + this.html = chunk; + } + this.endOfChunkHit = false; + this.lastChunkWritten = isLastChunk; + } + insertHtmlAtCurrentPos(chunk) { + this.html = this.html.substring(0, this.pos + 1) + chunk + this.html.substring(this.pos + 1); + this.endOfChunkHit = false; + } + startsWith(pattern, caseSensitive) { + // Check if our buffer has enough characters + if (this.pos + pattern.length > this.html.length) { + this.endOfChunkHit = !this.lastChunkWritten; + return false; + } + if (caseSensitive) { + return this.html.startsWith(pattern, this.pos); + } + for (let i = 0; i < pattern.length; i++) { + const cp = this.html.charCodeAt(this.pos + i) | 0x20; + if (cp !== pattern.charCodeAt(i)) { + return false; + } + } + return true; + } + peek(offset) { + const pos = this.pos + offset; + if (pos >= this.html.length) { + this.endOfChunkHit = !this.lastChunkWritten; + return CODE_POINTS.EOF; + } + const code = this.html.charCodeAt(pos); + return code === CODE_POINTS.CARRIAGE_RETURN ? CODE_POINTS.LINE_FEED : code; + } + advance() { + this.pos++; + //NOTE: LF should be in the last column of the line + if (this.isEol) { + this.isEol = false; + this.line++; + this.lineStartPos = this.pos; + } + if (this.pos >= this.html.length) { + this.endOfChunkHit = !this.lastChunkWritten; + return CODE_POINTS.EOF; + } + let cp = this.html.charCodeAt(this.pos); + //NOTE: all U+000D CARRIAGE RETURN (CR) characters must be converted to U+000A LINE FEED (LF) characters + if (cp === CODE_POINTS.CARRIAGE_RETURN) { + this.isEol = true; + this.skipNextNewLine = true; + return CODE_POINTS.LINE_FEED; + } + //NOTE: any U+000A LINE FEED (LF) characters that immediately follow a U+000D CARRIAGE RETURN (CR) character + //must be ignored. + if (cp === CODE_POINTS.LINE_FEED) { + this.isEol = true; + if (this.skipNextNewLine) { + // `line` will be bumped again in the recursive call. + this.line--; + this.skipNextNewLine = false; + this._addGap(); + return this.advance(); + } + } + this.skipNextNewLine = false; + if (isSurrogate(cp)) { + cp = this._processSurrogate(cp); + } + //OPTIMIZATION: first check if code point is in the common allowed + //range (ASCII alphanumeric, whitespaces, big chunk of BMP) + //before going into detailed performance cost validation. + const isCommonValidRange = this.handler.onParseError === null || + (cp > 0x1f && cp < 0x7f) || + cp === CODE_POINTS.LINE_FEED || + cp === CODE_POINTS.CARRIAGE_RETURN || + (cp > 0x9f && cp < 64976); + if (!isCommonValidRange) { + this._checkForProblematicCharacters(cp); + } + return cp; + } + _checkForProblematicCharacters(cp) { + if (isControlCodePoint(cp)) { + this._err(error_codes_ERR.controlCharacterInInputStream); + } + else if (isUndefinedCodePoint(cp)) { + this._err(error_codes_ERR.noncharacterInInputStream); + } + } + retreat(count) { + this.pos -= count; + while (this.pos < this.lastGapPos) { + this.lastGapPos = this.gapStack.pop(); + this.pos--; + } + this.isEol = false; + } +} +//# sourceMappingURL=preprocessor.js.map +;// CONCATENATED MODULE: ./node_modules/parse5/dist/common/token.js +var token_TokenType; +(function (TokenType) { + TokenType[TokenType["CHARACTER"] = 0] = "CHARACTER"; + TokenType[TokenType["NULL_CHARACTER"] = 1] = "NULL_CHARACTER"; + TokenType[TokenType["WHITESPACE_CHARACTER"] = 2] = "WHITESPACE_CHARACTER"; + TokenType[TokenType["START_TAG"] = 3] = "START_TAG"; + TokenType[TokenType["END_TAG"] = 4] = "END_TAG"; + TokenType[TokenType["COMMENT"] = 5] = "COMMENT"; + TokenType[TokenType["DOCTYPE"] = 6] = "DOCTYPE"; + TokenType[TokenType["EOF"] = 7] = "EOF"; + TokenType[TokenType["HIBERNATION"] = 8] = "HIBERNATION"; +})(token_TokenType = token_TokenType || (token_TokenType = {})); +function token_getTokenAttr(token, attrName) { + for (let i = token.attrs.length - 1; i >= 0; i--) { + if (token.attrs[i].name === attrName) { + return token.attrs[i].value; + } + } + return null; +} +//# sourceMappingURL=token.js.map +;// CONCATENATED MODULE: ./node_modules/entities/lib/esm/generated/decode-data-html.js +// Generated using scripts/write-decode-map.ts +/* harmony default export */ const decode_data_html = (new Uint16Array( +// prettier-ignore +"\u1d41<\xd5\u0131\u028a\u049d\u057b\u05d0\u0675\u06de\u07a2\u07d6\u080f\u0a4a\u0a91\u0da1\u0e6d\u0f09\u0f26\u10ca\u1228\u12e1\u1415\u149d\u14c3\u14df\u1525\0\0\0\0\0\0\u156b\u16cd\u198d\u1c12\u1ddd\u1f7e\u2060\u21b0\u228d\u23c0\u23fb\u2442\u2824\u2912\u2d08\u2e48\u2fce\u3016\u32ba\u3639\u37ac\u38fe\u3a28\u3a71\u3ae0\u3b2e\u0800EMabcfglmnoprstu\\bfms\x7f\x84\x8b\x90\x95\x98\xa6\xb3\xb9\xc8\xcflig\u803b\xc6\u40c6P\u803b&\u4026cute\u803b\xc1\u40c1reve;\u4102\u0100iyx}rc\u803b\xc2\u40c2;\u4410r;\uc000\ud835\udd04rave\u803b\xc0\u40c0pha;\u4391acr;\u4100d;\u6a53\u0100gp\x9d\xa1on;\u4104f;\uc000\ud835\udd38plyFunction;\u6061ing\u803b\xc5\u40c5\u0100cs\xbe\xc3r;\uc000\ud835\udc9cign;\u6254ilde\u803b\xc3\u40c3ml\u803b\xc4\u40c4\u0400aceforsu\xe5\xfb\xfe\u0117\u011c\u0122\u0127\u012a\u0100cr\xea\xf2kslash;\u6216\u0176\xf6\xf8;\u6ae7ed;\u6306y;\u4411\u0180crt\u0105\u010b\u0114ause;\u6235noullis;\u612ca;\u4392r;\uc000\ud835\udd05pf;\uc000\ud835\udd39eve;\u42d8c\xf2\u0113mpeq;\u624e\u0700HOacdefhilorsu\u014d\u0151\u0156\u0180\u019e\u01a2\u01b5\u01b7\u01ba\u01dc\u0215\u0273\u0278\u027ecy;\u4427PY\u803b\xa9\u40a9\u0180cpy\u015d\u0162\u017aute;\u4106\u0100;i\u0167\u0168\u62d2talDifferentialD;\u6145leys;\u612d\u0200aeio\u0189\u018e\u0194\u0198ron;\u410cdil\u803b\xc7\u40c7rc;\u4108nint;\u6230ot;\u410a\u0100dn\u01a7\u01adilla;\u40b8terDot;\u40b7\xf2\u017fi;\u43a7rcle\u0200DMPT\u01c7\u01cb\u01d1\u01d6ot;\u6299inus;\u6296lus;\u6295imes;\u6297o\u0100cs\u01e2\u01f8kwiseContourIntegral;\u6232eCurly\u0100DQ\u0203\u020foubleQuote;\u601duote;\u6019\u0200lnpu\u021e\u0228\u0247\u0255on\u0100;e\u0225\u0226\u6237;\u6a74\u0180git\u022f\u0236\u023aruent;\u6261nt;\u622fourIntegral;\u622e\u0100fr\u024c\u024e;\u6102oduct;\u6210nterClockwiseContourIntegral;\u6233oss;\u6a2fcr;\uc000\ud835\udc9ep\u0100;C\u0284\u0285\u62d3ap;\u624d\u0580DJSZacefios\u02a0\u02ac\u02b0\u02b4\u02b8\u02cb\u02d7\u02e1\u02e6\u0333\u048d\u0100;o\u0179\u02a5trahd;\u6911cy;\u4402cy;\u4405cy;\u440f\u0180grs\u02bf\u02c4\u02c7ger;\u6021r;\u61a1hv;\u6ae4\u0100ay\u02d0\u02d5ron;\u410e;\u4414l\u0100;t\u02dd\u02de\u6207a;\u4394r;\uc000\ud835\udd07\u0100af\u02eb\u0327\u0100cm\u02f0\u0322ritical\u0200ADGT\u0300\u0306\u0316\u031ccute;\u40b4o\u0174\u030b\u030d;\u42d9bleAcute;\u42ddrave;\u4060ilde;\u42dcond;\u62c4ferentialD;\u6146\u0470\u033d\0\0\0\u0342\u0354\0\u0405f;\uc000\ud835\udd3b\u0180;DE\u0348\u0349\u034d\u40a8ot;\u60dcqual;\u6250ble\u0300CDLRUV\u0363\u0372\u0382\u03cf\u03e2\u03f8ontourIntegra\xec\u0239o\u0274\u0379\0\0\u037b\xbb\u0349nArrow;\u61d3\u0100eo\u0387\u03a4ft\u0180ART\u0390\u0396\u03a1rrow;\u61d0ightArrow;\u61d4e\xe5\u02cang\u0100LR\u03ab\u03c4eft\u0100AR\u03b3\u03b9rrow;\u67f8ightArrow;\u67faightArrow;\u67f9ight\u0100AT\u03d8\u03derrow;\u61d2ee;\u62a8p\u0241\u03e9\0\0\u03efrrow;\u61d1ownArrow;\u61d5erticalBar;\u6225n\u0300ABLRTa\u0412\u042a\u0430\u045e\u047f\u037crrow\u0180;BU\u041d\u041e\u0422\u6193ar;\u6913pArrow;\u61f5reve;\u4311eft\u02d2\u043a\0\u0446\0\u0450ightVector;\u6950eeVector;\u695eector\u0100;B\u0459\u045a\u61bdar;\u6956ight\u01d4\u0467\0\u0471eeVector;\u695fector\u0100;B\u047a\u047b\u61c1ar;\u6957ee\u0100;A\u0486\u0487\u62a4rrow;\u61a7\u0100ct\u0492\u0497r;\uc000\ud835\udc9frok;\u4110\u0800NTacdfglmopqstux\u04bd\u04c0\u04c4\u04cb\u04de\u04e2\u04e7\u04ee\u04f5\u0521\u052f\u0536\u0552\u055d\u0560\u0565G;\u414aH\u803b\xd0\u40d0cute\u803b\xc9\u40c9\u0180aiy\u04d2\u04d7\u04dcron;\u411arc\u803b\xca\u40ca;\u442dot;\u4116r;\uc000\ud835\udd08rave\u803b\xc8\u40c8ement;\u6208\u0100ap\u04fa\u04fecr;\u4112ty\u0253\u0506\0\0\u0512mallSquare;\u65fberySmallSquare;\u65ab\u0100gp\u0526\u052aon;\u4118f;\uc000\ud835\udd3csilon;\u4395u\u0100ai\u053c\u0549l\u0100;T\u0542\u0543\u6a75ilde;\u6242librium;\u61cc\u0100ci\u0557\u055ar;\u6130m;\u6a73a;\u4397ml\u803b\xcb\u40cb\u0100ip\u056a\u056fsts;\u6203onentialE;\u6147\u0280cfios\u0585\u0588\u058d\u05b2\u05ccy;\u4424r;\uc000\ud835\udd09lled\u0253\u0597\0\0\u05a3mallSquare;\u65fcerySmallSquare;\u65aa\u0370\u05ba\0\u05bf\0\0\u05c4f;\uc000\ud835\udd3dAll;\u6200riertrf;\u6131c\xf2\u05cb\u0600JTabcdfgorst\u05e8\u05ec\u05ef\u05fa\u0600\u0612\u0616\u061b\u061d\u0623\u066c\u0672cy;\u4403\u803b>\u403emma\u0100;d\u05f7\u05f8\u4393;\u43dcreve;\u411e\u0180eiy\u0607\u060c\u0610dil;\u4122rc;\u411c;\u4413ot;\u4120r;\uc000\ud835\udd0a;\u62d9pf;\uc000\ud835\udd3eeater\u0300EFGLST\u0635\u0644\u064e\u0656\u065b\u0666qual\u0100;L\u063e\u063f\u6265ess;\u62dbullEqual;\u6267reater;\u6aa2ess;\u6277lantEqual;\u6a7eilde;\u6273cr;\uc000\ud835\udca2;\u626b\u0400Aacfiosu\u0685\u068b\u0696\u069b\u069e\u06aa\u06be\u06caRDcy;\u442a\u0100ct\u0690\u0694ek;\u42c7;\u405eirc;\u4124r;\u610clbertSpace;\u610b\u01f0\u06af\0\u06b2f;\u610dizontalLine;\u6500\u0100ct\u06c3\u06c5\xf2\u06a9rok;\u4126mp\u0144\u06d0\u06d8ownHum\xf0\u012fqual;\u624f\u0700EJOacdfgmnostu\u06fa\u06fe\u0703\u0707\u070e\u071a\u071e\u0721\u0728\u0744\u0778\u078b\u078f\u0795cy;\u4415lig;\u4132cy;\u4401cute\u803b\xcd\u40cd\u0100iy\u0713\u0718rc\u803b\xce\u40ce;\u4418ot;\u4130r;\u6111rave\u803b\xcc\u40cc\u0180;ap\u0720\u072f\u073f\u0100cg\u0734\u0737r;\u412ainaryI;\u6148lie\xf3\u03dd\u01f4\u0749\0\u0762\u0100;e\u074d\u074e\u622c\u0100gr\u0753\u0758ral;\u622bsection;\u62c2isible\u0100CT\u076c\u0772omma;\u6063imes;\u6062\u0180gpt\u077f\u0783\u0788on;\u412ef;\uc000\ud835\udd40a;\u4399cr;\u6110ilde;\u4128\u01eb\u079a\0\u079ecy;\u4406l\u803b\xcf\u40cf\u0280cfosu\u07ac\u07b7\u07bc\u07c2\u07d0\u0100iy\u07b1\u07b5rc;\u4134;\u4419r;\uc000\ud835\udd0dpf;\uc000\ud835\udd41\u01e3\u07c7\0\u07ccr;\uc000\ud835\udca5rcy;\u4408kcy;\u4404\u0380HJacfos\u07e4\u07e8\u07ec\u07f1\u07fd\u0802\u0808cy;\u4425cy;\u440cppa;\u439a\u0100ey\u07f6\u07fbdil;\u4136;\u441ar;\uc000\ud835\udd0epf;\uc000\ud835\udd42cr;\uc000\ud835\udca6\u0580JTaceflmost\u0825\u0829\u082c\u0850\u0863\u09b3\u09b8\u09c7\u09cd\u0a37\u0a47cy;\u4409\u803b<\u403c\u0280cmnpr\u0837\u083c\u0841\u0844\u084dute;\u4139bda;\u439bg;\u67ealacetrf;\u6112r;\u619e\u0180aey\u0857\u085c\u0861ron;\u413ddil;\u413b;\u441b\u0100fs\u0868\u0970t\u0500ACDFRTUVar\u087e\u08a9\u08b1\u08e0\u08e6\u08fc\u092f\u095b\u0390\u096a\u0100nr\u0883\u088fgleBracket;\u67e8row\u0180;BR\u0899\u089a\u089e\u6190ar;\u61e4ightArrow;\u61c6eiling;\u6308o\u01f5\u08b7\0\u08c3bleBracket;\u67e6n\u01d4\u08c8\0\u08d2eeVector;\u6961ector\u0100;B\u08db\u08dc\u61c3ar;\u6959loor;\u630aight\u0100AV\u08ef\u08f5rrow;\u6194ector;\u694e\u0100er\u0901\u0917e\u0180;AV\u0909\u090a\u0910\u62a3rrow;\u61a4ector;\u695aiangle\u0180;BE\u0924\u0925\u0929\u62b2ar;\u69cfqual;\u62b4p\u0180DTV\u0937\u0942\u094cownVector;\u6951eeVector;\u6960ector\u0100;B\u0956\u0957\u61bfar;\u6958ector\u0100;B\u0965\u0966\u61bcar;\u6952ight\xe1\u039cs\u0300EFGLST\u097e\u098b\u0995\u099d\u09a2\u09adqualGreater;\u62daullEqual;\u6266reater;\u6276ess;\u6aa1lantEqual;\u6a7dilde;\u6272r;\uc000\ud835\udd0f\u0100;e\u09bd\u09be\u62d8ftarrow;\u61daidot;\u413f\u0180npw\u09d4\u0a16\u0a1bg\u0200LRlr\u09de\u09f7\u0a02\u0a10eft\u0100AR\u09e6\u09ecrrow;\u67f5ightArrow;\u67f7ightArrow;\u67f6eft\u0100ar\u03b3\u0a0aight\xe1\u03bfight\xe1\u03caf;\uc000\ud835\udd43er\u0100LR\u0a22\u0a2ceftArrow;\u6199ightArrow;\u6198\u0180cht\u0a3e\u0a40\u0a42\xf2\u084c;\u61b0rok;\u4141;\u626a\u0400acefiosu\u0a5a\u0a5d\u0a60\u0a77\u0a7c\u0a85\u0a8b\u0a8ep;\u6905y;\u441c\u0100dl\u0a65\u0a6fiumSpace;\u605flintrf;\u6133r;\uc000\ud835\udd10nusPlus;\u6213pf;\uc000\ud835\udd44c\xf2\u0a76;\u439c\u0480Jacefostu\u0aa3\u0aa7\u0aad\u0ac0\u0b14\u0b19\u0d91\u0d97\u0d9ecy;\u440acute;\u4143\u0180aey\u0ab4\u0ab9\u0aberon;\u4147dil;\u4145;\u441d\u0180gsw\u0ac7\u0af0\u0b0eative\u0180MTV\u0ad3\u0adf\u0ae8ediumSpace;\u600bhi\u0100cn\u0ae6\u0ad8\xeb\u0ad9eryThi\xee\u0ad9ted\u0100GL\u0af8\u0b06reaterGreate\xf2\u0673essLes\xf3\u0a48Line;\u400ar;\uc000\ud835\udd11\u0200Bnpt\u0b22\u0b28\u0b37\u0b3areak;\u6060BreakingSpace;\u40a0f;\u6115\u0680;CDEGHLNPRSTV\u0b55\u0b56\u0b6a\u0b7c\u0ba1\u0beb\u0c04\u0c5e\u0c84\u0ca6\u0cd8\u0d61\u0d85\u6aec\u0100ou\u0b5b\u0b64ngruent;\u6262pCap;\u626doubleVerticalBar;\u6226\u0180lqx\u0b83\u0b8a\u0b9bement;\u6209ual\u0100;T\u0b92\u0b93\u6260ilde;\uc000\u2242\u0338ists;\u6204reater\u0380;EFGLST\u0bb6\u0bb7\u0bbd\u0bc9\u0bd3\u0bd8\u0be5\u626fqual;\u6271ullEqual;\uc000\u2267\u0338reater;\uc000\u226b\u0338ess;\u6279lantEqual;\uc000\u2a7e\u0338ilde;\u6275ump\u0144\u0bf2\u0bfdownHump;\uc000\u224e\u0338qual;\uc000\u224f\u0338e\u0100fs\u0c0a\u0c27tTriangle\u0180;BE\u0c1a\u0c1b\u0c21\u62eaar;\uc000\u29cf\u0338qual;\u62ecs\u0300;EGLST\u0c35\u0c36\u0c3c\u0c44\u0c4b\u0c58\u626equal;\u6270reater;\u6278ess;\uc000\u226a\u0338lantEqual;\uc000\u2a7d\u0338ilde;\u6274ested\u0100GL\u0c68\u0c79reaterGreater;\uc000\u2aa2\u0338essLess;\uc000\u2aa1\u0338recedes\u0180;ES\u0c92\u0c93\u0c9b\u6280qual;\uc000\u2aaf\u0338lantEqual;\u62e0\u0100ei\u0cab\u0cb9verseElement;\u620cghtTriangle\u0180;BE\u0ccb\u0ccc\u0cd2\u62ebar;\uc000\u29d0\u0338qual;\u62ed\u0100qu\u0cdd\u0d0cuareSu\u0100bp\u0ce8\u0cf9set\u0100;E\u0cf0\u0cf3\uc000\u228f\u0338qual;\u62e2erset\u0100;E\u0d03\u0d06\uc000\u2290\u0338qual;\u62e3\u0180bcp\u0d13\u0d24\u0d4eset\u0100;E\u0d1b\u0d1e\uc000\u2282\u20d2qual;\u6288ceeds\u0200;EST\u0d32\u0d33\u0d3b\u0d46\u6281qual;\uc000\u2ab0\u0338lantEqual;\u62e1ilde;\uc000\u227f\u0338erset\u0100;E\u0d58\u0d5b\uc000\u2283\u20d2qual;\u6289ilde\u0200;EFT\u0d6e\u0d6f\u0d75\u0d7f\u6241qual;\u6244ullEqual;\u6247ilde;\u6249erticalBar;\u6224cr;\uc000\ud835\udca9ilde\u803b\xd1\u40d1;\u439d\u0700Eacdfgmoprstuv\u0dbd\u0dc2\u0dc9\u0dd5\u0ddb\u0de0\u0de7\u0dfc\u0e02\u0e20\u0e22\u0e32\u0e3f\u0e44lig;\u4152cute\u803b\xd3\u40d3\u0100iy\u0dce\u0dd3rc\u803b\xd4\u40d4;\u441eblac;\u4150r;\uc000\ud835\udd12rave\u803b\xd2\u40d2\u0180aei\u0dee\u0df2\u0df6cr;\u414cga;\u43a9cron;\u439fpf;\uc000\ud835\udd46enCurly\u0100DQ\u0e0e\u0e1aoubleQuote;\u601cuote;\u6018;\u6a54\u0100cl\u0e27\u0e2cr;\uc000\ud835\udcaaash\u803b\xd8\u40d8i\u016c\u0e37\u0e3cde\u803b\xd5\u40d5es;\u6a37ml\u803b\xd6\u40d6er\u0100BP\u0e4b\u0e60\u0100ar\u0e50\u0e53r;\u603eac\u0100ek\u0e5a\u0e5c;\u63deet;\u63b4arenthesis;\u63dc\u0480acfhilors\u0e7f\u0e87\u0e8a\u0e8f\u0e92\u0e94\u0e9d\u0eb0\u0efcrtialD;\u6202y;\u441fr;\uc000\ud835\udd13i;\u43a6;\u43a0usMinus;\u40b1\u0100ip\u0ea2\u0eadncareplan\xe5\u069df;\u6119\u0200;eio\u0eb9\u0eba\u0ee0\u0ee4\u6abbcedes\u0200;EST\u0ec8\u0ec9\u0ecf\u0eda\u627aqual;\u6aaflantEqual;\u627cilde;\u627eme;\u6033\u0100dp\u0ee9\u0eeeuct;\u620fortion\u0100;a\u0225\u0ef9l;\u621d\u0100ci\u0f01\u0f06r;\uc000\ud835\udcab;\u43a8\u0200Ufos\u0f11\u0f16\u0f1b\u0f1fOT\u803b\"\u4022r;\uc000\ud835\udd14pf;\u611acr;\uc000\ud835\udcac\u0600BEacefhiorsu\u0f3e\u0f43\u0f47\u0f60\u0f73\u0fa7\u0faa\u0fad\u1096\u10a9\u10b4\u10bearr;\u6910G\u803b\xae\u40ae\u0180cnr\u0f4e\u0f53\u0f56ute;\u4154g;\u67ebr\u0100;t\u0f5c\u0f5d\u61a0l;\u6916\u0180aey\u0f67\u0f6c\u0f71ron;\u4158dil;\u4156;\u4420\u0100;v\u0f78\u0f79\u611cerse\u0100EU\u0f82\u0f99\u0100lq\u0f87\u0f8eement;\u620builibrium;\u61cbpEquilibrium;\u696fr\xbb\u0f79o;\u43a1ght\u0400ACDFTUVa\u0fc1\u0feb\u0ff3\u1022\u1028\u105b\u1087\u03d8\u0100nr\u0fc6\u0fd2gleBracket;\u67e9row\u0180;BL\u0fdc\u0fdd\u0fe1\u6192ar;\u61e5eftArrow;\u61c4eiling;\u6309o\u01f5\u0ff9\0\u1005bleBracket;\u67e7n\u01d4\u100a\0\u1014eeVector;\u695dector\u0100;B\u101d\u101e\u61c2ar;\u6955loor;\u630b\u0100er\u102d\u1043e\u0180;AV\u1035\u1036\u103c\u62a2rrow;\u61a6ector;\u695biangle\u0180;BE\u1050\u1051\u1055\u62b3ar;\u69d0qual;\u62b5p\u0180DTV\u1063\u106e\u1078ownVector;\u694feeVector;\u695cector\u0100;B\u1082\u1083\u61bear;\u6954ector\u0100;B\u1091\u1092\u61c0ar;\u6953\u0100pu\u109b\u109ef;\u611dndImplies;\u6970ightarrow;\u61db\u0100ch\u10b9\u10bcr;\u611b;\u61b1leDelayed;\u69f4\u0680HOacfhimoqstu\u10e4\u10f1\u10f7\u10fd\u1119\u111e\u1151\u1156\u1161\u1167\u11b5\u11bb\u11bf\u0100Cc\u10e9\u10eeHcy;\u4429y;\u4428FTcy;\u442ccute;\u415a\u0280;aeiy\u1108\u1109\u110e\u1113\u1117\u6abcron;\u4160dil;\u415erc;\u415c;\u4421r;\uc000\ud835\udd16ort\u0200DLRU\u112a\u1134\u113e\u1149ownArrow\xbb\u041eeftArrow\xbb\u089aightArrow\xbb\u0fddpArrow;\u6191gma;\u43a3allCircle;\u6218pf;\uc000\ud835\udd4a\u0272\u116d\0\0\u1170t;\u621aare\u0200;ISU\u117b\u117c\u1189\u11af\u65a1ntersection;\u6293u\u0100bp\u118f\u119eset\u0100;E\u1197\u1198\u628fqual;\u6291erset\u0100;E\u11a8\u11a9\u6290qual;\u6292nion;\u6294cr;\uc000\ud835\udcaear;\u62c6\u0200bcmp\u11c8\u11db\u1209\u120b\u0100;s\u11cd\u11ce\u62d0et\u0100;E\u11cd\u11d5qual;\u6286\u0100ch\u11e0\u1205eeds\u0200;EST\u11ed\u11ee\u11f4\u11ff\u627bqual;\u6ab0lantEqual;\u627dilde;\u627fTh\xe1\u0f8c;\u6211\u0180;es\u1212\u1213\u1223\u62d1rset\u0100;E\u121c\u121d\u6283qual;\u6287et\xbb\u1213\u0580HRSacfhiors\u123e\u1244\u1249\u1255\u125e\u1271\u1276\u129f\u12c2\u12c8\u12d1ORN\u803b\xde\u40deADE;\u6122\u0100Hc\u124e\u1252cy;\u440by;\u4426\u0100bu\u125a\u125c;\u4009;\u43a4\u0180aey\u1265\u126a\u126fron;\u4164dil;\u4162;\u4422r;\uc000\ud835\udd17\u0100ei\u127b\u1289\u01f2\u1280\0\u1287efore;\u6234a;\u4398\u0100cn\u128e\u1298kSpace;\uc000\u205f\u200aSpace;\u6009lde\u0200;EFT\u12ab\u12ac\u12b2\u12bc\u623cqual;\u6243ullEqual;\u6245ilde;\u6248pf;\uc000\ud835\udd4bipleDot;\u60db\u0100ct\u12d6\u12dbr;\uc000\ud835\udcafrok;\u4166\u0ae1\u12f7\u130e\u131a\u1326\0\u132c\u1331\0\0\0\0\0\u1338\u133d\u1377\u1385\0\u13ff\u1404\u140a\u1410\u0100cr\u12fb\u1301ute\u803b\xda\u40dar\u0100;o\u1307\u1308\u619fcir;\u6949r\u01e3\u1313\0\u1316y;\u440eve;\u416c\u0100iy\u131e\u1323rc\u803b\xdb\u40db;\u4423blac;\u4170r;\uc000\ud835\udd18rave\u803b\xd9\u40d9acr;\u416a\u0100di\u1341\u1369er\u0100BP\u1348\u135d\u0100ar\u134d\u1350r;\u405fac\u0100ek\u1357\u1359;\u63dfet;\u63b5arenthesis;\u63ddon\u0100;P\u1370\u1371\u62c3lus;\u628e\u0100gp\u137b\u137fon;\u4172f;\uc000\ud835\udd4c\u0400ADETadps\u1395\u13ae\u13b8\u13c4\u03e8\u13d2\u13d7\u13f3rrow\u0180;BD\u1150\u13a0\u13a4ar;\u6912ownArrow;\u61c5ownArrow;\u6195quilibrium;\u696eee\u0100;A\u13cb\u13cc\u62a5rrow;\u61a5own\xe1\u03f3er\u0100LR\u13de\u13e8eftArrow;\u6196ightArrow;\u6197i\u0100;l\u13f9\u13fa\u43d2on;\u43a5ing;\u416ecr;\uc000\ud835\udcb0ilde;\u4168ml\u803b\xdc\u40dc\u0480Dbcdefosv\u1427\u142c\u1430\u1433\u143e\u1485\u148a\u1490\u1496ash;\u62abar;\u6aeby;\u4412ash\u0100;l\u143b\u143c\u62a9;\u6ae6\u0100er\u1443\u1445;\u62c1\u0180bty\u144c\u1450\u147aar;\u6016\u0100;i\u144f\u1455cal\u0200BLST\u1461\u1465\u146a\u1474ar;\u6223ine;\u407ceparator;\u6758ilde;\u6240ThinSpace;\u600ar;\uc000\ud835\udd19pf;\uc000\ud835\udd4dcr;\uc000\ud835\udcb1dash;\u62aa\u0280cefos\u14a7\u14ac\u14b1\u14b6\u14bcirc;\u4174dge;\u62c0r;\uc000\ud835\udd1apf;\uc000\ud835\udd4ecr;\uc000\ud835\udcb2\u0200fios\u14cb\u14d0\u14d2\u14d8r;\uc000\ud835\udd1b;\u439epf;\uc000\ud835\udd4fcr;\uc000\ud835\udcb3\u0480AIUacfosu\u14f1\u14f5\u14f9\u14fd\u1504\u150f\u1514\u151a\u1520cy;\u442fcy;\u4407cy;\u442ecute\u803b\xdd\u40dd\u0100iy\u1509\u150drc;\u4176;\u442br;\uc000\ud835\udd1cpf;\uc000\ud835\udd50cr;\uc000\ud835\udcb4ml;\u4178\u0400Hacdefos\u1535\u1539\u153f\u154b\u154f\u155d\u1560\u1564cy;\u4416cute;\u4179\u0100ay\u1544\u1549ron;\u417d;\u4417ot;\u417b\u01f2\u1554\0\u155boWidt\xe8\u0ad9a;\u4396r;\u6128pf;\u6124cr;\uc000\ud835\udcb5\u0be1\u1583\u158a\u1590\0\u15b0\u15b6\u15bf\0\0\0\0\u15c6\u15db\u15eb\u165f\u166d\0\u1695\u169b\u16b2\u16b9\0\u16becute\u803b\xe1\u40e1reve;\u4103\u0300;Ediuy\u159c\u159d\u15a1\u15a3\u15a8\u15ad\u623e;\uc000\u223e\u0333;\u623frc\u803b\xe2\u40e2te\u80bb\xb4\u0306;\u4430lig\u803b\xe6\u40e6\u0100;r\xb2\u15ba;\uc000\ud835\udd1erave\u803b\xe0\u40e0\u0100ep\u15ca\u15d6\u0100fp\u15cf\u15d4sym;\u6135\xe8\u15d3ha;\u43b1\u0100ap\u15dfc\u0100cl\u15e4\u15e7r;\u4101g;\u6a3f\u0264\u15f0\0\0\u160a\u0280;adsv\u15fa\u15fb\u15ff\u1601\u1607\u6227nd;\u6a55;\u6a5clope;\u6a58;\u6a5a\u0380;elmrsz\u1618\u1619\u161b\u161e\u163f\u164f\u1659\u6220;\u69a4e\xbb\u1619sd\u0100;a\u1625\u1626\u6221\u0461\u1630\u1632\u1634\u1636\u1638\u163a\u163c\u163e;\u69a8;\u69a9;\u69aa;\u69ab;\u69ac;\u69ad;\u69ae;\u69aft\u0100;v\u1645\u1646\u621fb\u0100;d\u164c\u164d\u62be;\u699d\u0100pt\u1654\u1657h;\u6222\xbb\xb9arr;\u637c\u0100gp\u1663\u1667on;\u4105f;\uc000\ud835\udd52\u0380;Eaeiop\u12c1\u167b\u167d\u1682\u1684\u1687\u168a;\u6a70cir;\u6a6f;\u624ad;\u624bs;\u4027rox\u0100;e\u12c1\u1692\xf1\u1683ing\u803b\xe5\u40e5\u0180cty\u16a1\u16a6\u16a8r;\uc000\ud835\udcb6;\u402amp\u0100;e\u12c1\u16af\xf1\u0288ilde\u803b\xe3\u40e3ml\u803b\xe4\u40e4\u0100ci\u16c2\u16c8onin\xf4\u0272nt;\u6a11\u0800Nabcdefiklnoprsu\u16ed\u16f1\u1730\u173c\u1743\u1748\u1778\u177d\u17e0\u17e6\u1839\u1850\u170d\u193d\u1948\u1970ot;\u6aed\u0100cr\u16f6\u171ek\u0200ceps\u1700\u1705\u170d\u1713ong;\u624cpsilon;\u43f6rime;\u6035im\u0100;e\u171a\u171b\u623dq;\u62cd\u0176\u1722\u1726ee;\u62bded\u0100;g\u172c\u172d\u6305e\xbb\u172drk\u0100;t\u135c\u1737brk;\u63b6\u0100oy\u1701\u1741;\u4431quo;\u601e\u0280cmprt\u1753\u175b\u1761\u1764\u1768aus\u0100;e\u010a\u0109ptyv;\u69b0s\xe9\u170cno\xf5\u0113\u0180ahw\u176f\u1771\u1773;\u43b2;\u6136een;\u626cr;\uc000\ud835\udd1fg\u0380costuvw\u178d\u179d\u17b3\u17c1\u17d5\u17db\u17de\u0180aiu\u1794\u1796\u179a\xf0\u0760rc;\u65efp\xbb\u1371\u0180dpt\u17a4\u17a8\u17adot;\u6a00lus;\u6a01imes;\u6a02\u0271\u17b9\0\0\u17becup;\u6a06ar;\u6605riangle\u0100du\u17cd\u17d2own;\u65bdp;\u65b3plus;\u6a04e\xe5\u1444\xe5\u14adarow;\u690d\u0180ako\u17ed\u1826\u1835\u0100cn\u17f2\u1823k\u0180lst\u17fa\u05ab\u1802ozenge;\u69ebriangle\u0200;dlr\u1812\u1813\u1818\u181d\u65b4own;\u65beeft;\u65c2ight;\u65b8k;\u6423\u01b1\u182b\0\u1833\u01b2\u182f\0\u1831;\u6592;\u65914;\u6593ck;\u6588\u0100eo\u183e\u184d\u0100;q\u1843\u1846\uc000=\u20e5uiv;\uc000\u2261\u20e5t;\u6310\u0200ptwx\u1859\u185e\u1867\u186cf;\uc000\ud835\udd53\u0100;t\u13cb\u1863om\xbb\u13cctie;\u62c8\u0600DHUVbdhmptuv\u1885\u1896\u18aa\u18bb\u18d7\u18db\u18ec\u18ff\u1905\u190a\u1910\u1921\u0200LRlr\u188e\u1890\u1892\u1894;\u6557;\u6554;\u6556;\u6553\u0280;DUdu\u18a1\u18a2\u18a4\u18a6\u18a8\u6550;\u6566;\u6569;\u6564;\u6567\u0200LRlr\u18b3\u18b5\u18b7\u18b9;\u655d;\u655a;\u655c;\u6559\u0380;HLRhlr\u18ca\u18cb\u18cd\u18cf\u18d1\u18d3\u18d5\u6551;\u656c;\u6563;\u6560;\u656b;\u6562;\u655fox;\u69c9\u0200LRlr\u18e4\u18e6\u18e8\u18ea;\u6555;\u6552;\u6510;\u650c\u0280;DUdu\u06bd\u18f7\u18f9\u18fb\u18fd;\u6565;\u6568;\u652c;\u6534inus;\u629flus;\u629eimes;\u62a0\u0200LRlr\u1919\u191b\u191d\u191f;\u655b;\u6558;\u6518;\u6514\u0380;HLRhlr\u1930\u1931\u1933\u1935\u1937\u1939\u193b\u6502;\u656a;\u6561;\u655e;\u653c;\u6524;\u651c\u0100ev\u0123\u1942bar\u803b\xa6\u40a6\u0200ceio\u1951\u1956\u195a\u1960r;\uc000\ud835\udcb7mi;\u604fm\u0100;e\u171a\u171cl\u0180;bh\u1968\u1969\u196b\u405c;\u69c5sub;\u67c8\u016c\u1974\u197el\u0100;e\u1979\u197a\u6022t\xbb\u197ap\u0180;Ee\u012f\u1985\u1987;\u6aae\u0100;q\u06dc\u06db\u0ce1\u19a7\0\u19e8\u1a11\u1a15\u1a32\0\u1a37\u1a50\0\0\u1ab4\0\0\u1ac1\0\0\u1b21\u1b2e\u1b4d\u1b52\0\u1bfd\0\u1c0c\u0180cpr\u19ad\u19b2\u19ddute;\u4107\u0300;abcds\u19bf\u19c0\u19c4\u19ca\u19d5\u19d9\u6229nd;\u6a44rcup;\u6a49\u0100au\u19cf\u19d2p;\u6a4bp;\u6a47ot;\u6a40;\uc000\u2229\ufe00\u0100eo\u19e2\u19e5t;\u6041\xee\u0693\u0200aeiu\u19f0\u19fb\u1a01\u1a05\u01f0\u19f5\0\u19f8s;\u6a4don;\u410ddil\u803b\xe7\u40e7rc;\u4109ps\u0100;s\u1a0c\u1a0d\u6a4cm;\u6a50ot;\u410b\u0180dmn\u1a1b\u1a20\u1a26il\u80bb\xb8\u01adptyv;\u69b2t\u8100\xa2;e\u1a2d\u1a2e\u40a2r\xe4\u01b2r;\uc000\ud835\udd20\u0180cei\u1a3d\u1a40\u1a4dy;\u4447ck\u0100;m\u1a47\u1a48\u6713ark\xbb\u1a48;\u43c7r\u0380;Ecefms\u1a5f\u1a60\u1a62\u1a6b\u1aa4\u1aaa\u1aae\u65cb;\u69c3\u0180;el\u1a69\u1a6a\u1a6d\u42c6q;\u6257e\u0261\u1a74\0\0\u1a88rrow\u0100lr\u1a7c\u1a81eft;\u61baight;\u61bb\u0280RSacd\u1a92\u1a94\u1a96\u1a9a\u1a9f\xbb\u0f47;\u64c8st;\u629birc;\u629aash;\u629dnint;\u6a10id;\u6aefcir;\u69c2ubs\u0100;u\u1abb\u1abc\u6663it\xbb\u1abc\u02ec\u1ac7\u1ad4\u1afa\0\u1b0aon\u0100;e\u1acd\u1ace\u403a\u0100;q\xc7\xc6\u026d\u1ad9\0\0\u1ae2a\u0100;t\u1ade\u1adf\u402c;\u4040\u0180;fl\u1ae8\u1ae9\u1aeb\u6201\xee\u1160e\u0100mx\u1af1\u1af6ent\xbb\u1ae9e\xf3\u024d\u01e7\u1afe\0\u1b07\u0100;d\u12bb\u1b02ot;\u6a6dn\xf4\u0246\u0180fry\u1b10\u1b14\u1b17;\uc000\ud835\udd54o\xe4\u0254\u8100\xa9;s\u0155\u1b1dr;\u6117\u0100ao\u1b25\u1b29rr;\u61b5ss;\u6717\u0100cu\u1b32\u1b37r;\uc000\ud835\udcb8\u0100bp\u1b3c\u1b44\u0100;e\u1b41\u1b42\u6acf;\u6ad1\u0100;e\u1b49\u1b4a\u6ad0;\u6ad2dot;\u62ef\u0380delprvw\u1b60\u1b6c\u1b77\u1b82\u1bac\u1bd4\u1bf9arr\u0100lr\u1b68\u1b6a;\u6938;\u6935\u0270\u1b72\0\0\u1b75r;\u62dec;\u62dfarr\u0100;p\u1b7f\u1b80\u61b6;\u693d\u0300;bcdos\u1b8f\u1b90\u1b96\u1ba1\u1ba5\u1ba8\u622arcap;\u6a48\u0100au\u1b9b\u1b9ep;\u6a46p;\u6a4aot;\u628dr;\u6a45;\uc000\u222a\ufe00\u0200alrv\u1bb5\u1bbf\u1bde\u1be3rr\u0100;m\u1bbc\u1bbd\u61b7;\u693cy\u0180evw\u1bc7\u1bd4\u1bd8q\u0270\u1bce\0\0\u1bd2re\xe3\u1b73u\xe3\u1b75ee;\u62ceedge;\u62cfen\u803b\xa4\u40a4earrow\u0100lr\u1bee\u1bf3eft\xbb\u1b80ight\xbb\u1bbde\xe4\u1bdd\u0100ci\u1c01\u1c07onin\xf4\u01f7nt;\u6231lcty;\u632d\u0980AHabcdefhijlorstuwz\u1c38\u1c3b\u1c3f\u1c5d\u1c69\u1c75\u1c8a\u1c9e\u1cac\u1cb7\u1cfb\u1cff\u1d0d\u1d7b\u1d91\u1dab\u1dbb\u1dc6\u1dcdr\xf2\u0381ar;\u6965\u0200glrs\u1c48\u1c4d\u1c52\u1c54ger;\u6020eth;\u6138\xf2\u1133h\u0100;v\u1c5a\u1c5b\u6010\xbb\u090a\u016b\u1c61\u1c67arow;\u690fa\xe3\u0315\u0100ay\u1c6e\u1c73ron;\u410f;\u4434\u0180;ao\u0332\u1c7c\u1c84\u0100gr\u02bf\u1c81r;\u61catseq;\u6a77\u0180glm\u1c91\u1c94\u1c98\u803b\xb0\u40b0ta;\u43b4ptyv;\u69b1\u0100ir\u1ca3\u1ca8sht;\u697f;\uc000\ud835\udd21ar\u0100lr\u1cb3\u1cb5\xbb\u08dc\xbb\u101e\u0280aegsv\u1cc2\u0378\u1cd6\u1cdc\u1ce0m\u0180;os\u0326\u1cca\u1cd4nd\u0100;s\u0326\u1cd1uit;\u6666amma;\u43ddin;\u62f2\u0180;io\u1ce7\u1ce8\u1cf8\u40f7de\u8100\xf7;o\u1ce7\u1cf0ntimes;\u62c7n\xf8\u1cf7cy;\u4452c\u026f\u1d06\0\0\u1d0arn;\u631eop;\u630d\u0280lptuw\u1d18\u1d1d\u1d22\u1d49\u1d55lar;\u4024f;\uc000\ud835\udd55\u0280;emps\u030b\u1d2d\u1d37\u1d3d\u1d42q\u0100;d\u0352\u1d33ot;\u6251inus;\u6238lus;\u6214quare;\u62a1blebarwedg\xe5\xfan\u0180adh\u112e\u1d5d\u1d67ownarrow\xf3\u1c83arpoon\u0100lr\u1d72\u1d76ef\xf4\u1cb4igh\xf4\u1cb6\u0162\u1d7f\u1d85karo\xf7\u0f42\u026f\u1d8a\0\0\u1d8ern;\u631fop;\u630c\u0180cot\u1d98\u1da3\u1da6\u0100ry\u1d9d\u1da1;\uc000\ud835\udcb9;\u4455l;\u69f6rok;\u4111\u0100dr\u1db0\u1db4ot;\u62f1i\u0100;f\u1dba\u1816\u65bf\u0100ah\u1dc0\u1dc3r\xf2\u0429a\xf2\u0fa6angle;\u69a6\u0100ci\u1dd2\u1dd5y;\u445fgrarr;\u67ff\u0900Dacdefglmnopqrstux\u1e01\u1e09\u1e19\u1e38\u0578\u1e3c\u1e49\u1e61\u1e7e\u1ea5\u1eaf\u1ebd\u1ee1\u1f2a\u1f37\u1f44\u1f4e\u1f5a\u0100Do\u1e06\u1d34o\xf4\u1c89\u0100cs\u1e0e\u1e14ute\u803b\xe9\u40e9ter;\u6a6e\u0200aioy\u1e22\u1e27\u1e31\u1e36ron;\u411br\u0100;c\u1e2d\u1e2e\u6256\u803b\xea\u40ealon;\u6255;\u444dot;\u4117\u0100Dr\u1e41\u1e45ot;\u6252;\uc000\ud835\udd22\u0180;rs\u1e50\u1e51\u1e57\u6a9aave\u803b\xe8\u40e8\u0100;d\u1e5c\u1e5d\u6a96ot;\u6a98\u0200;ils\u1e6a\u1e6b\u1e72\u1e74\u6a99nters;\u63e7;\u6113\u0100;d\u1e79\u1e7a\u6a95ot;\u6a97\u0180aps\u1e85\u1e89\u1e97cr;\u4113ty\u0180;sv\u1e92\u1e93\u1e95\u6205et\xbb\u1e93p\u01001;\u1e9d\u1ea4\u0133\u1ea1\u1ea3;\u6004;\u6005\u6003\u0100gs\u1eaa\u1eac;\u414bp;\u6002\u0100gp\u1eb4\u1eb8on;\u4119f;\uc000\ud835\udd56\u0180als\u1ec4\u1ece\u1ed2r\u0100;s\u1eca\u1ecb\u62d5l;\u69e3us;\u6a71i\u0180;lv\u1eda\u1edb\u1edf\u43b5on\xbb\u1edb;\u43f5\u0200csuv\u1eea\u1ef3\u1f0b\u1f23\u0100io\u1eef\u1e31rc\xbb\u1e2e\u0269\u1ef9\0\0\u1efb\xed\u0548ant\u0100gl\u1f02\u1f06tr\xbb\u1e5dess\xbb\u1e7a\u0180aei\u1f12\u1f16\u1f1als;\u403dst;\u625fv\u0100;D\u0235\u1f20D;\u6a78parsl;\u69e5\u0100Da\u1f2f\u1f33ot;\u6253rr;\u6971\u0180cdi\u1f3e\u1f41\u1ef8r;\u612fo\xf4\u0352\u0100ah\u1f49\u1f4b;\u43b7\u803b\xf0\u40f0\u0100mr\u1f53\u1f57l\u803b\xeb\u40ebo;\u60ac\u0180cip\u1f61\u1f64\u1f67l;\u4021s\xf4\u056e\u0100eo\u1f6c\u1f74ctatio\xee\u0559nential\xe5\u0579\u09e1\u1f92\0\u1f9e\0\u1fa1\u1fa7\0\0\u1fc6\u1fcc\0\u1fd3\0\u1fe6\u1fea\u2000\0\u2008\u205allingdotse\xf1\u1e44y;\u4444male;\u6640\u0180ilr\u1fad\u1fb3\u1fc1lig;\u8000\ufb03\u0269\u1fb9\0\0\u1fbdg;\u8000\ufb00ig;\u8000\ufb04;\uc000\ud835\udd23lig;\u8000\ufb01lig;\uc000fj\u0180alt\u1fd9\u1fdc\u1fe1t;\u666dig;\u8000\ufb02ns;\u65b1of;\u4192\u01f0\u1fee\0\u1ff3f;\uc000\ud835\udd57\u0100ak\u05bf\u1ff7\u0100;v\u1ffc\u1ffd\u62d4;\u6ad9artint;\u6a0d\u0100ao\u200c\u2055\u0100cs\u2011\u2052\u03b1\u201a\u2030\u2038\u2045\u2048\0\u2050\u03b2\u2022\u2025\u2027\u202a\u202c\0\u202e\u803b\xbd\u40bd;\u6153\u803b\xbc\u40bc;\u6155;\u6159;\u615b\u01b3\u2034\0\u2036;\u6154;\u6156\u02b4\u203e\u2041\0\0\u2043\u803b\xbe\u40be;\u6157;\u615c5;\u6158\u01b6\u204c\0\u204e;\u615a;\u615d8;\u615el;\u6044wn;\u6322cr;\uc000\ud835\udcbb\u0880Eabcdefgijlnorstv\u2082\u2089\u209f\u20a5\u20b0\u20b4\u20f0\u20f5\u20fa\u20ff\u2103\u2112\u2138\u0317\u213e\u2152\u219e\u0100;l\u064d\u2087;\u6a8c\u0180cmp\u2090\u2095\u209dute;\u41f5ma\u0100;d\u209c\u1cda\u43b3;\u6a86reve;\u411f\u0100iy\u20aa\u20aerc;\u411d;\u4433ot;\u4121\u0200;lqs\u063e\u0642\u20bd\u20c9\u0180;qs\u063e\u064c\u20c4lan\xf4\u0665\u0200;cdl\u0665\u20d2\u20d5\u20e5c;\u6aa9ot\u0100;o\u20dc\u20dd\u6a80\u0100;l\u20e2\u20e3\u6a82;\u6a84\u0100;e\u20ea\u20ed\uc000\u22db\ufe00s;\u6a94r;\uc000\ud835\udd24\u0100;g\u0673\u061bmel;\u6137cy;\u4453\u0200;Eaj\u065a\u210c\u210e\u2110;\u6a92;\u6aa5;\u6aa4\u0200Eaes\u211b\u211d\u2129\u2134;\u6269p\u0100;p\u2123\u2124\u6a8arox\xbb\u2124\u0100;q\u212e\u212f\u6a88\u0100;q\u212e\u211bim;\u62e7pf;\uc000\ud835\udd58\u0100ci\u2143\u2146r;\u610am\u0180;el\u066b\u214e\u2150;\u6a8e;\u6a90\u8300>;cdlqr\u05ee\u2160\u216a\u216e\u2173\u2179\u0100ci\u2165\u2167;\u6aa7r;\u6a7aot;\u62d7Par;\u6995uest;\u6a7c\u0280adels\u2184\u216a\u2190\u0656\u219b\u01f0\u2189\0\u218epro\xf8\u209er;\u6978q\u0100lq\u063f\u2196les\xf3\u2088i\xed\u066b\u0100en\u21a3\u21adrtneqq;\uc000\u2269\ufe00\xc5\u21aa\u0500Aabcefkosy\u21c4\u21c7\u21f1\u21f5\u21fa\u2218\u221d\u222f\u2268\u227dr\xf2\u03a0\u0200ilmr\u21d0\u21d4\u21d7\u21dbrs\xf0\u1484f\xbb\u2024il\xf4\u06a9\u0100dr\u21e0\u21e4cy;\u444a\u0180;cw\u08f4\u21eb\u21efir;\u6948;\u61adar;\u610firc;\u4125\u0180alr\u2201\u220e\u2213rts\u0100;u\u2209\u220a\u6665it\xbb\u220alip;\u6026con;\u62b9r;\uc000\ud835\udd25s\u0100ew\u2223\u2229arow;\u6925arow;\u6926\u0280amopr\u223a\u223e\u2243\u225e\u2263rr;\u61fftht;\u623bk\u0100lr\u2249\u2253eftarrow;\u61a9ightarrow;\u61aaf;\uc000\ud835\udd59bar;\u6015\u0180clt\u226f\u2274\u2278r;\uc000\ud835\udcbdas\xe8\u21f4rok;\u4127\u0100bp\u2282\u2287ull;\u6043hen\xbb\u1c5b\u0ae1\u22a3\0\u22aa\0\u22b8\u22c5\u22ce\0\u22d5\u22f3\0\0\u22f8\u2322\u2367\u2362\u237f\0\u2386\u23aa\u23b4cute\u803b\xed\u40ed\u0180;iy\u0771\u22b0\u22b5rc\u803b\xee\u40ee;\u4438\u0100cx\u22bc\u22bfy;\u4435cl\u803b\xa1\u40a1\u0100fr\u039f\u22c9;\uc000\ud835\udd26rave\u803b\xec\u40ec\u0200;ino\u073e\u22dd\u22e9\u22ee\u0100in\u22e2\u22e6nt;\u6a0ct;\u622dfin;\u69dcta;\u6129lig;\u4133\u0180aop\u22fe\u231a\u231d\u0180cgt\u2305\u2308\u2317r;\u412b\u0180elp\u071f\u230f\u2313in\xe5\u078ear\xf4\u0720h;\u4131f;\u62b7ed;\u41b5\u0280;cfot\u04f4\u232c\u2331\u233d\u2341are;\u6105in\u0100;t\u2338\u2339\u621eie;\u69dddo\xf4\u2319\u0280;celp\u0757\u234c\u2350\u235b\u2361al;\u62ba\u0100gr\u2355\u2359er\xf3\u1563\xe3\u234darhk;\u6a17rod;\u6a3c\u0200cgpt\u236f\u2372\u2376\u237by;\u4451on;\u412ff;\uc000\ud835\udd5aa;\u43b9uest\u803b\xbf\u40bf\u0100ci\u238a\u238fr;\uc000\ud835\udcben\u0280;Edsv\u04f4\u239b\u239d\u23a1\u04f3;\u62f9ot;\u62f5\u0100;v\u23a6\u23a7\u62f4;\u62f3\u0100;i\u0777\u23aelde;\u4129\u01eb\u23b8\0\u23bccy;\u4456l\u803b\xef\u40ef\u0300cfmosu\u23cc\u23d7\u23dc\u23e1\u23e7\u23f5\u0100iy\u23d1\u23d5rc;\u4135;\u4439r;\uc000\ud835\udd27ath;\u4237pf;\uc000\ud835\udd5b\u01e3\u23ec\0\u23f1r;\uc000\ud835\udcbfrcy;\u4458kcy;\u4454\u0400acfghjos\u240b\u2416\u2422\u2427\u242d\u2431\u2435\u243bppa\u0100;v\u2413\u2414\u43ba;\u43f0\u0100ey\u241b\u2420dil;\u4137;\u443ar;\uc000\ud835\udd28reen;\u4138cy;\u4445cy;\u445cpf;\uc000\ud835\udd5ccr;\uc000\ud835\udcc0\u0b80ABEHabcdefghjlmnoprstuv\u2470\u2481\u2486\u248d\u2491\u250e\u253d\u255a\u2580\u264e\u265e\u2665\u2679\u267d\u269a\u26b2\u26d8\u275d\u2768\u278b\u27c0\u2801\u2812\u0180art\u2477\u247a\u247cr\xf2\u09c6\xf2\u0395ail;\u691barr;\u690e\u0100;g\u0994\u248b;\u6a8bar;\u6962\u0963\u24a5\0\u24aa\0\u24b1\0\0\0\0\0\u24b5\u24ba\0\u24c6\u24c8\u24cd\0\u24f9ute;\u413amptyv;\u69b4ra\xee\u084cbda;\u43bbg\u0180;dl\u088e\u24c1\u24c3;\u6991\xe5\u088e;\u6a85uo\u803b\xab\u40abr\u0400;bfhlpst\u0899\u24de\u24e6\u24e9\u24eb\u24ee\u24f1\u24f5\u0100;f\u089d\u24e3s;\u691fs;\u691d\xeb\u2252p;\u61abl;\u6939im;\u6973l;\u61a2\u0180;ae\u24ff\u2500\u2504\u6aabil;\u6919\u0100;s\u2509\u250a\u6aad;\uc000\u2aad\ufe00\u0180abr\u2515\u2519\u251drr;\u690crk;\u6772\u0100ak\u2522\u252cc\u0100ek\u2528\u252a;\u407b;\u405b\u0100es\u2531\u2533;\u698bl\u0100du\u2539\u253b;\u698f;\u698d\u0200aeuy\u2546\u254b\u2556\u2558ron;\u413e\u0100di\u2550\u2554il;\u413c\xec\u08b0\xe2\u2529;\u443b\u0200cqrs\u2563\u2566\u256d\u257da;\u6936uo\u0100;r\u0e19\u1746\u0100du\u2572\u2577har;\u6967shar;\u694bh;\u61b2\u0280;fgqs\u258b\u258c\u0989\u25f3\u25ff\u6264t\u0280ahlrt\u2598\u25a4\u25b7\u25c2\u25e8rrow\u0100;t\u0899\u25a1a\xe9\u24f6arpoon\u0100du\u25af\u25b4own\xbb\u045ap\xbb\u0966eftarrows;\u61c7ight\u0180ahs\u25cd\u25d6\u25derrow\u0100;s\u08f4\u08a7arpoon\xf3\u0f98quigarro\xf7\u21f0hreetimes;\u62cb\u0180;qs\u258b\u0993\u25falan\xf4\u09ac\u0280;cdgs\u09ac\u260a\u260d\u261d\u2628c;\u6aa8ot\u0100;o\u2614\u2615\u6a7f\u0100;r\u261a\u261b\u6a81;\u6a83\u0100;e\u2622\u2625\uc000\u22da\ufe00s;\u6a93\u0280adegs\u2633\u2639\u263d\u2649\u264bppro\xf8\u24c6ot;\u62d6q\u0100gq\u2643\u2645\xf4\u0989gt\xf2\u248c\xf4\u099bi\xed\u09b2\u0180ilr\u2655\u08e1\u265asht;\u697c;\uc000\ud835\udd29\u0100;E\u099c\u2663;\u6a91\u0161\u2669\u2676r\u0100du\u25b2\u266e\u0100;l\u0965\u2673;\u696alk;\u6584cy;\u4459\u0280;acht\u0a48\u2688\u268b\u2691\u2696r\xf2\u25c1orne\xf2\u1d08ard;\u696bri;\u65fa\u0100io\u269f\u26a4dot;\u4140ust\u0100;a\u26ac\u26ad\u63b0che\xbb\u26ad\u0200Eaes\u26bb\u26bd\u26c9\u26d4;\u6268p\u0100;p\u26c3\u26c4\u6a89rox\xbb\u26c4\u0100;q\u26ce\u26cf\u6a87\u0100;q\u26ce\u26bbim;\u62e6\u0400abnoptwz\u26e9\u26f4\u26f7\u271a\u272f\u2741\u2747\u2750\u0100nr\u26ee\u26f1g;\u67ecr;\u61fdr\xeb\u08c1g\u0180lmr\u26ff\u270d\u2714eft\u0100ar\u09e6\u2707ight\xe1\u09f2apsto;\u67fcight\xe1\u09fdparrow\u0100lr\u2725\u2729ef\xf4\u24edight;\u61ac\u0180afl\u2736\u2739\u273dr;\u6985;\uc000\ud835\udd5dus;\u6a2dimes;\u6a34\u0161\u274b\u274fst;\u6217\xe1\u134e\u0180;ef\u2757\u2758\u1800\u65cange\xbb\u2758ar\u0100;l\u2764\u2765\u4028t;\u6993\u0280achmt\u2773\u2776\u277c\u2785\u2787r\xf2\u08a8orne\xf2\u1d8car\u0100;d\u0f98\u2783;\u696d;\u600eri;\u62bf\u0300achiqt\u2798\u279d\u0a40\u27a2\u27ae\u27bbquo;\u6039r;\uc000\ud835\udcc1m\u0180;eg\u09b2\u27aa\u27ac;\u6a8d;\u6a8f\u0100bu\u252a\u27b3o\u0100;r\u0e1f\u27b9;\u601arok;\u4142\u8400<;cdhilqr\u082b\u27d2\u2639\u27dc\u27e0\u27e5\u27ea\u27f0\u0100ci\u27d7\u27d9;\u6aa6r;\u6a79re\xe5\u25f2mes;\u62c9arr;\u6976uest;\u6a7b\u0100Pi\u27f5\u27f9ar;\u6996\u0180;ef\u2800\u092d\u181b\u65c3r\u0100du\u2807\u280dshar;\u694ahar;\u6966\u0100en\u2817\u2821rtneqq;\uc000\u2268\ufe00\xc5\u281e\u0700Dacdefhilnopsu\u2840\u2845\u2882\u288e\u2893\u28a0\u28a5\u28a8\u28da\u28e2\u28e4\u0a83\u28f3\u2902Dot;\u623a\u0200clpr\u284e\u2852\u2863\u287dr\u803b\xaf\u40af\u0100et\u2857\u2859;\u6642\u0100;e\u285e\u285f\u6720se\xbb\u285f\u0100;s\u103b\u2868to\u0200;dlu\u103b\u2873\u2877\u287bow\xee\u048cef\xf4\u090f\xf0\u13d1ker;\u65ae\u0100oy\u2887\u288cmma;\u6a29;\u443cash;\u6014asuredangle\xbb\u1626r;\uc000\ud835\udd2ao;\u6127\u0180cdn\u28af\u28b4\u28c9ro\u803b\xb5\u40b5\u0200;acd\u1464\u28bd\u28c0\u28c4s\xf4\u16a7ir;\u6af0ot\u80bb\xb7\u01b5us\u0180;bd\u28d2\u1903\u28d3\u6212\u0100;u\u1d3c\u28d8;\u6a2a\u0163\u28de\u28e1p;\u6adb\xf2\u2212\xf0\u0a81\u0100dp\u28e9\u28eeels;\u62a7f;\uc000\ud835\udd5e\u0100ct\u28f8\u28fdr;\uc000\ud835\udcc2pos\xbb\u159d\u0180;lm\u2909\u290a\u290d\u43bctimap;\u62b8\u0c00GLRVabcdefghijlmoprstuvw\u2942\u2953\u297e\u2989\u2998\u29da\u29e9\u2a15\u2a1a\u2a58\u2a5d\u2a83\u2a95\u2aa4\u2aa8\u2b04\u2b07\u2b44\u2b7f\u2bae\u2c34\u2c67\u2c7c\u2ce9\u0100gt\u2947\u294b;\uc000\u22d9\u0338\u0100;v\u2950\u0bcf\uc000\u226b\u20d2\u0180elt\u295a\u2972\u2976ft\u0100ar\u2961\u2967rrow;\u61cdightarrow;\u61ce;\uc000\u22d8\u0338\u0100;v\u297b\u0c47\uc000\u226a\u20d2ightarrow;\u61cf\u0100Dd\u298e\u2993ash;\u62afash;\u62ae\u0280bcnpt\u29a3\u29a7\u29ac\u29b1\u29ccla\xbb\u02deute;\u4144g;\uc000\u2220\u20d2\u0280;Eiop\u0d84\u29bc\u29c0\u29c5\u29c8;\uc000\u2a70\u0338d;\uc000\u224b\u0338s;\u4149ro\xf8\u0d84ur\u0100;a\u29d3\u29d4\u666el\u0100;s\u29d3\u0b38\u01f3\u29df\0\u29e3p\u80bb\xa0\u0b37mp\u0100;e\u0bf9\u0c00\u0280aeouy\u29f4\u29fe\u2a03\u2a10\u2a13\u01f0\u29f9\0\u29fb;\u6a43on;\u4148dil;\u4146ng\u0100;d\u0d7e\u2a0aot;\uc000\u2a6d\u0338p;\u6a42;\u443dash;\u6013\u0380;Aadqsx\u0b92\u2a29\u2a2d\u2a3b\u2a41\u2a45\u2a50rr;\u61d7r\u0100hr\u2a33\u2a36k;\u6924\u0100;o\u13f2\u13f0ot;\uc000\u2250\u0338ui\xf6\u0b63\u0100ei\u2a4a\u2a4ear;\u6928\xed\u0b98ist\u0100;s\u0ba0\u0b9fr;\uc000\ud835\udd2b\u0200Eest\u0bc5\u2a66\u2a79\u2a7c\u0180;qs\u0bbc\u2a6d\u0be1\u0180;qs\u0bbc\u0bc5\u2a74lan\xf4\u0be2i\xed\u0bea\u0100;r\u0bb6\u2a81\xbb\u0bb7\u0180Aap\u2a8a\u2a8d\u2a91r\xf2\u2971rr;\u61aear;\u6af2\u0180;sv\u0f8d\u2a9c\u0f8c\u0100;d\u2aa1\u2aa2\u62fc;\u62facy;\u445a\u0380AEadest\u2ab7\u2aba\u2abe\u2ac2\u2ac5\u2af6\u2af9r\xf2\u2966;\uc000\u2266\u0338rr;\u619ar;\u6025\u0200;fqs\u0c3b\u2ace\u2ae3\u2aeft\u0100ar\u2ad4\u2ad9rro\xf7\u2ac1ightarro\xf7\u2a90\u0180;qs\u0c3b\u2aba\u2aealan\xf4\u0c55\u0100;s\u0c55\u2af4\xbb\u0c36i\xed\u0c5d\u0100;r\u0c35\u2afei\u0100;e\u0c1a\u0c25i\xe4\u0d90\u0100pt\u2b0c\u2b11f;\uc000\ud835\udd5f\u8180\xac;in\u2b19\u2b1a\u2b36\u40acn\u0200;Edv\u0b89\u2b24\u2b28\u2b2e;\uc000\u22f9\u0338ot;\uc000\u22f5\u0338\u01e1\u0b89\u2b33\u2b35;\u62f7;\u62f6i\u0100;v\u0cb8\u2b3c\u01e1\u0cb8\u2b41\u2b43;\u62fe;\u62fd\u0180aor\u2b4b\u2b63\u2b69r\u0200;ast\u0b7b\u2b55\u2b5a\u2b5flle\xec\u0b7bl;\uc000\u2afd\u20e5;\uc000\u2202\u0338lint;\u6a14\u0180;ce\u0c92\u2b70\u2b73u\xe5\u0ca5\u0100;c\u0c98\u2b78\u0100;e\u0c92\u2b7d\xf1\u0c98\u0200Aait\u2b88\u2b8b\u2b9d\u2ba7r\xf2\u2988rr\u0180;cw\u2b94\u2b95\u2b99\u619b;\uc000\u2933\u0338;\uc000\u219d\u0338ghtarrow\xbb\u2b95ri\u0100;e\u0ccb\u0cd6\u0380chimpqu\u2bbd\u2bcd\u2bd9\u2b04\u0b78\u2be4\u2bef\u0200;cer\u0d32\u2bc6\u0d37\u2bc9u\xe5\u0d45;\uc000\ud835\udcc3ort\u026d\u2b05\0\0\u2bd6ar\xe1\u2b56m\u0100;e\u0d6e\u2bdf\u0100;q\u0d74\u0d73su\u0100bp\u2beb\u2bed\xe5\u0cf8\xe5\u0d0b\u0180bcp\u2bf6\u2c11\u2c19\u0200;Ees\u2bff\u2c00\u0d22\u2c04\u6284;\uc000\u2ac5\u0338et\u0100;e\u0d1b\u2c0bq\u0100;q\u0d23\u2c00c\u0100;e\u0d32\u2c17\xf1\u0d38\u0200;Ees\u2c22\u2c23\u0d5f\u2c27\u6285;\uc000\u2ac6\u0338et\u0100;e\u0d58\u2c2eq\u0100;q\u0d60\u2c23\u0200gilr\u2c3d\u2c3f\u2c45\u2c47\xec\u0bd7lde\u803b\xf1\u40f1\xe7\u0c43iangle\u0100lr\u2c52\u2c5ceft\u0100;e\u0c1a\u2c5a\xf1\u0c26ight\u0100;e\u0ccb\u2c65\xf1\u0cd7\u0100;m\u2c6c\u2c6d\u43bd\u0180;es\u2c74\u2c75\u2c79\u4023ro;\u6116p;\u6007\u0480DHadgilrs\u2c8f\u2c94\u2c99\u2c9e\u2ca3\u2cb0\u2cb6\u2cd3\u2ce3ash;\u62adarr;\u6904p;\uc000\u224d\u20d2ash;\u62ac\u0100et\u2ca8\u2cac;\uc000\u2265\u20d2;\uc000>\u20d2nfin;\u69de\u0180Aet\u2cbd\u2cc1\u2cc5rr;\u6902;\uc000\u2264\u20d2\u0100;r\u2cca\u2ccd\uc000<\u20d2ie;\uc000\u22b4\u20d2\u0100At\u2cd8\u2cdcrr;\u6903rie;\uc000\u22b5\u20d2im;\uc000\u223c\u20d2\u0180Aan\u2cf0\u2cf4\u2d02rr;\u61d6r\u0100hr\u2cfa\u2cfdk;\u6923\u0100;o\u13e7\u13e5ear;\u6927\u1253\u1a95\0\0\0\0\0\0\0\0\0\0\0\0\0\u2d2d\0\u2d38\u2d48\u2d60\u2d65\u2d72\u2d84\u1b07\0\0\u2d8d\u2dab\0\u2dc8\u2dce\0\u2ddc\u2e19\u2e2b\u2e3e\u2e43\u0100cs\u2d31\u1a97ute\u803b\xf3\u40f3\u0100iy\u2d3c\u2d45r\u0100;c\u1a9e\u2d42\u803b\xf4\u40f4;\u443e\u0280abios\u1aa0\u2d52\u2d57\u01c8\u2d5alac;\u4151v;\u6a38old;\u69bclig;\u4153\u0100cr\u2d69\u2d6dir;\u69bf;\uc000\ud835\udd2c\u036f\u2d79\0\0\u2d7c\0\u2d82n;\u42dbave\u803b\xf2\u40f2;\u69c1\u0100bm\u2d88\u0df4ar;\u69b5\u0200acit\u2d95\u2d98\u2da5\u2da8r\xf2\u1a80\u0100ir\u2d9d\u2da0r;\u69beoss;\u69bbn\xe5\u0e52;\u69c0\u0180aei\u2db1\u2db5\u2db9cr;\u414dga;\u43c9\u0180cdn\u2dc0\u2dc5\u01cdron;\u43bf;\u69b6pf;\uc000\ud835\udd60\u0180ael\u2dd4\u2dd7\u01d2r;\u69b7rp;\u69b9\u0380;adiosv\u2dea\u2deb\u2dee\u2e08\u2e0d\u2e10\u2e16\u6228r\xf2\u1a86\u0200;efm\u2df7\u2df8\u2e02\u2e05\u6a5dr\u0100;o\u2dfe\u2dff\u6134f\xbb\u2dff\u803b\xaa\u40aa\u803b\xba\u40bagof;\u62b6r;\u6a56lope;\u6a57;\u6a5b\u0180clo\u2e1f\u2e21\u2e27\xf2\u2e01ash\u803b\xf8\u40f8l;\u6298i\u016c\u2e2f\u2e34de\u803b\xf5\u40f5es\u0100;a\u01db\u2e3as;\u6a36ml\u803b\xf6\u40f6bar;\u633d\u0ae1\u2e5e\0\u2e7d\0\u2e80\u2e9d\0\u2ea2\u2eb9\0\0\u2ecb\u0e9c\0\u2f13\0\0\u2f2b\u2fbc\0\u2fc8r\u0200;ast\u0403\u2e67\u2e72\u0e85\u8100\xb6;l\u2e6d\u2e6e\u40b6le\xec\u0403\u0269\u2e78\0\0\u2e7bm;\u6af3;\u6afdy;\u443fr\u0280cimpt\u2e8b\u2e8f\u2e93\u1865\u2e97nt;\u4025od;\u402eil;\u6030enk;\u6031r;\uc000\ud835\udd2d\u0180imo\u2ea8\u2eb0\u2eb4\u0100;v\u2ead\u2eae\u43c6;\u43d5ma\xf4\u0a76ne;\u660e\u0180;tv\u2ebf\u2ec0\u2ec8\u43c0chfork\xbb\u1ffd;\u43d6\u0100au\u2ecf\u2edfn\u0100ck\u2ed5\u2eddk\u0100;h\u21f4\u2edb;\u610e\xf6\u21f4s\u0480;abcdemst\u2ef3\u2ef4\u1908\u2ef9\u2efd\u2f04\u2f06\u2f0a\u2f0e\u402bcir;\u6a23ir;\u6a22\u0100ou\u1d40\u2f02;\u6a25;\u6a72n\u80bb\xb1\u0e9dim;\u6a26wo;\u6a27\u0180ipu\u2f19\u2f20\u2f25ntint;\u6a15f;\uc000\ud835\udd61nd\u803b\xa3\u40a3\u0500;Eaceinosu\u0ec8\u2f3f\u2f41\u2f44\u2f47\u2f81\u2f89\u2f92\u2f7e\u2fb6;\u6ab3p;\u6ab7u\xe5\u0ed9\u0100;c\u0ece\u2f4c\u0300;acens\u0ec8\u2f59\u2f5f\u2f66\u2f68\u2f7eppro\xf8\u2f43urlye\xf1\u0ed9\xf1\u0ece\u0180aes\u2f6f\u2f76\u2f7approx;\u6ab9qq;\u6ab5im;\u62e8i\xed\u0edfme\u0100;s\u2f88\u0eae\u6032\u0180Eas\u2f78\u2f90\u2f7a\xf0\u2f75\u0180dfp\u0eec\u2f99\u2faf\u0180als\u2fa0\u2fa5\u2faalar;\u632eine;\u6312urf;\u6313\u0100;t\u0efb\u2fb4\xef\u0efbrel;\u62b0\u0100ci\u2fc0\u2fc5r;\uc000\ud835\udcc5;\u43c8ncsp;\u6008\u0300fiopsu\u2fda\u22e2\u2fdf\u2fe5\u2feb\u2ff1r;\uc000\ud835\udd2epf;\uc000\ud835\udd62rime;\u6057cr;\uc000\ud835\udcc6\u0180aeo\u2ff8\u3009\u3013t\u0100ei\u2ffe\u3005rnion\xf3\u06b0nt;\u6a16st\u0100;e\u3010\u3011\u403f\xf1\u1f19\xf4\u0f14\u0a80ABHabcdefhilmnoprstux\u3040\u3051\u3055\u3059\u30e0\u310e\u312b\u3147\u3162\u3172\u318e\u3206\u3215\u3224\u3229\u3258\u326e\u3272\u3290\u32b0\u32b7\u0180art\u3047\u304a\u304cr\xf2\u10b3\xf2\u03ddail;\u691car\xf2\u1c65ar;\u6964\u0380cdenqrt\u3068\u3075\u3078\u307f\u308f\u3094\u30cc\u0100eu\u306d\u3071;\uc000\u223d\u0331te;\u4155i\xe3\u116emptyv;\u69b3g\u0200;del\u0fd1\u3089\u308b\u308d;\u6992;\u69a5\xe5\u0fd1uo\u803b\xbb\u40bbr\u0580;abcfhlpstw\u0fdc\u30ac\u30af\u30b7\u30b9\u30bc\u30be\u30c0\u30c3\u30c7\u30cap;\u6975\u0100;f\u0fe0\u30b4s;\u6920;\u6933s;\u691e\xeb\u225d\xf0\u272el;\u6945im;\u6974l;\u61a3;\u619d\u0100ai\u30d1\u30d5il;\u691ao\u0100;n\u30db\u30dc\u6236al\xf3\u0f1e\u0180abr\u30e7\u30ea\u30eer\xf2\u17e5rk;\u6773\u0100ak\u30f3\u30fdc\u0100ek\u30f9\u30fb;\u407d;\u405d\u0100es\u3102\u3104;\u698cl\u0100du\u310a\u310c;\u698e;\u6990\u0200aeuy\u3117\u311c\u3127\u3129ron;\u4159\u0100di\u3121\u3125il;\u4157\xec\u0ff2\xe2\u30fa;\u4440\u0200clqs\u3134\u3137\u313d\u3144a;\u6937dhar;\u6969uo\u0100;r\u020e\u020dh;\u61b3\u0180acg\u314e\u315f\u0f44l\u0200;ips\u0f78\u3158\u315b\u109cn\xe5\u10bbar\xf4\u0fa9t;\u65ad\u0180ilr\u3169\u1023\u316esht;\u697d;\uc000\ud835\udd2f\u0100ao\u3177\u3186r\u0100du\u317d\u317f\xbb\u047b\u0100;l\u1091\u3184;\u696c\u0100;v\u318b\u318c\u43c1;\u43f1\u0180gns\u3195\u31f9\u31fcht\u0300ahlrst\u31a4\u31b0\u31c2\u31d8\u31e4\u31eerrow\u0100;t\u0fdc\u31ada\xe9\u30c8arpoon\u0100du\u31bb\u31bfow\xee\u317ep\xbb\u1092eft\u0100ah\u31ca\u31d0rrow\xf3\u0feaarpoon\xf3\u0551ightarrows;\u61c9quigarro\xf7\u30cbhreetimes;\u62ccg;\u42daingdotse\xf1\u1f32\u0180ahm\u320d\u3210\u3213r\xf2\u0feaa\xf2\u0551;\u600foust\u0100;a\u321e\u321f\u63b1che\xbb\u321fmid;\u6aee\u0200abpt\u3232\u323d\u3240\u3252\u0100nr\u3237\u323ag;\u67edr;\u61fer\xeb\u1003\u0180afl\u3247\u324a\u324er;\u6986;\uc000\ud835\udd63us;\u6a2eimes;\u6a35\u0100ap\u325d\u3267r\u0100;g\u3263\u3264\u4029t;\u6994olint;\u6a12ar\xf2\u31e3\u0200achq\u327b\u3280\u10bc\u3285quo;\u603ar;\uc000\ud835\udcc7\u0100bu\u30fb\u328ao\u0100;r\u0214\u0213\u0180hir\u3297\u329b\u32a0re\xe5\u31f8mes;\u62cai\u0200;efl\u32aa\u1059\u1821\u32ab\u65b9tri;\u69celuhar;\u6968;\u611e\u0d61\u32d5\u32db\u32df\u332c\u3338\u3371\0\u337a\u33a4\0\0\u33ec\u33f0\0\u3428\u3448\u345a\u34ad\u34b1\u34ca\u34f1\0\u3616\0\0\u3633cute;\u415bqu\xef\u27ba\u0500;Eaceinpsy\u11ed\u32f3\u32f5\u32ff\u3302\u330b\u330f\u331f\u3326\u3329;\u6ab4\u01f0\u32fa\0\u32fc;\u6ab8on;\u4161u\xe5\u11fe\u0100;d\u11f3\u3307il;\u415frc;\u415d\u0180Eas\u3316\u3318\u331b;\u6ab6p;\u6abaim;\u62e9olint;\u6a13i\xed\u1204;\u4441ot\u0180;be\u3334\u1d47\u3335\u62c5;\u6a66\u0380Aacmstx\u3346\u334a\u3357\u335b\u335e\u3363\u336drr;\u61d8r\u0100hr\u3350\u3352\xeb\u2228\u0100;o\u0a36\u0a34t\u803b\xa7\u40a7i;\u403bwar;\u6929m\u0100in\u3369\xf0nu\xf3\xf1t;\u6736r\u0100;o\u3376\u2055\uc000\ud835\udd30\u0200acoy\u3382\u3386\u3391\u33a0rp;\u666f\u0100hy\u338b\u338fcy;\u4449;\u4448rt\u026d\u3399\0\0\u339ci\xe4\u1464ara\xec\u2e6f\u803b\xad\u40ad\u0100gm\u33a8\u33b4ma\u0180;fv\u33b1\u33b2\u33b2\u43c3;\u43c2\u0400;deglnpr\u12ab\u33c5\u33c9\u33ce\u33d6\u33de\u33e1\u33e6ot;\u6a6a\u0100;q\u12b1\u12b0\u0100;E\u33d3\u33d4\u6a9e;\u6aa0\u0100;E\u33db\u33dc\u6a9d;\u6a9fe;\u6246lus;\u6a24arr;\u6972ar\xf2\u113d\u0200aeit\u33f8\u3408\u340f\u3417\u0100ls\u33fd\u3404lsetm\xe9\u336ahp;\u6a33parsl;\u69e4\u0100dl\u1463\u3414e;\u6323\u0100;e\u341c\u341d\u6aaa\u0100;s\u3422\u3423\u6aac;\uc000\u2aac\ufe00\u0180flp\u342e\u3433\u3442tcy;\u444c\u0100;b\u3438\u3439\u402f\u0100;a\u343e\u343f\u69c4r;\u633ff;\uc000\ud835\udd64a\u0100dr\u344d\u0402es\u0100;u\u3454\u3455\u6660it\xbb\u3455\u0180csu\u3460\u3479\u349f\u0100au\u3465\u346fp\u0100;s\u1188\u346b;\uc000\u2293\ufe00p\u0100;s\u11b4\u3475;\uc000\u2294\ufe00u\u0100bp\u347f\u348f\u0180;es\u1197\u119c\u3486et\u0100;e\u1197\u348d\xf1\u119d\u0180;es\u11a8\u11ad\u3496et\u0100;e\u11a8\u349d\xf1\u11ae\u0180;af\u117b\u34a6\u05b0r\u0165\u34ab\u05b1\xbb\u117car\xf2\u1148\u0200cemt\u34b9\u34be\u34c2\u34c5r;\uc000\ud835\udcc8tm\xee\xf1i\xec\u3415ar\xe6\u11be\u0100ar\u34ce\u34d5r\u0100;f\u34d4\u17bf\u6606\u0100an\u34da\u34edight\u0100ep\u34e3\u34eapsilo\xee\u1ee0h\xe9\u2eafs\xbb\u2852\u0280bcmnp\u34fb\u355e\u1209\u358b\u358e\u0480;Edemnprs\u350e\u350f\u3511\u3515\u351e\u3523\u352c\u3531\u3536\u6282;\u6ac5ot;\u6abd\u0100;d\u11da\u351aot;\u6ac3ult;\u6ac1\u0100Ee\u3528\u352a;\u6acb;\u628alus;\u6abfarr;\u6979\u0180eiu\u353d\u3552\u3555t\u0180;en\u350e\u3545\u354bq\u0100;q\u11da\u350feq\u0100;q\u352b\u3528m;\u6ac7\u0100bp\u355a\u355c;\u6ad5;\u6ad3c\u0300;acens\u11ed\u356c\u3572\u3579\u357b\u3326ppro\xf8\u32faurlye\xf1\u11fe\xf1\u11f3\u0180aes\u3582\u3588\u331bppro\xf8\u331aq\xf1\u3317g;\u666a\u0680123;Edehlmnps\u35a9\u35ac\u35af\u121c\u35b2\u35b4\u35c0\u35c9\u35d5\u35da\u35df\u35e8\u35ed\u803b\xb9\u40b9\u803b\xb2\u40b2\u803b\xb3\u40b3;\u6ac6\u0100os\u35b9\u35bct;\u6abeub;\u6ad8\u0100;d\u1222\u35c5ot;\u6ac4s\u0100ou\u35cf\u35d2l;\u67c9b;\u6ad7arr;\u697bult;\u6ac2\u0100Ee\u35e4\u35e6;\u6acc;\u628blus;\u6ac0\u0180eiu\u35f4\u3609\u360ct\u0180;en\u121c\u35fc\u3602q\u0100;q\u1222\u35b2eq\u0100;q\u35e7\u35e4m;\u6ac8\u0100bp\u3611\u3613;\u6ad4;\u6ad6\u0180Aan\u361c\u3620\u362drr;\u61d9r\u0100hr\u3626\u3628\xeb\u222e\u0100;o\u0a2b\u0a29war;\u692alig\u803b\xdf\u40df\u0be1\u3651\u365d\u3660\u12ce\u3673\u3679\0\u367e\u36c2\0\0\0\0\0\u36db\u3703\0\u3709\u376c\0\0\0\u3787\u0272\u3656\0\0\u365bget;\u6316;\u43c4r\xeb\u0e5f\u0180aey\u3666\u366b\u3670ron;\u4165dil;\u4163;\u4442lrec;\u6315r;\uc000\ud835\udd31\u0200eiko\u3686\u369d\u36b5\u36bc\u01f2\u368b\0\u3691e\u01004f\u1284\u1281a\u0180;sv\u3698\u3699\u369b\u43b8ym;\u43d1\u0100cn\u36a2\u36b2k\u0100as\u36a8\u36aeppro\xf8\u12c1im\xbb\u12acs\xf0\u129e\u0100as\u36ba\u36ae\xf0\u12c1rn\u803b\xfe\u40fe\u01ec\u031f\u36c6\u22e7es\u8180\xd7;bd\u36cf\u36d0\u36d8\u40d7\u0100;a\u190f\u36d5r;\u6a31;\u6a30\u0180eps\u36e1\u36e3\u3700\xe1\u2a4d\u0200;bcf\u0486\u36ec\u36f0\u36f4ot;\u6336ir;\u6af1\u0100;o\u36f9\u36fc\uc000\ud835\udd65rk;\u6ada\xe1\u3362rime;\u6034\u0180aip\u370f\u3712\u3764d\xe5\u1248\u0380adempst\u3721\u374d\u3740\u3751\u3757\u375c\u375fngle\u0280;dlqr\u3730\u3731\u3736\u3740\u3742\u65b5own\xbb\u1dbbeft\u0100;e\u2800\u373e\xf1\u092e;\u625cight\u0100;e\u32aa\u374b\xf1\u105aot;\u65ecinus;\u6a3alus;\u6a39b;\u69cdime;\u6a3bezium;\u63e2\u0180cht\u3772\u377d\u3781\u0100ry\u3777\u377b;\uc000\ud835\udcc9;\u4446cy;\u445brok;\u4167\u0100io\u378b\u378ex\xf4\u1777head\u0100lr\u3797\u37a0eftarro\xf7\u084fightarrow\xbb\u0f5d\u0900AHabcdfghlmoprstuw\u37d0\u37d3\u37d7\u37e4\u37f0\u37fc\u380e\u381c\u3823\u3834\u3851\u385d\u386b\u38a9\u38cc\u38d2\u38ea\u38f6r\xf2\u03edar;\u6963\u0100cr\u37dc\u37e2ute\u803b\xfa\u40fa\xf2\u1150r\u01e3\u37ea\0\u37edy;\u445eve;\u416d\u0100iy\u37f5\u37farc\u803b\xfb\u40fb;\u4443\u0180abh\u3803\u3806\u380br\xf2\u13adlac;\u4171a\xf2\u13c3\u0100ir\u3813\u3818sht;\u697e;\uc000\ud835\udd32rave\u803b\xf9\u40f9\u0161\u3827\u3831r\u0100lr\u382c\u382e\xbb\u0957\xbb\u1083lk;\u6580\u0100ct\u3839\u384d\u026f\u383f\0\0\u384arn\u0100;e\u3845\u3846\u631cr\xbb\u3846op;\u630fri;\u65f8\u0100al\u3856\u385acr;\u416b\u80bb\xa8\u0349\u0100gp\u3862\u3866on;\u4173f;\uc000\ud835\udd66\u0300adhlsu\u114b\u3878\u387d\u1372\u3891\u38a0own\xe1\u13b3arpoon\u0100lr\u3888\u388cef\xf4\u382digh\xf4\u382fi\u0180;hl\u3899\u389a\u389c\u43c5\xbb\u13faon\xbb\u389aparrows;\u61c8\u0180cit\u38b0\u38c4\u38c8\u026f\u38b6\0\0\u38c1rn\u0100;e\u38bc\u38bd\u631dr\xbb\u38bdop;\u630eng;\u416fri;\u65f9cr;\uc000\ud835\udcca\u0180dir\u38d9\u38dd\u38e2ot;\u62f0lde;\u4169i\u0100;f\u3730\u38e8\xbb\u1813\u0100am\u38ef\u38f2r\xf2\u38a8l\u803b\xfc\u40fcangle;\u69a7\u0780ABDacdeflnoprsz\u391c\u391f\u3929\u392d\u39b5\u39b8\u39bd\u39df\u39e4\u39e8\u39f3\u39f9\u39fd\u3a01\u3a20r\xf2\u03f7ar\u0100;v\u3926\u3927\u6ae8;\u6ae9as\xe8\u03e1\u0100nr\u3932\u3937grt;\u699c\u0380eknprst\u34e3\u3946\u394b\u3952\u395d\u3964\u3996app\xe1\u2415othin\xe7\u1e96\u0180hir\u34eb\u2ec8\u3959op\xf4\u2fb5\u0100;h\u13b7\u3962\xef\u318d\u0100iu\u3969\u396dgm\xe1\u33b3\u0100bp\u3972\u3984setneq\u0100;q\u397d\u3980\uc000\u228a\ufe00;\uc000\u2acb\ufe00setneq\u0100;q\u398f\u3992\uc000\u228b\ufe00;\uc000\u2acc\ufe00\u0100hr\u399b\u399fet\xe1\u369ciangle\u0100lr\u39aa\u39afeft\xbb\u0925ight\xbb\u1051y;\u4432ash\xbb\u1036\u0180elr\u39c4\u39d2\u39d7\u0180;be\u2dea\u39cb\u39cfar;\u62bbq;\u625alip;\u62ee\u0100bt\u39dc\u1468a\xf2\u1469r;\uc000\ud835\udd33tr\xe9\u39aesu\u0100bp\u39ef\u39f1\xbb\u0d1c\xbb\u0d59pf;\uc000\ud835\udd67ro\xf0\u0efbtr\xe9\u39b4\u0100cu\u3a06\u3a0br;\uc000\ud835\udccb\u0100bp\u3a10\u3a18n\u0100Ee\u3980\u3a16\xbb\u397en\u0100Ee\u3992\u3a1e\xbb\u3990igzag;\u699a\u0380cefoprs\u3a36\u3a3b\u3a56\u3a5b\u3a54\u3a61\u3a6airc;\u4175\u0100di\u3a40\u3a51\u0100bg\u3a45\u3a49ar;\u6a5fe\u0100;q\u15fa\u3a4f;\u6259erp;\u6118r;\uc000\ud835\udd34pf;\uc000\ud835\udd68\u0100;e\u1479\u3a66at\xe8\u1479cr;\uc000\ud835\udccc\u0ae3\u178e\u3a87\0\u3a8b\0\u3a90\u3a9b\0\0\u3a9d\u3aa8\u3aab\u3aaf\0\0\u3ac3\u3ace\0\u3ad8\u17dc\u17dftr\xe9\u17d1r;\uc000\ud835\udd35\u0100Aa\u3a94\u3a97r\xf2\u03c3r\xf2\u09f6;\u43be\u0100Aa\u3aa1\u3aa4r\xf2\u03b8r\xf2\u09eba\xf0\u2713is;\u62fb\u0180dpt\u17a4\u3ab5\u3abe\u0100fl\u3aba\u17a9;\uc000\ud835\udd69im\xe5\u17b2\u0100Aa\u3ac7\u3acar\xf2\u03cer\xf2\u0a01\u0100cq\u3ad2\u17b8r;\uc000\ud835\udccd\u0100pt\u17d6\u3adcr\xe9\u17d4\u0400acefiosu\u3af0\u3afd\u3b08\u3b0c\u3b11\u3b15\u3b1b\u3b21c\u0100uy\u3af6\u3afbte\u803b\xfd\u40fd;\u444f\u0100iy\u3b02\u3b06rc;\u4177;\u444bn\u803b\xa5\u40a5r;\uc000\ud835\udd36cy;\u4457pf;\uc000\ud835\udd6acr;\uc000\ud835\udcce\u0100cm\u3b26\u3b29y;\u444el\u803b\xff\u40ff\u0500acdefhiosw\u3b42\u3b48\u3b54\u3b58\u3b64\u3b69\u3b6d\u3b74\u3b7a\u3b80cute;\u417a\u0100ay\u3b4d\u3b52ron;\u417e;\u4437ot;\u417c\u0100et\u3b5d\u3b61tr\xe6\u155fa;\u43b6r;\uc000\ud835\udd37cy;\u4436grarr;\u61ddpf;\uc000\ud835\udd6bcr;\uc000\ud835\udccf\u0100jn\u3b85\u3b87;\u600dj;\u600c" + .split("") + .map((c) => c.charCodeAt(0)))); +//# sourceMappingURL=decode-data-html.js.map +;// CONCATENATED MODULE: ./node_modules/entities/lib/esm/generated/decode-data-xml.js +// Generated using scripts/write-decode-map.ts +/* harmony default export */ const decode_data_xml = (new Uint16Array( +// prettier-ignore +"\u0200aglq\t\x15\x18\x1b\u026d\x0f\0\0\x12p;\u4026os;\u4027t;\u403et;\u403cuot;\u4022" + .split("") + .map((c) => c.charCodeAt(0)))); +//# sourceMappingURL=decode-data-xml.js.map +;// CONCATENATED MODULE: ./node_modules/entities/lib/esm/decode_codepoint.js +// Adapted from https://github.com/mathiasbynens/he/blob/36afe179392226cf1b6ccdb16ebbb7a5a844d93a/src/he.js#L106-L134 +var _a; +const decodeMap = new Map([ + [0, 65533], + // C1 Unicode control character reference replacements + [128, 8364], + [130, 8218], + [131, 402], + [132, 8222], + [133, 8230], + [134, 8224], + [135, 8225], + [136, 710], + [137, 8240], + [138, 352], + [139, 8249], + [140, 338], + [142, 381], + [145, 8216], + [146, 8217], + [147, 8220], + [148, 8221], + [149, 8226], + [150, 8211], + [151, 8212], + [152, 732], + [153, 8482], + [154, 353], + [155, 8250], + [156, 339], + [158, 382], + [159, 376], +]); +/** + * Polyfill for `String.fromCodePoint`. It is used to create a string from a Unicode code point. + */ +const fromCodePoint = +// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition, node/no-unsupported-features/es-builtins +(_a = String.fromCodePoint) !== null && _a !== void 0 ? _a : function (codePoint) { + let output = ""; + if (codePoint > 0xffff) { + codePoint -= 0x10000; + output += String.fromCharCode(((codePoint >>> 10) & 0x3ff) | 0xd800); + codePoint = 0xdc00 | (codePoint & 0x3ff); + } + output += String.fromCharCode(codePoint); + return output; +}; +/** + * Replace the given code point with a replacement character if it is a + * surrogate or is outside the valid range. Otherwise return the code + * point unchanged. + */ +function replaceCodePoint(codePoint) { + var _a; + if ((codePoint >= 0xd800 && codePoint <= 0xdfff) || codePoint > 0x10ffff) { + return 0xfffd; + } + return (_a = decodeMap.get(codePoint)) !== null && _a !== void 0 ? _a : codePoint; +} +/** + * Replace the code point if relevant, then convert it to a string. + * + * @deprecated Use `fromCodePoint(replaceCodePoint(codePoint))` instead. + * @param codePoint The code point to decode. + * @returns The decoded code point. + */ +function decodeCodePoint(codePoint) { + return fromCodePoint(replaceCodePoint(codePoint)); +} +//# sourceMappingURL=decode_codepoint.js.map +;// CONCATENATED MODULE: ./node_modules/entities/lib/esm/decode.js + + + +// Re-export for use by eg. htmlparser2 + + +var CharCodes; +(function (CharCodes) { + CharCodes[CharCodes["NUM"] = 35] = "NUM"; + CharCodes[CharCodes["SEMI"] = 59] = "SEMI"; + CharCodes[CharCodes["EQUALS"] = 61] = "EQUALS"; + CharCodes[CharCodes["ZERO"] = 48] = "ZERO"; + CharCodes[CharCodes["NINE"] = 57] = "NINE"; + CharCodes[CharCodes["LOWER_A"] = 97] = "LOWER_A"; + CharCodes[CharCodes["LOWER_F"] = 102] = "LOWER_F"; + CharCodes[CharCodes["LOWER_X"] = 120] = "LOWER_X"; + CharCodes[CharCodes["LOWER_Z"] = 122] = "LOWER_Z"; + CharCodes[CharCodes["UPPER_A"] = 65] = "UPPER_A"; + CharCodes[CharCodes["UPPER_F"] = 70] = "UPPER_F"; + CharCodes[CharCodes["UPPER_Z"] = 90] = "UPPER_Z"; +})(CharCodes || (CharCodes = {})); +/** Bit that needs to be set to convert an upper case ASCII character to lower case */ +const TO_LOWER_BIT = 0b100000; +var BinTrieFlags; +(function (BinTrieFlags) { + BinTrieFlags[BinTrieFlags["VALUE_LENGTH"] = 49152] = "VALUE_LENGTH"; + BinTrieFlags[BinTrieFlags["BRANCH_LENGTH"] = 16256] = "BRANCH_LENGTH"; + BinTrieFlags[BinTrieFlags["JUMP_TABLE"] = 127] = "JUMP_TABLE"; +})(BinTrieFlags || (BinTrieFlags = {})); +function isNumber(code) { + return code >= CharCodes.ZERO && code <= CharCodes.NINE; +} +function isHexadecimalCharacter(code) { + return ((code >= CharCodes.UPPER_A && code <= CharCodes.UPPER_F) || + (code >= CharCodes.LOWER_A && code <= CharCodes.LOWER_F)); +} +function isAsciiAlphaNumeric(code) { + return ((code >= CharCodes.UPPER_A && code <= CharCodes.UPPER_Z) || + (code >= CharCodes.LOWER_A && code <= CharCodes.LOWER_Z) || + isNumber(code)); +} +/** + * Checks if the given character is a valid end character for an entity in an attribute. + * + * Attribute values that aren't terminated properly aren't parsed, and shouldn't lead to a parser error. + * See the example in https://html.spec.whatwg.org/multipage/parsing.html#named-character-reference-state + */ +function isEntityInAttributeInvalidEnd(code) { + return code === CharCodes.EQUALS || isAsciiAlphaNumeric(code); +} +var EntityDecoderState; +(function (EntityDecoderState) { + EntityDecoderState[EntityDecoderState["EntityStart"] = 0] = "EntityStart"; + EntityDecoderState[EntityDecoderState["NumericStart"] = 1] = "NumericStart"; + EntityDecoderState[EntityDecoderState["NumericDecimal"] = 2] = "NumericDecimal"; + EntityDecoderState[EntityDecoderState["NumericHex"] = 3] = "NumericHex"; + EntityDecoderState[EntityDecoderState["NamedEntity"] = 4] = "NamedEntity"; +})(EntityDecoderState || (EntityDecoderState = {})); +var DecodingMode; +(function (DecodingMode) { + /** Entities in text nodes that can end with any character. */ + DecodingMode[DecodingMode["Legacy"] = 0] = "Legacy"; + /** Only allow entities terminated with a semicolon. */ + DecodingMode[DecodingMode["Strict"] = 1] = "Strict"; + /** Entities in attributes have limitations on ending characters. */ + DecodingMode[DecodingMode["Attribute"] = 2] = "Attribute"; +})(DecodingMode || (DecodingMode = {})); +/** + * Token decoder with support of writing partial entities. + */ +class EntityDecoder { + constructor( + /** The tree used to decode entities. */ + decodeTree, + /** + * The function that is called when a codepoint is decoded. + * + * For multi-byte named entities, this will be called multiple times, + * with the second codepoint, and the same `consumed` value. + * + * @param codepoint The decoded codepoint. + * @param consumed The number of bytes consumed by the decoder. + */ + emitCodePoint, + /** An object that is used to produce errors. */ + errors) { + this.decodeTree = decodeTree; + this.emitCodePoint = emitCodePoint; + this.errors = errors; + /** The current state of the decoder. */ + this.state = EntityDecoderState.EntityStart; + /** Characters that were consumed while parsing an entity. */ + this.consumed = 1; + /** + * The result of the entity. + * + * Either the result index of a numeric entity, or the codepoint of a + * numeric entity. + */ + this.result = 0; + /** The current index in the decode tree. */ + this.treeIndex = 0; + /** The number of characters that were consumed in excess. */ + this.excess = 1; + /** The mode in which the decoder is operating. */ + this.decodeMode = DecodingMode.Strict; + } + /** Resets the instance to make it reusable. */ + startEntity(decodeMode) { + this.decodeMode = decodeMode; + this.state = EntityDecoderState.EntityStart; + this.result = 0; + this.treeIndex = 0; + this.excess = 1; + this.consumed = 1; + } + /** + * Write an entity to the decoder. This can be called multiple times with partial entities. + * If the entity is incomplete, the decoder will return -1. + * + * Mirrors the implementation of `getDecoder`, but with the ability to stop decoding if the + * entity is incomplete, and resume when the next string is written. + * + * @param string The string containing the entity (or a continuation of the entity). + * @param offset The offset at which the entity begins. Should be 0 if this is not the first call. + * @returns The number of characters that were consumed, or -1 if the entity is incomplete. + */ + write(str, offset) { + switch (this.state) { + case EntityDecoderState.EntityStart: { + if (str.charCodeAt(offset) === CharCodes.NUM) { + this.state = EntityDecoderState.NumericStart; + this.consumed += 1; + return this.stateNumericStart(str, offset + 1); + } + this.state = EntityDecoderState.NamedEntity; + return this.stateNamedEntity(str, offset); + } + case EntityDecoderState.NumericStart: { + return this.stateNumericStart(str, offset); + } + case EntityDecoderState.NumericDecimal: { + return this.stateNumericDecimal(str, offset); + } + case EntityDecoderState.NumericHex: { + return this.stateNumericHex(str, offset); + } + case EntityDecoderState.NamedEntity: { + return this.stateNamedEntity(str, offset); + } + } + } + /** + * Switches between the numeric decimal and hexadecimal states. + * + * Equivalent to the `Numeric character reference state` in the HTML spec. + * + * @param str The string containing the entity (or a continuation of the entity). + * @param offset The current offset. + * @returns The number of characters that were consumed, or -1 if the entity is incomplete. + */ + stateNumericStart(str, offset) { + if (offset >= str.length) { + return -1; + } + if ((str.charCodeAt(offset) | TO_LOWER_BIT) === CharCodes.LOWER_X) { + this.state = EntityDecoderState.NumericHex; + this.consumed += 1; + return this.stateNumericHex(str, offset + 1); + } + this.state = EntityDecoderState.NumericDecimal; + return this.stateNumericDecimal(str, offset); + } + addToNumericResult(str, start, end, base) { + if (start !== end) { + const digitCount = end - start; + this.result = + this.result * Math.pow(base, digitCount) + + parseInt(str.substr(start, digitCount), base); + this.consumed += digitCount; + } + } + /** + * Parses a hexadecimal numeric entity. + * + * Equivalent to the `Hexademical character reference state` in the HTML spec. + * + * @param str The string containing the entity (or a continuation of the entity). + * @param offset The current offset. + * @returns The number of characters that were consumed, or -1 if the entity is incomplete. + */ + stateNumericHex(str, offset) { + const startIdx = offset; + while (offset < str.length) { + const char = str.charCodeAt(offset); + if (isNumber(char) || isHexadecimalCharacter(char)) { + offset += 1; + } + else { + this.addToNumericResult(str, startIdx, offset, 16); + return this.emitNumericEntity(char, 3); + } + } + this.addToNumericResult(str, startIdx, offset, 16); + return -1; + } + /** + * Parses a decimal numeric entity. + * + * Equivalent to the `Decimal character reference state` in the HTML spec. + * + * @param str The string containing the entity (or a continuation of the entity). + * @param offset The current offset. + * @returns The number of characters that were consumed, or -1 if the entity is incomplete. + */ + stateNumericDecimal(str, offset) { + const startIdx = offset; + while (offset < str.length) { + const char = str.charCodeAt(offset); + if (isNumber(char)) { + offset += 1; + } + else { + this.addToNumericResult(str, startIdx, offset, 10); + return this.emitNumericEntity(char, 2); + } + } + this.addToNumericResult(str, startIdx, offset, 10); + return -1; + } + /** + * Validate and emit a numeric entity. + * + * Implements the logic from the `Hexademical character reference start + * state` and `Numeric character reference end state` in the HTML spec. + * + * @param lastCp The last code point of the entity. Used to see if the + * entity was terminated with a semicolon. + * @param expectedLength The minimum number of characters that should be + * consumed. Used to validate that at least one digit + * was consumed. + * @returns The number of characters that were consumed. + */ + emitNumericEntity(lastCp, expectedLength) { + var _a; + // Ensure we consumed at least one digit. + if (this.consumed <= expectedLength) { + (_a = this.errors) === null || _a === void 0 ? void 0 : _a.absenceOfDigitsInNumericCharacterReference(this.consumed); + return 0; + } + // Figure out if this is a legit end of the entity + if (lastCp === CharCodes.SEMI) { + this.consumed += 1; + } + else if (this.decodeMode === DecodingMode.Strict) { + return 0; + } + this.emitCodePoint(replaceCodePoint(this.result), this.consumed); + if (this.errors) { + if (lastCp !== CharCodes.SEMI) { + this.errors.missingSemicolonAfterCharacterReference(); + } + this.errors.validateNumericCharacterReference(this.result); + } + return this.consumed; + } + /** + * Parses a named entity. + * + * Equivalent to the `Named character reference state` in the HTML spec. + * + * @param str The string containing the entity (or a continuation of the entity). + * @param offset The current offset. + * @returns The number of characters that were consumed, or -1 if the entity is incomplete. + */ + stateNamedEntity(str, offset) { + const { decodeTree } = this; + let current = decodeTree[this.treeIndex]; + // The mask is the number of bytes of the value, including the current byte. + let valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14; + for (; offset < str.length; offset++, this.excess++) { + const char = str.charCodeAt(offset); + this.treeIndex = determineBranch(decodeTree, current, this.treeIndex + Math.max(1, valueLength), char); + if (this.treeIndex < 0) { + return this.result === 0 || + // If we are parsing an attribute + (this.decodeMode === DecodingMode.Attribute && + // We shouldn't have consumed any characters after the entity, + (valueLength === 0 || + // And there should be no invalid characters. + isEntityInAttributeInvalidEnd(char))) + ? 0 + : this.emitNotTerminatedNamedEntity(); + } + current = decodeTree[this.treeIndex]; + valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14; + // If the branch is a value, store it and continue + if (valueLength !== 0) { + // If the entity is terminated by a semicolon, we are done. + if (char === CharCodes.SEMI) { + return this.emitNamedEntityData(this.treeIndex, valueLength, this.consumed + this.excess); + } + // If we encounter a non-terminated (legacy) entity while parsing strictly, then ignore it. + if (this.decodeMode !== DecodingMode.Strict) { + this.result = this.treeIndex; + this.consumed += this.excess; + this.excess = 0; + } + } + } + return -1; + } + /** + * Emit a named entity that was not terminated with a semicolon. + * + * @returns The number of characters consumed. + */ + emitNotTerminatedNamedEntity() { + var _a; + const { result, decodeTree } = this; + const valueLength = (decodeTree[result] & BinTrieFlags.VALUE_LENGTH) >> 14; + this.emitNamedEntityData(result, valueLength, this.consumed); + (_a = this.errors) === null || _a === void 0 ? void 0 : _a.missingSemicolonAfterCharacterReference(); + return this.consumed; + } + /** + * Emit a named entity. + * + * @param result The index of the entity in the decode tree. + * @param valueLength The number of bytes in the entity. + * @param consumed The number of characters consumed. + * + * @returns The number of characters consumed. + */ + emitNamedEntityData(result, valueLength, consumed) { + const { decodeTree } = this; + this.emitCodePoint(valueLength === 1 + ? decodeTree[result] & ~BinTrieFlags.VALUE_LENGTH + : decodeTree[result + 1], consumed); + if (valueLength === 3) { + // For multi-byte values, we need to emit the second byte. + this.emitCodePoint(decodeTree[result + 2], consumed); + } + return consumed; + } + /** + * Signal to the parser that the end of the input was reached. + * + * Remaining data will be emitted and relevant errors will be produced. + * + * @returns The number of characters consumed. + */ + end() { + var _a; + switch (this.state) { + case EntityDecoderState.NamedEntity: { + // Emit a named entity if we have one. + return this.result !== 0 && + (this.decodeMode !== DecodingMode.Attribute || + this.result === this.treeIndex) + ? this.emitNotTerminatedNamedEntity() + : 0; + } + // Otherwise, emit a numeric entity if we have one. + case EntityDecoderState.NumericDecimal: { + return this.emitNumericEntity(0, 2); + } + case EntityDecoderState.NumericHex: { + return this.emitNumericEntity(0, 3); + } + case EntityDecoderState.NumericStart: { + (_a = this.errors) === null || _a === void 0 ? void 0 : _a.absenceOfDigitsInNumericCharacterReference(this.consumed); + return 0; + } + case EntityDecoderState.EntityStart: { + // Return 0 if we have no entity. + return 0; + } + } + } +} +/** + * Creates a function that decodes entities in a string. + * + * @param decodeTree The decode tree. + * @returns A function that decodes entities in a string. + */ +function getDecoder(decodeTree) { + let ret = ""; + const decoder = new EntityDecoder(decodeTree, (str) => (ret += fromCodePoint(str))); + return function decodeWithTrie(str, decodeMode) { + let lastIndex = 0; + let offset = 0; + while ((offset = str.indexOf("&", offset)) >= 0) { + ret += str.slice(lastIndex, offset); + decoder.startEntity(decodeMode); + const len = decoder.write(str, + // Skip the "&" + offset + 1); + if (len < 0) { + lastIndex = offset + decoder.end(); + break; + } + lastIndex = offset + len; + // If `len` is 0, skip the current `&` and continue. + offset = len === 0 ? lastIndex + 1 : lastIndex; + } + const result = ret + str.slice(lastIndex); + // Make sure we don't keep a reference to the final string. + ret = ""; + return result; + }; +} +/** + * Determines the branch of the current node that is taken given the current + * character. This function is used to traverse the trie. + * + * @param decodeTree The trie. + * @param current The current node. + * @param nodeIdx The index right after the current node and its value. + * @param char The current character. + * @returns The index of the next node, or -1 if no branch is taken. + */ +function determineBranch(decodeTree, current, nodeIdx, char) { + const branchCount = (current & BinTrieFlags.BRANCH_LENGTH) >> 7; + const jumpOffset = current & BinTrieFlags.JUMP_TABLE; + // Case 1: Single branch encoded in jump offset + if (branchCount === 0) { + return jumpOffset !== 0 && char === jumpOffset ? nodeIdx : -1; + } + // Case 2: Multiple branches encoded in jump table + if (jumpOffset) { + const value = char - jumpOffset; + return value < 0 || value >= branchCount + ? -1 + : decodeTree[nodeIdx + value] - 1; + } + // Case 3: Multiple branches encoded in dictionary + // Binary search for the character. + let lo = nodeIdx; + let hi = lo + branchCount - 1; + while (lo <= hi) { + const mid = (lo + hi) >>> 1; + const midVal = decodeTree[mid]; + if (midVal < char) { + lo = mid + 1; + } + else if (midVal > char) { + hi = mid - 1; + } + else { + return decodeTree[mid + branchCount]; + } + } + return -1; +} +const htmlDecoder = getDecoder(decode_data_html); +const xmlDecoder = getDecoder(decode_data_xml); +/** + * Decodes an HTML string. + * + * @param str The string to decode. + * @param mode The decoding mode. + * @returns The decoded string. + */ +function decodeHTML(str, mode = DecodingMode.Legacy) { + return htmlDecoder(str, mode); +} +/** + * Decodes an HTML string in an attribute. + * + * @param str The string to decode. + * @returns The decoded string. + */ +function decodeHTMLAttribute(str) { + return htmlDecoder(str, DecodingMode.Attribute); +} +/** + * Decodes an HTML string, requiring all entities to be terminated by a semicolon. + * + * @param str The string to decode. + * @returns The decoded string. + */ +function decodeHTMLStrict(str) { + return htmlDecoder(str, DecodingMode.Strict); +} +/** + * Decodes an XML string, requiring all entities to be terminated by a semicolon. + * + * @param str The string to decode. + * @returns The decoded string. + */ +function decodeXML(str) { + return xmlDecoder(str, DecodingMode.Strict); +} +//# sourceMappingURL=decode.js.map +;// CONCATENATED MODULE: ./node_modules/parse5/dist/common/html.js +/** All valid namespaces in HTML. */ +var html_NS; +(function (NS) { + NS["HTML"] = "http://www.w3.org/1999/xhtml"; + NS["MATHML"] = "http://www.w3.org/1998/Math/MathML"; + NS["SVG"] = "http://www.w3.org/2000/svg"; + NS["XLINK"] = "http://www.w3.org/1999/xlink"; + NS["XML"] = "http://www.w3.org/XML/1998/namespace"; + NS["XMLNS"] = "http://www.w3.org/2000/xmlns/"; +})(html_NS = html_NS || (html_NS = {})); +var html_ATTRS; +(function (ATTRS) { + ATTRS["TYPE"] = "type"; + ATTRS["ACTION"] = "action"; + ATTRS["ENCODING"] = "encoding"; + ATTRS["PROMPT"] = "prompt"; + ATTRS["NAME"] = "name"; + ATTRS["COLOR"] = "color"; + ATTRS["FACE"] = "face"; + ATTRS["SIZE"] = "size"; +})(html_ATTRS = html_ATTRS || (html_ATTRS = {})); +/** + * The mode of the document. + * + * @see {@link https://dom.spec.whatwg.org/#concept-document-limited-quirks} + */ +var html_DOCUMENT_MODE; +(function (DOCUMENT_MODE) { + DOCUMENT_MODE["NO_QUIRKS"] = "no-quirks"; + DOCUMENT_MODE["QUIRKS"] = "quirks"; + DOCUMENT_MODE["LIMITED_QUIRKS"] = "limited-quirks"; +})(html_DOCUMENT_MODE = html_DOCUMENT_MODE || (html_DOCUMENT_MODE = {})); +var TAG_NAMES; +(function (TAG_NAMES) { + TAG_NAMES["A"] = "a"; + TAG_NAMES["ADDRESS"] = "address"; + TAG_NAMES["ANNOTATION_XML"] = "annotation-xml"; + TAG_NAMES["APPLET"] = "applet"; + TAG_NAMES["AREA"] = "area"; + TAG_NAMES["ARTICLE"] = "article"; + TAG_NAMES["ASIDE"] = "aside"; + TAG_NAMES["B"] = "b"; + TAG_NAMES["BASE"] = "base"; + TAG_NAMES["BASEFONT"] = "basefont"; + TAG_NAMES["BGSOUND"] = "bgsound"; + TAG_NAMES["BIG"] = "big"; + TAG_NAMES["BLOCKQUOTE"] = "blockquote"; + TAG_NAMES["BODY"] = "body"; + TAG_NAMES["BR"] = "br"; + TAG_NAMES["BUTTON"] = "button"; + TAG_NAMES["CAPTION"] = "caption"; + TAG_NAMES["CENTER"] = "center"; + TAG_NAMES["CODE"] = "code"; + TAG_NAMES["COL"] = "col"; + TAG_NAMES["COLGROUP"] = "colgroup"; + TAG_NAMES["DD"] = "dd"; + TAG_NAMES["DESC"] = "desc"; + TAG_NAMES["DETAILS"] = "details"; + TAG_NAMES["DIALOG"] = "dialog"; + TAG_NAMES["DIR"] = "dir"; + TAG_NAMES["DIV"] = "div"; + TAG_NAMES["DL"] = "dl"; + TAG_NAMES["DT"] = "dt"; + TAG_NAMES["EM"] = "em"; + TAG_NAMES["EMBED"] = "embed"; + TAG_NAMES["FIELDSET"] = "fieldset"; + TAG_NAMES["FIGCAPTION"] = "figcaption"; + TAG_NAMES["FIGURE"] = "figure"; + TAG_NAMES["FONT"] = "font"; + TAG_NAMES["FOOTER"] = "footer"; + TAG_NAMES["FOREIGN_OBJECT"] = "foreignObject"; + TAG_NAMES["FORM"] = "form"; + TAG_NAMES["FRAME"] = "frame"; + TAG_NAMES["FRAMESET"] = "frameset"; + TAG_NAMES["H1"] = "h1"; + TAG_NAMES["H2"] = "h2"; + TAG_NAMES["H3"] = "h3"; + TAG_NAMES["H4"] = "h4"; + TAG_NAMES["H5"] = "h5"; + TAG_NAMES["H6"] = "h6"; + TAG_NAMES["HEAD"] = "head"; + TAG_NAMES["HEADER"] = "header"; + TAG_NAMES["HGROUP"] = "hgroup"; + TAG_NAMES["HR"] = "hr"; + TAG_NAMES["HTML"] = "html"; + TAG_NAMES["I"] = "i"; + TAG_NAMES["IMG"] = "img"; + TAG_NAMES["IMAGE"] = "image"; + TAG_NAMES["INPUT"] = "input"; + TAG_NAMES["IFRAME"] = "iframe"; + TAG_NAMES["KEYGEN"] = "keygen"; + TAG_NAMES["LABEL"] = "label"; + TAG_NAMES["LI"] = "li"; + TAG_NAMES["LINK"] = "link"; + TAG_NAMES["LISTING"] = "listing"; + TAG_NAMES["MAIN"] = "main"; + TAG_NAMES["MALIGNMARK"] = "malignmark"; + TAG_NAMES["MARQUEE"] = "marquee"; + TAG_NAMES["MATH"] = "math"; + TAG_NAMES["MENU"] = "menu"; + TAG_NAMES["META"] = "meta"; + TAG_NAMES["MGLYPH"] = "mglyph"; + TAG_NAMES["MI"] = "mi"; + TAG_NAMES["MO"] = "mo"; + TAG_NAMES["MN"] = "mn"; + TAG_NAMES["MS"] = "ms"; + TAG_NAMES["MTEXT"] = "mtext"; + TAG_NAMES["NAV"] = "nav"; + TAG_NAMES["NOBR"] = "nobr"; + TAG_NAMES["NOFRAMES"] = "noframes"; + TAG_NAMES["NOEMBED"] = "noembed"; + TAG_NAMES["NOSCRIPT"] = "noscript"; + TAG_NAMES["OBJECT"] = "object"; + TAG_NAMES["OL"] = "ol"; + TAG_NAMES["OPTGROUP"] = "optgroup"; + TAG_NAMES["OPTION"] = "option"; + TAG_NAMES["P"] = "p"; + TAG_NAMES["PARAM"] = "param"; + TAG_NAMES["PLAINTEXT"] = "plaintext"; + TAG_NAMES["PRE"] = "pre"; + TAG_NAMES["RB"] = "rb"; + TAG_NAMES["RP"] = "rp"; + TAG_NAMES["RT"] = "rt"; + TAG_NAMES["RTC"] = "rtc"; + TAG_NAMES["RUBY"] = "ruby"; + TAG_NAMES["S"] = "s"; + TAG_NAMES["SCRIPT"] = "script"; + TAG_NAMES["SECTION"] = "section"; + TAG_NAMES["SELECT"] = "select"; + TAG_NAMES["SOURCE"] = "source"; + TAG_NAMES["SMALL"] = "small"; + TAG_NAMES["SPAN"] = "span"; + TAG_NAMES["STRIKE"] = "strike"; + TAG_NAMES["STRONG"] = "strong"; + TAG_NAMES["STYLE"] = "style"; + TAG_NAMES["SUB"] = "sub"; + TAG_NAMES["SUMMARY"] = "summary"; + TAG_NAMES["SUP"] = "sup"; + TAG_NAMES["TABLE"] = "table"; + TAG_NAMES["TBODY"] = "tbody"; + TAG_NAMES["TEMPLATE"] = "template"; + TAG_NAMES["TEXTAREA"] = "textarea"; + TAG_NAMES["TFOOT"] = "tfoot"; + TAG_NAMES["TD"] = "td"; + TAG_NAMES["TH"] = "th"; + TAG_NAMES["THEAD"] = "thead"; + TAG_NAMES["TITLE"] = "title"; + TAG_NAMES["TR"] = "tr"; + TAG_NAMES["TRACK"] = "track"; + TAG_NAMES["TT"] = "tt"; + TAG_NAMES["U"] = "u"; + TAG_NAMES["UL"] = "ul"; + TAG_NAMES["SVG"] = "svg"; + TAG_NAMES["VAR"] = "var"; + TAG_NAMES["WBR"] = "wbr"; + TAG_NAMES["XMP"] = "xmp"; +})(TAG_NAMES = TAG_NAMES || (TAG_NAMES = {})); +/** + * Tag IDs are numeric IDs for known tag names. + * + * We use tag IDs to improve the performance of tag name comparisons. + */ +var TAG_ID; +(function (TAG_ID) { + TAG_ID[TAG_ID["UNKNOWN"] = 0] = "UNKNOWN"; + TAG_ID[TAG_ID["A"] = 1] = "A"; + TAG_ID[TAG_ID["ADDRESS"] = 2] = "ADDRESS"; + TAG_ID[TAG_ID["ANNOTATION_XML"] = 3] = "ANNOTATION_XML"; + TAG_ID[TAG_ID["APPLET"] = 4] = "APPLET"; + TAG_ID[TAG_ID["AREA"] = 5] = "AREA"; + TAG_ID[TAG_ID["ARTICLE"] = 6] = "ARTICLE"; + TAG_ID[TAG_ID["ASIDE"] = 7] = "ASIDE"; + TAG_ID[TAG_ID["B"] = 8] = "B"; + TAG_ID[TAG_ID["BASE"] = 9] = "BASE"; + TAG_ID[TAG_ID["BASEFONT"] = 10] = "BASEFONT"; + TAG_ID[TAG_ID["BGSOUND"] = 11] = "BGSOUND"; + TAG_ID[TAG_ID["BIG"] = 12] = "BIG"; + TAG_ID[TAG_ID["BLOCKQUOTE"] = 13] = "BLOCKQUOTE"; + TAG_ID[TAG_ID["BODY"] = 14] = "BODY"; + TAG_ID[TAG_ID["BR"] = 15] = "BR"; + TAG_ID[TAG_ID["BUTTON"] = 16] = "BUTTON"; + TAG_ID[TAG_ID["CAPTION"] = 17] = "CAPTION"; + TAG_ID[TAG_ID["CENTER"] = 18] = "CENTER"; + TAG_ID[TAG_ID["CODE"] = 19] = "CODE"; + TAG_ID[TAG_ID["COL"] = 20] = "COL"; + TAG_ID[TAG_ID["COLGROUP"] = 21] = "COLGROUP"; + TAG_ID[TAG_ID["DD"] = 22] = "DD"; + TAG_ID[TAG_ID["DESC"] = 23] = "DESC"; + TAG_ID[TAG_ID["DETAILS"] = 24] = "DETAILS"; + TAG_ID[TAG_ID["DIALOG"] = 25] = "DIALOG"; + TAG_ID[TAG_ID["DIR"] = 26] = "DIR"; + TAG_ID[TAG_ID["DIV"] = 27] = "DIV"; + TAG_ID[TAG_ID["DL"] = 28] = "DL"; + TAG_ID[TAG_ID["DT"] = 29] = "DT"; + TAG_ID[TAG_ID["EM"] = 30] = "EM"; + TAG_ID[TAG_ID["EMBED"] = 31] = "EMBED"; + TAG_ID[TAG_ID["FIELDSET"] = 32] = "FIELDSET"; + TAG_ID[TAG_ID["FIGCAPTION"] = 33] = "FIGCAPTION"; + TAG_ID[TAG_ID["FIGURE"] = 34] = "FIGURE"; + TAG_ID[TAG_ID["FONT"] = 35] = "FONT"; + TAG_ID[TAG_ID["FOOTER"] = 36] = "FOOTER"; + TAG_ID[TAG_ID["FOREIGN_OBJECT"] = 37] = "FOREIGN_OBJECT"; + TAG_ID[TAG_ID["FORM"] = 38] = "FORM"; + TAG_ID[TAG_ID["FRAME"] = 39] = "FRAME"; + TAG_ID[TAG_ID["FRAMESET"] = 40] = "FRAMESET"; + TAG_ID[TAG_ID["H1"] = 41] = "H1"; + TAG_ID[TAG_ID["H2"] = 42] = "H2"; + TAG_ID[TAG_ID["H3"] = 43] = "H3"; + TAG_ID[TAG_ID["H4"] = 44] = "H4"; + TAG_ID[TAG_ID["H5"] = 45] = "H5"; + TAG_ID[TAG_ID["H6"] = 46] = "H6"; + TAG_ID[TAG_ID["HEAD"] = 47] = "HEAD"; + TAG_ID[TAG_ID["HEADER"] = 48] = "HEADER"; + TAG_ID[TAG_ID["HGROUP"] = 49] = "HGROUP"; + TAG_ID[TAG_ID["HR"] = 50] = "HR"; + TAG_ID[TAG_ID["HTML"] = 51] = "HTML"; + TAG_ID[TAG_ID["I"] = 52] = "I"; + TAG_ID[TAG_ID["IMG"] = 53] = "IMG"; + TAG_ID[TAG_ID["IMAGE"] = 54] = "IMAGE"; + TAG_ID[TAG_ID["INPUT"] = 55] = "INPUT"; + TAG_ID[TAG_ID["IFRAME"] = 56] = "IFRAME"; + TAG_ID[TAG_ID["KEYGEN"] = 57] = "KEYGEN"; + TAG_ID[TAG_ID["LABEL"] = 58] = "LABEL"; + TAG_ID[TAG_ID["LI"] = 59] = "LI"; + TAG_ID[TAG_ID["LINK"] = 60] = "LINK"; + TAG_ID[TAG_ID["LISTING"] = 61] = "LISTING"; + TAG_ID[TAG_ID["MAIN"] = 62] = "MAIN"; + TAG_ID[TAG_ID["MALIGNMARK"] = 63] = "MALIGNMARK"; + TAG_ID[TAG_ID["MARQUEE"] = 64] = "MARQUEE"; + TAG_ID[TAG_ID["MATH"] = 65] = "MATH"; + TAG_ID[TAG_ID["MENU"] = 66] = "MENU"; + TAG_ID[TAG_ID["META"] = 67] = "META"; + TAG_ID[TAG_ID["MGLYPH"] = 68] = "MGLYPH"; + TAG_ID[TAG_ID["MI"] = 69] = "MI"; + TAG_ID[TAG_ID["MO"] = 70] = "MO"; + TAG_ID[TAG_ID["MN"] = 71] = "MN"; + TAG_ID[TAG_ID["MS"] = 72] = "MS"; + TAG_ID[TAG_ID["MTEXT"] = 73] = "MTEXT"; + TAG_ID[TAG_ID["NAV"] = 74] = "NAV"; + TAG_ID[TAG_ID["NOBR"] = 75] = "NOBR"; + TAG_ID[TAG_ID["NOFRAMES"] = 76] = "NOFRAMES"; + TAG_ID[TAG_ID["NOEMBED"] = 77] = "NOEMBED"; + TAG_ID[TAG_ID["NOSCRIPT"] = 78] = "NOSCRIPT"; + TAG_ID[TAG_ID["OBJECT"] = 79] = "OBJECT"; + TAG_ID[TAG_ID["OL"] = 80] = "OL"; + TAG_ID[TAG_ID["OPTGROUP"] = 81] = "OPTGROUP"; + TAG_ID[TAG_ID["OPTION"] = 82] = "OPTION"; + TAG_ID[TAG_ID["P"] = 83] = "P"; + TAG_ID[TAG_ID["PARAM"] = 84] = "PARAM"; + TAG_ID[TAG_ID["PLAINTEXT"] = 85] = "PLAINTEXT"; + TAG_ID[TAG_ID["PRE"] = 86] = "PRE"; + TAG_ID[TAG_ID["RB"] = 87] = "RB"; + TAG_ID[TAG_ID["RP"] = 88] = "RP"; + TAG_ID[TAG_ID["RT"] = 89] = "RT"; + TAG_ID[TAG_ID["RTC"] = 90] = "RTC"; + TAG_ID[TAG_ID["RUBY"] = 91] = "RUBY"; + TAG_ID[TAG_ID["S"] = 92] = "S"; + TAG_ID[TAG_ID["SCRIPT"] = 93] = "SCRIPT"; + TAG_ID[TAG_ID["SECTION"] = 94] = "SECTION"; + TAG_ID[TAG_ID["SELECT"] = 95] = "SELECT"; + TAG_ID[TAG_ID["SOURCE"] = 96] = "SOURCE"; + TAG_ID[TAG_ID["SMALL"] = 97] = "SMALL"; + TAG_ID[TAG_ID["SPAN"] = 98] = "SPAN"; + TAG_ID[TAG_ID["STRIKE"] = 99] = "STRIKE"; + TAG_ID[TAG_ID["STRONG"] = 100] = "STRONG"; + TAG_ID[TAG_ID["STYLE"] = 101] = "STYLE"; + TAG_ID[TAG_ID["SUB"] = 102] = "SUB"; + TAG_ID[TAG_ID["SUMMARY"] = 103] = "SUMMARY"; + TAG_ID[TAG_ID["SUP"] = 104] = "SUP"; + TAG_ID[TAG_ID["TABLE"] = 105] = "TABLE"; + TAG_ID[TAG_ID["TBODY"] = 106] = "TBODY"; + TAG_ID[TAG_ID["TEMPLATE"] = 107] = "TEMPLATE"; + TAG_ID[TAG_ID["TEXTAREA"] = 108] = "TEXTAREA"; + TAG_ID[TAG_ID["TFOOT"] = 109] = "TFOOT"; + TAG_ID[TAG_ID["TD"] = 110] = "TD"; + TAG_ID[TAG_ID["TH"] = 111] = "TH"; + TAG_ID[TAG_ID["THEAD"] = 112] = "THEAD"; + TAG_ID[TAG_ID["TITLE"] = 113] = "TITLE"; + TAG_ID[TAG_ID["TR"] = 114] = "TR"; + TAG_ID[TAG_ID["TRACK"] = 115] = "TRACK"; + TAG_ID[TAG_ID["TT"] = 116] = "TT"; + TAG_ID[TAG_ID["U"] = 117] = "U"; + TAG_ID[TAG_ID["UL"] = 118] = "UL"; + TAG_ID[TAG_ID["SVG"] = 119] = "SVG"; + TAG_ID[TAG_ID["VAR"] = 120] = "VAR"; + TAG_ID[TAG_ID["WBR"] = 121] = "WBR"; + TAG_ID[TAG_ID["XMP"] = 122] = "XMP"; +})(TAG_ID = TAG_ID || (TAG_ID = {})); +const TAG_NAME_TO_ID = new Map([ + [TAG_NAMES.A, TAG_ID.A], + [TAG_NAMES.ADDRESS, TAG_ID.ADDRESS], + [TAG_NAMES.ANNOTATION_XML, TAG_ID.ANNOTATION_XML], + [TAG_NAMES.APPLET, TAG_ID.APPLET], + [TAG_NAMES.AREA, TAG_ID.AREA], + [TAG_NAMES.ARTICLE, TAG_ID.ARTICLE], + [TAG_NAMES.ASIDE, TAG_ID.ASIDE], + [TAG_NAMES.B, TAG_ID.B], + [TAG_NAMES.BASE, TAG_ID.BASE], + [TAG_NAMES.BASEFONT, TAG_ID.BASEFONT], + [TAG_NAMES.BGSOUND, TAG_ID.BGSOUND], + [TAG_NAMES.BIG, TAG_ID.BIG], + [TAG_NAMES.BLOCKQUOTE, TAG_ID.BLOCKQUOTE], + [TAG_NAMES.BODY, TAG_ID.BODY], + [TAG_NAMES.BR, TAG_ID.BR], + [TAG_NAMES.BUTTON, TAG_ID.BUTTON], + [TAG_NAMES.CAPTION, TAG_ID.CAPTION], + [TAG_NAMES.CENTER, TAG_ID.CENTER], + [TAG_NAMES.CODE, TAG_ID.CODE], + [TAG_NAMES.COL, TAG_ID.COL], + [TAG_NAMES.COLGROUP, TAG_ID.COLGROUP], + [TAG_NAMES.DD, TAG_ID.DD], + [TAG_NAMES.DESC, TAG_ID.DESC], + [TAG_NAMES.DETAILS, TAG_ID.DETAILS], + [TAG_NAMES.DIALOG, TAG_ID.DIALOG], + [TAG_NAMES.DIR, TAG_ID.DIR], + [TAG_NAMES.DIV, TAG_ID.DIV], + [TAG_NAMES.DL, TAG_ID.DL], + [TAG_NAMES.DT, TAG_ID.DT], + [TAG_NAMES.EM, TAG_ID.EM], + [TAG_NAMES.EMBED, TAG_ID.EMBED], + [TAG_NAMES.FIELDSET, TAG_ID.FIELDSET], + [TAG_NAMES.FIGCAPTION, TAG_ID.FIGCAPTION], + [TAG_NAMES.FIGURE, TAG_ID.FIGURE], + [TAG_NAMES.FONT, TAG_ID.FONT], + [TAG_NAMES.FOOTER, TAG_ID.FOOTER], + [TAG_NAMES.FOREIGN_OBJECT, TAG_ID.FOREIGN_OBJECT], + [TAG_NAMES.FORM, TAG_ID.FORM], + [TAG_NAMES.FRAME, TAG_ID.FRAME], + [TAG_NAMES.FRAMESET, TAG_ID.FRAMESET], + [TAG_NAMES.H1, TAG_ID.H1], + [TAG_NAMES.H2, TAG_ID.H2], + [TAG_NAMES.H3, TAG_ID.H3], + [TAG_NAMES.H4, TAG_ID.H4], + [TAG_NAMES.H5, TAG_ID.H5], + [TAG_NAMES.H6, TAG_ID.H6], + [TAG_NAMES.HEAD, TAG_ID.HEAD], + [TAG_NAMES.HEADER, TAG_ID.HEADER], + [TAG_NAMES.HGROUP, TAG_ID.HGROUP], + [TAG_NAMES.HR, TAG_ID.HR], + [TAG_NAMES.HTML, TAG_ID.HTML], + [TAG_NAMES.I, TAG_ID.I], + [TAG_NAMES.IMG, TAG_ID.IMG], + [TAG_NAMES.IMAGE, TAG_ID.IMAGE], + [TAG_NAMES.INPUT, TAG_ID.INPUT], + [TAG_NAMES.IFRAME, TAG_ID.IFRAME], + [TAG_NAMES.KEYGEN, TAG_ID.KEYGEN], + [TAG_NAMES.LABEL, TAG_ID.LABEL], + [TAG_NAMES.LI, TAG_ID.LI], + [TAG_NAMES.LINK, TAG_ID.LINK], + [TAG_NAMES.LISTING, TAG_ID.LISTING], + [TAG_NAMES.MAIN, TAG_ID.MAIN], + [TAG_NAMES.MALIGNMARK, TAG_ID.MALIGNMARK], + [TAG_NAMES.MARQUEE, TAG_ID.MARQUEE], + [TAG_NAMES.MATH, TAG_ID.MATH], + [TAG_NAMES.MENU, TAG_ID.MENU], + [TAG_NAMES.META, TAG_ID.META], + [TAG_NAMES.MGLYPH, TAG_ID.MGLYPH], + [TAG_NAMES.MI, TAG_ID.MI], + [TAG_NAMES.MO, TAG_ID.MO], + [TAG_NAMES.MN, TAG_ID.MN], + [TAG_NAMES.MS, TAG_ID.MS], + [TAG_NAMES.MTEXT, TAG_ID.MTEXT], + [TAG_NAMES.NAV, TAG_ID.NAV], + [TAG_NAMES.NOBR, TAG_ID.NOBR], + [TAG_NAMES.NOFRAMES, TAG_ID.NOFRAMES], + [TAG_NAMES.NOEMBED, TAG_ID.NOEMBED], + [TAG_NAMES.NOSCRIPT, TAG_ID.NOSCRIPT], + [TAG_NAMES.OBJECT, TAG_ID.OBJECT], + [TAG_NAMES.OL, TAG_ID.OL], + [TAG_NAMES.OPTGROUP, TAG_ID.OPTGROUP], + [TAG_NAMES.OPTION, TAG_ID.OPTION], + [TAG_NAMES.P, TAG_ID.P], + [TAG_NAMES.PARAM, TAG_ID.PARAM], + [TAG_NAMES.PLAINTEXT, TAG_ID.PLAINTEXT], + [TAG_NAMES.PRE, TAG_ID.PRE], + [TAG_NAMES.RB, TAG_ID.RB], + [TAG_NAMES.RP, TAG_ID.RP], + [TAG_NAMES.RT, TAG_ID.RT], + [TAG_NAMES.RTC, TAG_ID.RTC], + [TAG_NAMES.RUBY, TAG_ID.RUBY], + [TAG_NAMES.S, TAG_ID.S], + [TAG_NAMES.SCRIPT, TAG_ID.SCRIPT], + [TAG_NAMES.SECTION, TAG_ID.SECTION], + [TAG_NAMES.SELECT, TAG_ID.SELECT], + [TAG_NAMES.SOURCE, TAG_ID.SOURCE], + [TAG_NAMES.SMALL, TAG_ID.SMALL], + [TAG_NAMES.SPAN, TAG_ID.SPAN], + [TAG_NAMES.STRIKE, TAG_ID.STRIKE], + [TAG_NAMES.STRONG, TAG_ID.STRONG], + [TAG_NAMES.STYLE, TAG_ID.STYLE], + [TAG_NAMES.SUB, TAG_ID.SUB], + [TAG_NAMES.SUMMARY, TAG_ID.SUMMARY], + [TAG_NAMES.SUP, TAG_ID.SUP], + [TAG_NAMES.TABLE, TAG_ID.TABLE], + [TAG_NAMES.TBODY, TAG_ID.TBODY], + [TAG_NAMES.TEMPLATE, TAG_ID.TEMPLATE], + [TAG_NAMES.TEXTAREA, TAG_ID.TEXTAREA], + [TAG_NAMES.TFOOT, TAG_ID.TFOOT], + [TAG_NAMES.TD, TAG_ID.TD], + [TAG_NAMES.TH, TAG_ID.TH], + [TAG_NAMES.THEAD, TAG_ID.THEAD], + [TAG_NAMES.TITLE, TAG_ID.TITLE], + [TAG_NAMES.TR, TAG_ID.TR], + [TAG_NAMES.TRACK, TAG_ID.TRACK], + [TAG_NAMES.TT, TAG_ID.TT], + [TAG_NAMES.U, TAG_ID.U], + [TAG_NAMES.UL, TAG_ID.UL], + [TAG_NAMES.SVG, TAG_ID.SVG], + [TAG_NAMES.VAR, TAG_ID.VAR], + [TAG_NAMES.WBR, TAG_ID.WBR], + [TAG_NAMES.XMP, TAG_ID.XMP], +]); +function html_getTagID(tagName) { + var _a; + return (_a = TAG_NAME_TO_ID.get(tagName)) !== null && _a !== void 0 ? _a : TAG_ID.UNKNOWN; +} +const html_$ = TAG_ID; +const html_SPECIAL_ELEMENTS = { + [html_NS.HTML]: new Set([ + html_$.ADDRESS, + html_$.APPLET, + html_$.AREA, + html_$.ARTICLE, + html_$.ASIDE, + html_$.BASE, + html_$.BASEFONT, + html_$.BGSOUND, + html_$.BLOCKQUOTE, + html_$.BODY, + html_$.BR, + html_$.BUTTON, + html_$.CAPTION, + html_$.CENTER, + html_$.COL, + html_$.COLGROUP, + html_$.DD, + html_$.DETAILS, + html_$.DIR, + html_$.DIV, + html_$.DL, + html_$.DT, + html_$.EMBED, + html_$.FIELDSET, + html_$.FIGCAPTION, + html_$.FIGURE, + html_$.FOOTER, + html_$.FORM, + html_$.FRAME, + html_$.FRAMESET, + html_$.H1, + html_$.H2, + html_$.H3, + html_$.H4, + html_$.H5, + html_$.H6, + html_$.HEAD, + html_$.HEADER, + html_$.HGROUP, + html_$.HR, + html_$.HTML, + html_$.IFRAME, + html_$.IMG, + html_$.INPUT, + html_$.LI, + html_$.LINK, + html_$.LISTING, + html_$.MAIN, + html_$.MARQUEE, + html_$.MENU, + html_$.META, + html_$.NAV, + html_$.NOEMBED, + html_$.NOFRAMES, + html_$.NOSCRIPT, + html_$.OBJECT, + html_$.OL, + html_$.P, + html_$.PARAM, + html_$.PLAINTEXT, + html_$.PRE, + html_$.SCRIPT, + html_$.SECTION, + html_$.SELECT, + html_$.SOURCE, + html_$.STYLE, + html_$.SUMMARY, + html_$.TABLE, + html_$.TBODY, + html_$.TD, + html_$.TEMPLATE, + html_$.TEXTAREA, + html_$.TFOOT, + html_$.TH, + html_$.THEAD, + html_$.TITLE, + html_$.TR, + html_$.TRACK, + html_$.UL, + html_$.WBR, + html_$.XMP, + ]), + [html_NS.MATHML]: new Set([html_$.MI, html_$.MO, html_$.MN, html_$.MS, html_$.MTEXT, html_$.ANNOTATION_XML]), + [html_NS.SVG]: new Set([html_$.TITLE, html_$.FOREIGN_OBJECT, html_$.DESC]), + [html_NS.XLINK]: new Set(), + [html_NS.XML]: new Set(), + [html_NS.XMLNS]: new Set(), +}; +function html_isNumberedHeader(tn) { + return tn === html_$.H1 || tn === html_$.H2 || tn === html_$.H3 || tn === html_$.H4 || tn === html_$.H5 || tn === html_$.H6; +} +const UNESCAPED_TEXT = new Set([ + TAG_NAMES.STYLE, + TAG_NAMES.SCRIPT, + TAG_NAMES.XMP, + TAG_NAMES.IFRAME, + TAG_NAMES.NOEMBED, + TAG_NAMES.NOFRAMES, + TAG_NAMES.PLAINTEXT, +]); +function html_hasUnescapedText(tn, scriptingEnabled) { + return UNESCAPED_TEXT.has(tn) || (scriptingEnabled && tn === TAG_NAMES.NOSCRIPT); +} +//# sourceMappingURL=html.js.map +;// CONCATENATED MODULE: ./node_modules/parse5/dist/tokenizer/index.js + + + + + + +//C1 Unicode control character reference replacements +const C1_CONTROLS_REFERENCE_REPLACEMENTS = new Map([ + [0x80, 8364], + [0x82, 8218], + [0x83, 402], + [0x84, 8222], + [0x85, 8230], + [0x86, 8224], + [0x87, 8225], + [0x88, 710], + [0x89, 8240], + [0x8a, 352], + [0x8b, 8249], + [0x8c, 338], + [0x8e, 381], + [0x91, 8216], + [0x92, 8217], + [0x93, 8220], + [0x94, 8221], + [0x95, 8226], + [0x96, 8211], + [0x97, 8212], + [0x98, 732], + [0x99, 8482], + [0x9a, 353], + [0x9b, 8250], + [0x9c, 339], + [0x9e, 382], + [0x9f, 376], +]); +//States +var State; +(function (State) { + State[State["DATA"] = 0] = "DATA"; + State[State["RCDATA"] = 1] = "RCDATA"; + State[State["RAWTEXT"] = 2] = "RAWTEXT"; + State[State["SCRIPT_DATA"] = 3] = "SCRIPT_DATA"; + State[State["PLAINTEXT"] = 4] = "PLAINTEXT"; + State[State["TAG_OPEN"] = 5] = "TAG_OPEN"; + State[State["END_TAG_OPEN"] = 6] = "END_TAG_OPEN"; + State[State["TAG_NAME"] = 7] = "TAG_NAME"; + State[State["RCDATA_LESS_THAN_SIGN"] = 8] = "RCDATA_LESS_THAN_SIGN"; + State[State["RCDATA_END_TAG_OPEN"] = 9] = "RCDATA_END_TAG_OPEN"; + State[State["RCDATA_END_TAG_NAME"] = 10] = "RCDATA_END_TAG_NAME"; + State[State["RAWTEXT_LESS_THAN_SIGN"] = 11] = "RAWTEXT_LESS_THAN_SIGN"; + State[State["RAWTEXT_END_TAG_OPEN"] = 12] = "RAWTEXT_END_TAG_OPEN"; + State[State["RAWTEXT_END_TAG_NAME"] = 13] = "RAWTEXT_END_TAG_NAME"; + State[State["SCRIPT_DATA_LESS_THAN_SIGN"] = 14] = "SCRIPT_DATA_LESS_THAN_SIGN"; + State[State["SCRIPT_DATA_END_TAG_OPEN"] = 15] = "SCRIPT_DATA_END_TAG_OPEN"; + State[State["SCRIPT_DATA_END_TAG_NAME"] = 16] = "SCRIPT_DATA_END_TAG_NAME"; + State[State["SCRIPT_DATA_ESCAPE_START"] = 17] = "SCRIPT_DATA_ESCAPE_START"; + State[State["SCRIPT_DATA_ESCAPE_START_DASH"] = 18] = "SCRIPT_DATA_ESCAPE_START_DASH"; + State[State["SCRIPT_DATA_ESCAPED"] = 19] = "SCRIPT_DATA_ESCAPED"; + State[State["SCRIPT_DATA_ESCAPED_DASH"] = 20] = "SCRIPT_DATA_ESCAPED_DASH"; + State[State["SCRIPT_DATA_ESCAPED_DASH_DASH"] = 21] = "SCRIPT_DATA_ESCAPED_DASH_DASH"; + State[State["SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN"] = 22] = "SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN"; + State[State["SCRIPT_DATA_ESCAPED_END_TAG_OPEN"] = 23] = "SCRIPT_DATA_ESCAPED_END_TAG_OPEN"; + State[State["SCRIPT_DATA_ESCAPED_END_TAG_NAME"] = 24] = "SCRIPT_DATA_ESCAPED_END_TAG_NAME"; + State[State["SCRIPT_DATA_DOUBLE_ESCAPE_START"] = 25] = "SCRIPT_DATA_DOUBLE_ESCAPE_START"; + State[State["SCRIPT_DATA_DOUBLE_ESCAPED"] = 26] = "SCRIPT_DATA_DOUBLE_ESCAPED"; + State[State["SCRIPT_DATA_DOUBLE_ESCAPED_DASH"] = 27] = "SCRIPT_DATA_DOUBLE_ESCAPED_DASH"; + State[State["SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH"] = 28] = "SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH"; + State[State["SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN"] = 29] = "SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN"; + State[State["SCRIPT_DATA_DOUBLE_ESCAPE_END"] = 30] = "SCRIPT_DATA_DOUBLE_ESCAPE_END"; + State[State["BEFORE_ATTRIBUTE_NAME"] = 31] = "BEFORE_ATTRIBUTE_NAME"; + State[State["ATTRIBUTE_NAME"] = 32] = "ATTRIBUTE_NAME"; + State[State["AFTER_ATTRIBUTE_NAME"] = 33] = "AFTER_ATTRIBUTE_NAME"; + State[State["BEFORE_ATTRIBUTE_VALUE"] = 34] = "BEFORE_ATTRIBUTE_VALUE"; + State[State["ATTRIBUTE_VALUE_DOUBLE_QUOTED"] = 35] = "ATTRIBUTE_VALUE_DOUBLE_QUOTED"; + State[State["ATTRIBUTE_VALUE_SINGLE_QUOTED"] = 36] = "ATTRIBUTE_VALUE_SINGLE_QUOTED"; + State[State["ATTRIBUTE_VALUE_UNQUOTED"] = 37] = "ATTRIBUTE_VALUE_UNQUOTED"; + State[State["AFTER_ATTRIBUTE_VALUE_QUOTED"] = 38] = "AFTER_ATTRIBUTE_VALUE_QUOTED"; + State[State["SELF_CLOSING_START_TAG"] = 39] = "SELF_CLOSING_START_TAG"; + State[State["BOGUS_COMMENT"] = 40] = "BOGUS_COMMENT"; + State[State["MARKUP_DECLARATION_OPEN"] = 41] = "MARKUP_DECLARATION_OPEN"; + State[State["COMMENT_START"] = 42] = "COMMENT_START"; + State[State["COMMENT_START_DASH"] = 43] = "COMMENT_START_DASH"; + State[State["COMMENT"] = 44] = "COMMENT"; + State[State["COMMENT_LESS_THAN_SIGN"] = 45] = "COMMENT_LESS_THAN_SIGN"; + State[State["COMMENT_LESS_THAN_SIGN_BANG"] = 46] = "COMMENT_LESS_THAN_SIGN_BANG"; + State[State["COMMENT_LESS_THAN_SIGN_BANG_DASH"] = 47] = "COMMENT_LESS_THAN_SIGN_BANG_DASH"; + State[State["COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH"] = 48] = "COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH"; + State[State["COMMENT_END_DASH"] = 49] = "COMMENT_END_DASH"; + State[State["COMMENT_END"] = 50] = "COMMENT_END"; + State[State["COMMENT_END_BANG"] = 51] = "COMMENT_END_BANG"; + State[State["DOCTYPE"] = 52] = "DOCTYPE"; + State[State["BEFORE_DOCTYPE_NAME"] = 53] = "BEFORE_DOCTYPE_NAME"; + State[State["DOCTYPE_NAME"] = 54] = "DOCTYPE_NAME"; + State[State["AFTER_DOCTYPE_NAME"] = 55] = "AFTER_DOCTYPE_NAME"; + State[State["AFTER_DOCTYPE_PUBLIC_KEYWORD"] = 56] = "AFTER_DOCTYPE_PUBLIC_KEYWORD"; + State[State["BEFORE_DOCTYPE_PUBLIC_IDENTIFIER"] = 57] = "BEFORE_DOCTYPE_PUBLIC_IDENTIFIER"; + State[State["DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED"] = 58] = "DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED"; + State[State["DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED"] = 59] = "DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED"; + State[State["AFTER_DOCTYPE_PUBLIC_IDENTIFIER"] = 60] = "AFTER_DOCTYPE_PUBLIC_IDENTIFIER"; + State[State["BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS"] = 61] = "BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS"; + State[State["AFTER_DOCTYPE_SYSTEM_KEYWORD"] = 62] = "AFTER_DOCTYPE_SYSTEM_KEYWORD"; + State[State["BEFORE_DOCTYPE_SYSTEM_IDENTIFIER"] = 63] = "BEFORE_DOCTYPE_SYSTEM_IDENTIFIER"; + State[State["DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED"] = 64] = "DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED"; + State[State["DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED"] = 65] = "DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED"; + State[State["AFTER_DOCTYPE_SYSTEM_IDENTIFIER"] = 66] = "AFTER_DOCTYPE_SYSTEM_IDENTIFIER"; + State[State["BOGUS_DOCTYPE"] = 67] = "BOGUS_DOCTYPE"; + State[State["CDATA_SECTION"] = 68] = "CDATA_SECTION"; + State[State["CDATA_SECTION_BRACKET"] = 69] = "CDATA_SECTION_BRACKET"; + State[State["CDATA_SECTION_END"] = 70] = "CDATA_SECTION_END"; + State[State["CHARACTER_REFERENCE"] = 71] = "CHARACTER_REFERENCE"; + State[State["NAMED_CHARACTER_REFERENCE"] = 72] = "NAMED_CHARACTER_REFERENCE"; + State[State["AMBIGUOUS_AMPERSAND"] = 73] = "AMBIGUOUS_AMPERSAND"; + State[State["NUMERIC_CHARACTER_REFERENCE"] = 74] = "NUMERIC_CHARACTER_REFERENCE"; + State[State["HEXADEMICAL_CHARACTER_REFERENCE_START"] = 75] = "HEXADEMICAL_CHARACTER_REFERENCE_START"; + State[State["HEXADEMICAL_CHARACTER_REFERENCE"] = 76] = "HEXADEMICAL_CHARACTER_REFERENCE"; + State[State["DECIMAL_CHARACTER_REFERENCE"] = 77] = "DECIMAL_CHARACTER_REFERENCE"; + State[State["NUMERIC_CHARACTER_REFERENCE_END"] = 78] = "NUMERIC_CHARACTER_REFERENCE_END"; +})(State || (State = {})); +//Tokenizer initial states for different modes +const tokenizer_TokenizerMode = { + DATA: State.DATA, + RCDATA: State.RCDATA, + RAWTEXT: State.RAWTEXT, + SCRIPT_DATA: State.SCRIPT_DATA, + PLAINTEXT: State.PLAINTEXT, + CDATA_SECTION: State.CDATA_SECTION, +}; +//Utils +//OPTIMIZATION: these utility functions should not be moved out of this module. V8 Crankshaft will not inline +//this functions if they will be situated in another module due to context switch. +//Always perform inlining check before modifying this functions ('node --trace-inlining'). +function isAsciiDigit(cp) { + return cp >= CODE_POINTS.DIGIT_0 && cp <= CODE_POINTS.DIGIT_9; +} +function isAsciiUpper(cp) { + return cp >= CODE_POINTS.LATIN_CAPITAL_A && cp <= CODE_POINTS.LATIN_CAPITAL_Z; +} +function isAsciiLower(cp) { + return cp >= CODE_POINTS.LATIN_SMALL_A && cp <= CODE_POINTS.LATIN_SMALL_Z; +} +function isAsciiLetter(cp) { + return isAsciiLower(cp) || isAsciiUpper(cp); +} +function tokenizer_isAsciiAlphaNumeric(cp) { + return isAsciiLetter(cp) || isAsciiDigit(cp); +} +function isAsciiUpperHexDigit(cp) { + return cp >= CODE_POINTS.LATIN_CAPITAL_A && cp <= CODE_POINTS.LATIN_CAPITAL_F; +} +function isAsciiLowerHexDigit(cp) { + return cp >= CODE_POINTS.LATIN_SMALL_A && cp <= CODE_POINTS.LATIN_SMALL_F; +} +function isAsciiHexDigit(cp) { + return isAsciiDigit(cp) || isAsciiUpperHexDigit(cp) || isAsciiLowerHexDigit(cp); +} +function toAsciiLower(cp) { + return cp + 32; +} +function isWhitespace(cp) { + return cp === CODE_POINTS.SPACE || cp === CODE_POINTS.LINE_FEED || cp === CODE_POINTS.TABULATION || cp === CODE_POINTS.FORM_FEED; +} +function tokenizer_isEntityInAttributeInvalidEnd(nextCp) { + return nextCp === CODE_POINTS.EQUALS_SIGN || tokenizer_isAsciiAlphaNumeric(nextCp); +} +function isScriptDataDoubleEscapeSequenceEnd(cp) { + return isWhitespace(cp) || cp === CODE_POINTS.SOLIDUS || cp === CODE_POINTS.GREATER_THAN_SIGN; +} +//Tokenizer +class tokenizer_Tokenizer { + constructor(options, handler) { + this.options = options; + this.handler = handler; + this.paused = false; + /** Ensures that the parsing loop isn't run multiple times at once. */ + this.inLoop = false; + /** + * Indicates that the current adjusted node exists, is not an element in the HTML namespace, + * and that it is not an integration point for either MathML or HTML. + * + * @see {@link https://html.spec.whatwg.org/multipage/parsing.html#tree-construction} + */ + this.inForeignNode = false; + this.lastStartTagName = ''; + this.active = false; + this.state = State.DATA; + this.returnState = State.DATA; + this.charRefCode = -1; + this.consumedAfterSnapshot = -1; + this.currentCharacterToken = null; + this.currentToken = null; + this.currentAttr = { name: '', value: '' }; + this.preprocessor = new Preprocessor(handler); + this.currentLocation = this.getCurrentLocation(-1); + } + //Errors + _err(code) { + var _a, _b; + (_b = (_a = this.handler).onParseError) === null || _b === void 0 ? void 0 : _b.call(_a, this.preprocessor.getError(code)); + } + // NOTE: `offset` may never run across line boundaries. + getCurrentLocation(offset) { + if (!this.options.sourceCodeLocationInfo) { + return null; + } + return { + startLine: this.preprocessor.line, + startCol: this.preprocessor.col - offset, + startOffset: this.preprocessor.offset - offset, + endLine: -1, + endCol: -1, + endOffset: -1, + }; + } + _runParsingLoop() { + if (this.inLoop) + return; + this.inLoop = true; + while (this.active && !this.paused) { + this.consumedAfterSnapshot = 0; + const cp = this._consume(); + if (!this._ensureHibernation()) { + this._callState(cp); + } + } + this.inLoop = false; + } + //API + pause() { + this.paused = true; + } + resume(writeCallback) { + if (!this.paused) { + throw new Error('Parser was already resumed'); + } + this.paused = false; + // Necessary for synchronous resume. + if (this.inLoop) + return; + this._runParsingLoop(); + if (!this.paused) { + writeCallback === null || writeCallback === void 0 ? void 0 : writeCallback(); + } + } + write(chunk, isLastChunk, writeCallback) { + this.active = true; + this.preprocessor.write(chunk, isLastChunk); + this._runParsingLoop(); + if (!this.paused) { + writeCallback === null || writeCallback === void 0 ? void 0 : writeCallback(); + } + } + insertHtmlAtCurrentPos(chunk) { + this.active = true; + this.preprocessor.insertHtmlAtCurrentPos(chunk); + this._runParsingLoop(); + } + //Hibernation + _ensureHibernation() { + if (this.preprocessor.endOfChunkHit) { + this._unconsume(this.consumedAfterSnapshot); + this.active = false; + return true; + } + return false; + } + //Consumption + _consume() { + this.consumedAfterSnapshot++; + return this.preprocessor.advance(); + } + _unconsume(count) { + this.consumedAfterSnapshot -= count; + this.preprocessor.retreat(count); + } + _reconsumeInState(state, cp) { + this.state = state; + this._callState(cp); + } + _advanceBy(count) { + this.consumedAfterSnapshot += count; + for (let i = 0; i < count; i++) { + this.preprocessor.advance(); + } + } + _consumeSequenceIfMatch(pattern, caseSensitive) { + if (this.preprocessor.startsWith(pattern, caseSensitive)) { + // We will already have consumed one character before calling this method. + this._advanceBy(pattern.length - 1); + return true; + } + return false; + } + //Token creation + _createStartTagToken() { + this.currentToken = { + type: token_TokenType.START_TAG, + tagName: '', + tagID: TAG_ID.UNKNOWN, + selfClosing: false, + ackSelfClosing: false, + attrs: [], + location: this.getCurrentLocation(1), + }; + } + _createEndTagToken() { + this.currentToken = { + type: token_TokenType.END_TAG, + tagName: '', + tagID: TAG_ID.UNKNOWN, + selfClosing: false, + ackSelfClosing: false, + attrs: [], + location: this.getCurrentLocation(2), + }; + } + _createCommentToken(offset) { + this.currentToken = { + type: token_TokenType.COMMENT, + data: '', + location: this.getCurrentLocation(offset), + }; + } + _createDoctypeToken(initialName) { + this.currentToken = { + type: token_TokenType.DOCTYPE, + name: initialName, + forceQuirks: false, + publicId: null, + systemId: null, + location: this.currentLocation, + }; + } + _createCharacterToken(type, chars) { + this.currentCharacterToken = { + type, + chars, + location: this.currentLocation, + }; + } + //Tag attributes + _createAttr(attrNameFirstCh) { + this.currentAttr = { + name: attrNameFirstCh, + value: '', + }; + this.currentLocation = this.getCurrentLocation(0); + } + _leaveAttrName() { + var _a; + var _b; + const token = this.currentToken; + if (token_getTokenAttr(token, this.currentAttr.name) === null) { + token.attrs.push(this.currentAttr); + if (token.location && this.currentLocation) { + const attrLocations = ((_a = (_b = token.location).attrs) !== null && _a !== void 0 ? _a : (_b.attrs = Object.create(null))); + attrLocations[this.currentAttr.name] = this.currentLocation; + // Set end location + this._leaveAttrValue(); + } + } + else { + this._err(error_codes_ERR.duplicateAttribute); + } + } + _leaveAttrValue() { + if (this.currentLocation) { + this.currentLocation.endLine = this.preprocessor.line; + this.currentLocation.endCol = this.preprocessor.col; + this.currentLocation.endOffset = this.preprocessor.offset; + } + } + //Token emission + prepareToken(ct) { + this._emitCurrentCharacterToken(ct.location); + this.currentToken = null; + if (ct.location) { + ct.location.endLine = this.preprocessor.line; + ct.location.endCol = this.preprocessor.col + 1; + ct.location.endOffset = this.preprocessor.offset + 1; + } + this.currentLocation = this.getCurrentLocation(-1); + } + emitCurrentTagToken() { + const ct = this.currentToken; + this.prepareToken(ct); + ct.tagID = html_getTagID(ct.tagName); + if (ct.type === token_TokenType.START_TAG) { + this.lastStartTagName = ct.tagName; + this.handler.onStartTag(ct); + } + else { + if (ct.attrs.length > 0) { + this._err(error_codes_ERR.endTagWithAttributes); + } + if (ct.selfClosing) { + this._err(error_codes_ERR.endTagWithTrailingSolidus); + } + this.handler.onEndTag(ct); + } + this.preprocessor.dropParsedChunk(); + } + emitCurrentComment(ct) { + this.prepareToken(ct); + this.handler.onComment(ct); + this.preprocessor.dropParsedChunk(); + } + emitCurrentDoctype(ct) { + this.prepareToken(ct); + this.handler.onDoctype(ct); + this.preprocessor.dropParsedChunk(); + } + _emitCurrentCharacterToken(nextLocation) { + if (this.currentCharacterToken) { + //NOTE: if we have a pending character token, make it's end location equal to the + //current token's start location. + if (nextLocation && this.currentCharacterToken.location) { + this.currentCharacterToken.location.endLine = nextLocation.startLine; + this.currentCharacterToken.location.endCol = nextLocation.startCol; + this.currentCharacterToken.location.endOffset = nextLocation.startOffset; + } + switch (this.currentCharacterToken.type) { + case token_TokenType.CHARACTER: { + this.handler.onCharacter(this.currentCharacterToken); + break; + } + case token_TokenType.NULL_CHARACTER: { + this.handler.onNullCharacter(this.currentCharacterToken); + break; + } + case token_TokenType.WHITESPACE_CHARACTER: { + this.handler.onWhitespaceCharacter(this.currentCharacterToken); + break; + } + } + this.currentCharacterToken = null; + } + } + _emitEOFToken() { + const location = this.getCurrentLocation(0); + if (location) { + location.endLine = location.startLine; + location.endCol = location.startCol; + location.endOffset = location.startOffset; + } + this._emitCurrentCharacterToken(location); + this.handler.onEof({ type: token_TokenType.EOF, location }); + this.active = false; + } + //Characters emission + //OPTIMIZATION: specification uses only one type of character tokens (one token per character). + //This causes a huge memory overhead and a lot of unnecessary parser loops. parse5 uses 3 groups of characters. + //If we have a sequence of characters that belong to the same group, the parser can process it + //as a single solid character token. + //So, there are 3 types of character tokens in parse5: + //1)TokenType.NULL_CHARACTER - \u0000-character sequences (e.g. '\u0000\u0000\u0000') + //2)TokenType.WHITESPACE_CHARACTER - any whitespace/new-line character sequences (e.g. '\n \r\t \f') + //3)TokenType.CHARACTER - any character sequence which don't belong to groups 1 and 2 (e.g. 'abcdef1234@@#$%^') + _appendCharToCurrentCharacterToken(type, ch) { + if (this.currentCharacterToken) { + if (this.currentCharacterToken.type !== type) { + this.currentLocation = this.getCurrentLocation(0); + this._emitCurrentCharacterToken(this.currentLocation); + this.preprocessor.dropParsedChunk(); + } + else { + this.currentCharacterToken.chars += ch; + return; + } + } + this._createCharacterToken(type, ch); + } + _emitCodePoint(cp) { + const type = isWhitespace(cp) + ? token_TokenType.WHITESPACE_CHARACTER + : cp === CODE_POINTS.NULL + ? token_TokenType.NULL_CHARACTER + : token_TokenType.CHARACTER; + this._appendCharToCurrentCharacterToken(type, String.fromCodePoint(cp)); + } + //NOTE: used when we emit characters explicitly. + //This is always for non-whitespace and non-null characters, which allows us to avoid additional checks. + _emitChars(ch) { + this._appendCharToCurrentCharacterToken(token_TokenType.CHARACTER, ch); + } + // Character reference helpers + _matchNamedCharacterReference(cp) { + let result = null; + let excess = 0; + let withoutSemicolon = false; + for (let i = 0, current = decode_data_html[0]; i >= 0; cp = this._consume()) { + i = determineBranch(decode_data_html, current, i + 1, cp); + if (i < 0) + break; + excess += 1; + current = decode_data_html[i]; + const masked = current & BinTrieFlags.VALUE_LENGTH; + // If the branch is a value, store it and continue + if (masked) { + // The mask is the number of bytes of the value, including the current byte. + const valueLength = (masked >> 14) - 1; + // Attribute values that aren't terminated properly aren't parsed, and shouldn't lead to a parser error. + // See the example in https://html.spec.whatwg.org/multipage/parsing.html#named-character-reference-state + if (cp !== CODE_POINTS.SEMICOLON && + this._isCharacterReferenceInAttribute() && + tokenizer_isEntityInAttributeInvalidEnd(this.preprocessor.peek(1))) { + //NOTE: we don't flush all consumed code points here, and instead switch back to the original state after + //emitting an ampersand. This is fine, as alphanumeric characters won't be parsed differently in attributes. + result = [CODE_POINTS.AMPERSAND]; + // Skip over the value. + i += valueLength; + } + else { + // If this is a surrogate pair, consume the next two bytes. + result = + valueLength === 0 + ? [decode_data_html[i] & ~BinTrieFlags.VALUE_LENGTH] + : valueLength === 1 + ? [decode_data_html[++i]] + : [decode_data_html[++i], decode_data_html[++i]]; + excess = 0; + withoutSemicolon = cp !== CODE_POINTS.SEMICOLON; + } + if (valueLength === 0) { + // If the value is zero-length, we're done. + this._consume(); + break; + } + } + } + this._unconsume(excess); + if (withoutSemicolon && !this.preprocessor.endOfChunkHit) { + this._err(error_codes_ERR.missingSemicolonAfterCharacterReference); + } + // We want to emit the error above on the code point after the entity. + // We always consume one code point too many in the loop, and we wait to + // unconsume it until after the error is emitted. + this._unconsume(1); + return result; + } + _isCharacterReferenceInAttribute() { + return (this.returnState === State.ATTRIBUTE_VALUE_DOUBLE_QUOTED || + this.returnState === State.ATTRIBUTE_VALUE_SINGLE_QUOTED || + this.returnState === State.ATTRIBUTE_VALUE_UNQUOTED); + } + _flushCodePointConsumedAsCharacterReference(cp) { + if (this._isCharacterReferenceInAttribute()) { + this.currentAttr.value += String.fromCodePoint(cp); + } + else { + this._emitCodePoint(cp); + } + } + // Calling states this way turns out to be much faster than any other approach. + _callState(cp) { + switch (this.state) { + case State.DATA: { + this._stateData(cp); + break; + } + case State.RCDATA: { + this._stateRcdata(cp); + break; + } + case State.RAWTEXT: { + this._stateRawtext(cp); + break; + } + case State.SCRIPT_DATA: { + this._stateScriptData(cp); + break; + } + case State.PLAINTEXT: { + this._statePlaintext(cp); + break; + } + case State.TAG_OPEN: { + this._stateTagOpen(cp); + break; + } + case State.END_TAG_OPEN: { + this._stateEndTagOpen(cp); + break; + } + case State.TAG_NAME: { + this._stateTagName(cp); + break; + } + case State.RCDATA_LESS_THAN_SIGN: { + this._stateRcdataLessThanSign(cp); + break; + } + case State.RCDATA_END_TAG_OPEN: { + this._stateRcdataEndTagOpen(cp); + break; + } + case State.RCDATA_END_TAG_NAME: { + this._stateRcdataEndTagName(cp); + break; + } + case State.RAWTEXT_LESS_THAN_SIGN: { + this._stateRawtextLessThanSign(cp); + break; + } + case State.RAWTEXT_END_TAG_OPEN: { + this._stateRawtextEndTagOpen(cp); + break; + } + case State.RAWTEXT_END_TAG_NAME: { + this._stateRawtextEndTagName(cp); + break; + } + case State.SCRIPT_DATA_LESS_THAN_SIGN: { + this._stateScriptDataLessThanSign(cp); + break; + } + case State.SCRIPT_DATA_END_TAG_OPEN: { + this._stateScriptDataEndTagOpen(cp); + break; + } + case State.SCRIPT_DATA_END_TAG_NAME: { + this._stateScriptDataEndTagName(cp); + break; + } + case State.SCRIPT_DATA_ESCAPE_START: { + this._stateScriptDataEscapeStart(cp); + break; + } + case State.SCRIPT_DATA_ESCAPE_START_DASH: { + this._stateScriptDataEscapeStartDash(cp); + break; + } + case State.SCRIPT_DATA_ESCAPED: { + this._stateScriptDataEscaped(cp); + break; + } + case State.SCRIPT_DATA_ESCAPED_DASH: { + this._stateScriptDataEscapedDash(cp); + break; + } + case State.SCRIPT_DATA_ESCAPED_DASH_DASH: { + this._stateScriptDataEscapedDashDash(cp); + break; + } + case State.SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN: { + this._stateScriptDataEscapedLessThanSign(cp); + break; + } + case State.SCRIPT_DATA_ESCAPED_END_TAG_OPEN: { + this._stateScriptDataEscapedEndTagOpen(cp); + break; + } + case State.SCRIPT_DATA_ESCAPED_END_TAG_NAME: { + this._stateScriptDataEscapedEndTagName(cp); + break; + } + case State.SCRIPT_DATA_DOUBLE_ESCAPE_START: { + this._stateScriptDataDoubleEscapeStart(cp); + break; + } + case State.SCRIPT_DATA_DOUBLE_ESCAPED: { + this._stateScriptDataDoubleEscaped(cp); + break; + } + case State.SCRIPT_DATA_DOUBLE_ESCAPED_DASH: { + this._stateScriptDataDoubleEscapedDash(cp); + break; + } + case State.SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH: { + this._stateScriptDataDoubleEscapedDashDash(cp); + break; + } + case State.SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN: { + this._stateScriptDataDoubleEscapedLessThanSign(cp); + break; + } + case State.SCRIPT_DATA_DOUBLE_ESCAPE_END: { + this._stateScriptDataDoubleEscapeEnd(cp); + break; + } + case State.BEFORE_ATTRIBUTE_NAME: { + this._stateBeforeAttributeName(cp); + break; + } + case State.ATTRIBUTE_NAME: { + this._stateAttributeName(cp); + break; + } + case State.AFTER_ATTRIBUTE_NAME: { + this._stateAfterAttributeName(cp); + break; + } + case State.BEFORE_ATTRIBUTE_VALUE: { + this._stateBeforeAttributeValue(cp); + break; + } + case State.ATTRIBUTE_VALUE_DOUBLE_QUOTED: { + this._stateAttributeValueDoubleQuoted(cp); + break; + } + case State.ATTRIBUTE_VALUE_SINGLE_QUOTED: { + this._stateAttributeValueSingleQuoted(cp); + break; + } + case State.ATTRIBUTE_VALUE_UNQUOTED: { + this._stateAttributeValueUnquoted(cp); + break; + } + case State.AFTER_ATTRIBUTE_VALUE_QUOTED: { + this._stateAfterAttributeValueQuoted(cp); + break; + } + case State.SELF_CLOSING_START_TAG: { + this._stateSelfClosingStartTag(cp); + break; + } + case State.BOGUS_COMMENT: { + this._stateBogusComment(cp); + break; + } + case State.MARKUP_DECLARATION_OPEN: { + this._stateMarkupDeclarationOpen(cp); + break; + } + case State.COMMENT_START: { + this._stateCommentStart(cp); + break; + } + case State.COMMENT_START_DASH: { + this._stateCommentStartDash(cp); + break; + } + case State.COMMENT: { + this._stateComment(cp); + break; + } + case State.COMMENT_LESS_THAN_SIGN: { + this._stateCommentLessThanSign(cp); + break; + } + case State.COMMENT_LESS_THAN_SIGN_BANG: { + this._stateCommentLessThanSignBang(cp); + break; + } + case State.COMMENT_LESS_THAN_SIGN_BANG_DASH: { + this._stateCommentLessThanSignBangDash(cp); + break; + } + case State.COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH: { + this._stateCommentLessThanSignBangDashDash(cp); + break; + } + case State.COMMENT_END_DASH: { + this._stateCommentEndDash(cp); + break; + } + case State.COMMENT_END: { + this._stateCommentEnd(cp); + break; + } + case State.COMMENT_END_BANG: { + this._stateCommentEndBang(cp); + break; + } + case State.DOCTYPE: { + this._stateDoctype(cp); + break; + } + case State.BEFORE_DOCTYPE_NAME: { + this._stateBeforeDoctypeName(cp); + break; + } + case State.DOCTYPE_NAME: { + this._stateDoctypeName(cp); + break; + } + case State.AFTER_DOCTYPE_NAME: { + this._stateAfterDoctypeName(cp); + break; + } + case State.AFTER_DOCTYPE_PUBLIC_KEYWORD: { + this._stateAfterDoctypePublicKeyword(cp); + break; + } + case State.BEFORE_DOCTYPE_PUBLIC_IDENTIFIER: { + this._stateBeforeDoctypePublicIdentifier(cp); + break; + } + case State.DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED: { + this._stateDoctypePublicIdentifierDoubleQuoted(cp); + break; + } + case State.DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED: { + this._stateDoctypePublicIdentifierSingleQuoted(cp); + break; + } + case State.AFTER_DOCTYPE_PUBLIC_IDENTIFIER: { + this._stateAfterDoctypePublicIdentifier(cp); + break; + } + case State.BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS: { + this._stateBetweenDoctypePublicAndSystemIdentifiers(cp); + break; + } + case State.AFTER_DOCTYPE_SYSTEM_KEYWORD: { + this._stateAfterDoctypeSystemKeyword(cp); + break; + } + case State.BEFORE_DOCTYPE_SYSTEM_IDENTIFIER: { + this._stateBeforeDoctypeSystemIdentifier(cp); + break; + } + case State.DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED: { + this._stateDoctypeSystemIdentifierDoubleQuoted(cp); + break; + } + case State.DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED: { + this._stateDoctypeSystemIdentifierSingleQuoted(cp); + break; + } + case State.AFTER_DOCTYPE_SYSTEM_IDENTIFIER: { + this._stateAfterDoctypeSystemIdentifier(cp); + break; + } + case State.BOGUS_DOCTYPE: { + this._stateBogusDoctype(cp); + break; + } + case State.CDATA_SECTION: { + this._stateCdataSection(cp); + break; + } + case State.CDATA_SECTION_BRACKET: { + this._stateCdataSectionBracket(cp); + break; + } + case State.CDATA_SECTION_END: { + this._stateCdataSectionEnd(cp); + break; + } + case State.CHARACTER_REFERENCE: { + this._stateCharacterReference(cp); + break; + } + case State.NAMED_CHARACTER_REFERENCE: { + this._stateNamedCharacterReference(cp); + break; + } + case State.AMBIGUOUS_AMPERSAND: { + this._stateAmbiguousAmpersand(cp); + break; + } + case State.NUMERIC_CHARACTER_REFERENCE: { + this._stateNumericCharacterReference(cp); + break; + } + case State.HEXADEMICAL_CHARACTER_REFERENCE_START: { + this._stateHexademicalCharacterReferenceStart(cp); + break; + } + case State.HEXADEMICAL_CHARACTER_REFERENCE: { + this._stateHexademicalCharacterReference(cp); + break; + } + case State.DECIMAL_CHARACTER_REFERENCE: { + this._stateDecimalCharacterReference(cp); + break; + } + case State.NUMERIC_CHARACTER_REFERENCE_END: { + this._stateNumericCharacterReferenceEnd(cp); + break; + } + default: { + throw new Error('Unknown state'); + } + } + } + // State machine + // Data state + //------------------------------------------------------------------ + _stateData(cp) { + switch (cp) { + case CODE_POINTS.LESS_THAN_SIGN: { + this.state = State.TAG_OPEN; + break; + } + case CODE_POINTS.AMPERSAND: { + this.returnState = State.DATA; + this.state = State.CHARACTER_REFERENCE; + break; + } + case CODE_POINTS.NULL: { + this._err(error_codes_ERR.unexpectedNullCharacter); + this._emitCodePoint(cp); + break; + } + case CODE_POINTS.EOF: { + this._emitEOFToken(); + break; + } + default: { + this._emitCodePoint(cp); + } + } + } + // RCDATA state + //------------------------------------------------------------------ + _stateRcdata(cp) { + switch (cp) { + case CODE_POINTS.AMPERSAND: { + this.returnState = State.RCDATA; + this.state = State.CHARACTER_REFERENCE; + break; + } + case CODE_POINTS.LESS_THAN_SIGN: { + this.state = State.RCDATA_LESS_THAN_SIGN; + break; + } + case CODE_POINTS.NULL: { + this._err(error_codes_ERR.unexpectedNullCharacter); + this._emitChars(REPLACEMENT_CHARACTER); + break; + } + case CODE_POINTS.EOF: { + this._emitEOFToken(); + break; + } + default: { + this._emitCodePoint(cp); + } + } + } + // RAWTEXT state + //------------------------------------------------------------------ + _stateRawtext(cp) { + switch (cp) { + case CODE_POINTS.LESS_THAN_SIGN: { + this.state = State.RAWTEXT_LESS_THAN_SIGN; + break; + } + case CODE_POINTS.NULL: { + this._err(error_codes_ERR.unexpectedNullCharacter); + this._emitChars(REPLACEMENT_CHARACTER); + break; + } + case CODE_POINTS.EOF: { + this._emitEOFToken(); + break; + } + default: { + this._emitCodePoint(cp); + } + } + } + // Script data state + //------------------------------------------------------------------ + _stateScriptData(cp) { + switch (cp) { + case CODE_POINTS.LESS_THAN_SIGN: { + this.state = State.SCRIPT_DATA_LESS_THAN_SIGN; + break; + } + case CODE_POINTS.NULL: { + this._err(error_codes_ERR.unexpectedNullCharacter); + this._emitChars(REPLACEMENT_CHARACTER); + break; + } + case CODE_POINTS.EOF: { + this._emitEOFToken(); + break; + } + default: { + this._emitCodePoint(cp); + } + } + } + // PLAINTEXT state + //------------------------------------------------------------------ + _statePlaintext(cp) { + switch (cp) { + case CODE_POINTS.NULL: { + this._err(error_codes_ERR.unexpectedNullCharacter); + this._emitChars(REPLACEMENT_CHARACTER); + break; + } + case CODE_POINTS.EOF: { + this._emitEOFToken(); + break; + } + default: { + this._emitCodePoint(cp); + } + } + } + // Tag open state + //------------------------------------------------------------------ + _stateTagOpen(cp) { + if (isAsciiLetter(cp)) { + this._createStartTagToken(); + this.state = State.TAG_NAME; + this._stateTagName(cp); + } + else + switch (cp) { + case CODE_POINTS.EXCLAMATION_MARK: { + this.state = State.MARKUP_DECLARATION_OPEN; + break; + } + case CODE_POINTS.SOLIDUS: { + this.state = State.END_TAG_OPEN; + break; + } + case CODE_POINTS.QUESTION_MARK: { + this._err(error_codes_ERR.unexpectedQuestionMarkInsteadOfTagName); + this._createCommentToken(1); + this.state = State.BOGUS_COMMENT; + this._stateBogusComment(cp); + break; + } + case CODE_POINTS.EOF: { + this._err(error_codes_ERR.eofBeforeTagName); + this._emitChars('<'); + this._emitEOFToken(); + break; + } + default: { + this._err(error_codes_ERR.invalidFirstCharacterOfTagName); + this._emitChars('<'); + this.state = State.DATA; + this._stateData(cp); + } + } + } + // End tag open state + //------------------------------------------------------------------ + _stateEndTagOpen(cp) { + if (isAsciiLetter(cp)) { + this._createEndTagToken(); + this.state = State.TAG_NAME; + this._stateTagName(cp); + } + else + switch (cp) { + case CODE_POINTS.GREATER_THAN_SIGN: { + this._err(error_codes_ERR.missingEndTagName); + this.state = State.DATA; + break; + } + case CODE_POINTS.EOF: { + this._err(error_codes_ERR.eofBeforeTagName); + this._emitChars(''); + break; + } + case CODE_POINTS.NULL: { + this._err(error_codes_ERR.unexpectedNullCharacter); + this.state = State.SCRIPT_DATA_ESCAPED; + this._emitChars(REPLACEMENT_CHARACTER); + break; + } + case CODE_POINTS.EOF: { + this._err(error_codes_ERR.eofInScriptHtmlCommentLikeText); + this._emitEOFToken(); + break; + } + default: { + this.state = State.SCRIPT_DATA_ESCAPED; + this._emitCodePoint(cp); + } + } + } + // Script data escaped less-than sign state + //------------------------------------------------------------------ + _stateScriptDataEscapedLessThanSign(cp) { + if (cp === CODE_POINTS.SOLIDUS) { + this.state = State.SCRIPT_DATA_ESCAPED_END_TAG_OPEN; + } + else if (isAsciiLetter(cp)) { + this._emitChars('<'); + this.state = State.SCRIPT_DATA_DOUBLE_ESCAPE_START; + this._stateScriptDataDoubleEscapeStart(cp); + } + else { + this._emitChars('<'); + this.state = State.SCRIPT_DATA_ESCAPED; + this._stateScriptDataEscaped(cp); + } + } + // Script data escaped end tag open state + //------------------------------------------------------------------ + _stateScriptDataEscapedEndTagOpen(cp) { + if (isAsciiLetter(cp)) { + this.state = State.SCRIPT_DATA_ESCAPED_END_TAG_NAME; + this._stateScriptDataEscapedEndTagName(cp); + } + else { + this._emitChars(''); + break; + } + case CODE_POINTS.NULL: { + this._err(error_codes_ERR.unexpectedNullCharacter); + this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED; + this._emitChars(REPLACEMENT_CHARACTER); + break; + } + case CODE_POINTS.EOF: { + this._err(error_codes_ERR.eofInScriptHtmlCommentLikeText); + this._emitEOFToken(); + break; + } + default: { + this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED; + this._emitCodePoint(cp); + } + } + } + // Script data double escaped less-than sign state + //------------------------------------------------------------------ + _stateScriptDataDoubleEscapedLessThanSign(cp) { + if (cp === CODE_POINTS.SOLIDUS) { + this.state = State.SCRIPT_DATA_DOUBLE_ESCAPE_END; + this._emitChars('/'); + } + else { + this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED; + this._stateScriptDataDoubleEscaped(cp); + } + } + // Script data double escape end state + //------------------------------------------------------------------ + _stateScriptDataDoubleEscapeEnd(cp) { + if (this.preprocessor.startsWith(SEQUENCES.SCRIPT, false) && + isScriptDataDoubleEscapeSequenceEnd(this.preprocessor.peek(SEQUENCES.SCRIPT.length))) { + this._emitCodePoint(cp); + for (let i = 0; i < SEQUENCES.SCRIPT.length; i++) { + this._emitCodePoint(this._consume()); + } + this.state = State.SCRIPT_DATA_ESCAPED; + } + else if (!this._ensureHibernation()) { + this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED; + this._stateScriptDataDoubleEscaped(cp); + } + } + // Before attribute name state + //------------------------------------------------------------------ + _stateBeforeAttributeName(cp) { + switch (cp) { + case CODE_POINTS.SPACE: + case CODE_POINTS.LINE_FEED: + case CODE_POINTS.TABULATION: + case CODE_POINTS.FORM_FEED: { + // Ignore whitespace + break; + } + case CODE_POINTS.SOLIDUS: + case CODE_POINTS.GREATER_THAN_SIGN: + case CODE_POINTS.EOF: { + this.state = State.AFTER_ATTRIBUTE_NAME; + this._stateAfterAttributeName(cp); + break; + } + case CODE_POINTS.EQUALS_SIGN: { + this._err(error_codes_ERR.unexpectedEqualsSignBeforeAttributeName); + this._createAttr('='); + this.state = State.ATTRIBUTE_NAME; + break; + } + default: { + this._createAttr(''); + this.state = State.ATTRIBUTE_NAME; + this._stateAttributeName(cp); + } + } + } + // Attribute name state + //------------------------------------------------------------------ + _stateAttributeName(cp) { + switch (cp) { + case CODE_POINTS.SPACE: + case CODE_POINTS.LINE_FEED: + case CODE_POINTS.TABULATION: + case CODE_POINTS.FORM_FEED: + case CODE_POINTS.SOLIDUS: + case CODE_POINTS.GREATER_THAN_SIGN: + case CODE_POINTS.EOF: { + this._leaveAttrName(); + this.state = State.AFTER_ATTRIBUTE_NAME; + this._stateAfterAttributeName(cp); + break; + } + case CODE_POINTS.EQUALS_SIGN: { + this._leaveAttrName(); + this.state = State.BEFORE_ATTRIBUTE_VALUE; + break; + } + case CODE_POINTS.QUOTATION_MARK: + case CODE_POINTS.APOSTROPHE: + case CODE_POINTS.LESS_THAN_SIGN: { + this._err(error_codes_ERR.unexpectedCharacterInAttributeName); + this.currentAttr.name += String.fromCodePoint(cp); + break; + } + case CODE_POINTS.NULL: { + this._err(error_codes_ERR.unexpectedNullCharacter); + this.currentAttr.name += REPLACEMENT_CHARACTER; + break; + } + default: { + this.currentAttr.name += String.fromCodePoint(isAsciiUpper(cp) ? toAsciiLower(cp) : cp); + } + } + } + // After attribute name state + //------------------------------------------------------------------ + _stateAfterAttributeName(cp) { + switch (cp) { + case CODE_POINTS.SPACE: + case CODE_POINTS.LINE_FEED: + case CODE_POINTS.TABULATION: + case CODE_POINTS.FORM_FEED: { + // Ignore whitespace + break; + } + case CODE_POINTS.SOLIDUS: { + this.state = State.SELF_CLOSING_START_TAG; + break; + } + case CODE_POINTS.EQUALS_SIGN: { + this.state = State.BEFORE_ATTRIBUTE_VALUE; + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this.state = State.DATA; + this.emitCurrentTagToken(); + break; + } + case CODE_POINTS.EOF: { + this._err(error_codes_ERR.eofInTag); + this._emitEOFToken(); + break; + } + default: { + this._createAttr(''); + this.state = State.ATTRIBUTE_NAME; + this._stateAttributeName(cp); + } + } + } + // Before attribute value state + //------------------------------------------------------------------ + _stateBeforeAttributeValue(cp) { + switch (cp) { + case CODE_POINTS.SPACE: + case CODE_POINTS.LINE_FEED: + case CODE_POINTS.TABULATION: + case CODE_POINTS.FORM_FEED: { + // Ignore whitespace + break; + } + case CODE_POINTS.QUOTATION_MARK: { + this.state = State.ATTRIBUTE_VALUE_DOUBLE_QUOTED; + break; + } + case CODE_POINTS.APOSTROPHE: { + this.state = State.ATTRIBUTE_VALUE_SINGLE_QUOTED; + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this._err(error_codes_ERR.missingAttributeValue); + this.state = State.DATA; + this.emitCurrentTagToken(); + break; + } + default: { + this.state = State.ATTRIBUTE_VALUE_UNQUOTED; + this._stateAttributeValueUnquoted(cp); + } + } + } + // Attribute value (double-quoted) state + //------------------------------------------------------------------ + _stateAttributeValueDoubleQuoted(cp) { + switch (cp) { + case CODE_POINTS.QUOTATION_MARK: { + this.state = State.AFTER_ATTRIBUTE_VALUE_QUOTED; + break; + } + case CODE_POINTS.AMPERSAND: { + this.returnState = State.ATTRIBUTE_VALUE_DOUBLE_QUOTED; + this.state = State.CHARACTER_REFERENCE; + break; + } + case CODE_POINTS.NULL: { + this._err(error_codes_ERR.unexpectedNullCharacter); + this.currentAttr.value += REPLACEMENT_CHARACTER; + break; + } + case CODE_POINTS.EOF: { + this._err(error_codes_ERR.eofInTag); + this._emitEOFToken(); + break; + } + default: { + this.currentAttr.value += String.fromCodePoint(cp); + } + } + } + // Attribute value (single-quoted) state + //------------------------------------------------------------------ + _stateAttributeValueSingleQuoted(cp) { + switch (cp) { + case CODE_POINTS.APOSTROPHE: { + this.state = State.AFTER_ATTRIBUTE_VALUE_QUOTED; + break; + } + case CODE_POINTS.AMPERSAND: { + this.returnState = State.ATTRIBUTE_VALUE_SINGLE_QUOTED; + this.state = State.CHARACTER_REFERENCE; + break; + } + case CODE_POINTS.NULL: { + this._err(error_codes_ERR.unexpectedNullCharacter); + this.currentAttr.value += REPLACEMENT_CHARACTER; + break; + } + case CODE_POINTS.EOF: { + this._err(error_codes_ERR.eofInTag); + this._emitEOFToken(); + break; + } + default: { + this.currentAttr.value += String.fromCodePoint(cp); + } + } + } + // Attribute value (unquoted) state + //------------------------------------------------------------------ + _stateAttributeValueUnquoted(cp) { + switch (cp) { + case CODE_POINTS.SPACE: + case CODE_POINTS.LINE_FEED: + case CODE_POINTS.TABULATION: + case CODE_POINTS.FORM_FEED: { + this._leaveAttrValue(); + this.state = State.BEFORE_ATTRIBUTE_NAME; + break; + } + case CODE_POINTS.AMPERSAND: { + this.returnState = State.ATTRIBUTE_VALUE_UNQUOTED; + this.state = State.CHARACTER_REFERENCE; + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this._leaveAttrValue(); + this.state = State.DATA; + this.emitCurrentTagToken(); + break; + } + case CODE_POINTS.NULL: { + this._err(error_codes_ERR.unexpectedNullCharacter); + this.currentAttr.value += REPLACEMENT_CHARACTER; + break; + } + case CODE_POINTS.QUOTATION_MARK: + case CODE_POINTS.APOSTROPHE: + case CODE_POINTS.LESS_THAN_SIGN: + case CODE_POINTS.EQUALS_SIGN: + case CODE_POINTS.GRAVE_ACCENT: { + this._err(error_codes_ERR.unexpectedCharacterInUnquotedAttributeValue); + this.currentAttr.value += String.fromCodePoint(cp); + break; + } + case CODE_POINTS.EOF: { + this._err(error_codes_ERR.eofInTag); + this._emitEOFToken(); + break; + } + default: { + this.currentAttr.value += String.fromCodePoint(cp); + } + } + } + // After attribute value (quoted) state + //------------------------------------------------------------------ + _stateAfterAttributeValueQuoted(cp) { + switch (cp) { + case CODE_POINTS.SPACE: + case CODE_POINTS.LINE_FEED: + case CODE_POINTS.TABULATION: + case CODE_POINTS.FORM_FEED: { + this._leaveAttrValue(); + this.state = State.BEFORE_ATTRIBUTE_NAME; + break; + } + case CODE_POINTS.SOLIDUS: { + this._leaveAttrValue(); + this.state = State.SELF_CLOSING_START_TAG; + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this._leaveAttrValue(); + this.state = State.DATA; + this.emitCurrentTagToken(); + break; + } + case CODE_POINTS.EOF: { + this._err(error_codes_ERR.eofInTag); + this._emitEOFToken(); + break; + } + default: { + this._err(error_codes_ERR.missingWhitespaceBetweenAttributes); + this.state = State.BEFORE_ATTRIBUTE_NAME; + this._stateBeforeAttributeName(cp); + } + } + } + // Self-closing start tag state + //------------------------------------------------------------------ + _stateSelfClosingStartTag(cp) { + switch (cp) { + case CODE_POINTS.GREATER_THAN_SIGN: { + const token = this.currentToken; + token.selfClosing = true; + this.state = State.DATA; + this.emitCurrentTagToken(); + break; + } + case CODE_POINTS.EOF: { + this._err(error_codes_ERR.eofInTag); + this._emitEOFToken(); + break; + } + default: { + this._err(error_codes_ERR.unexpectedSolidusInTag); + this.state = State.BEFORE_ATTRIBUTE_NAME; + this._stateBeforeAttributeName(cp); + } + } + } + // Bogus comment state + //------------------------------------------------------------------ + _stateBogusComment(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.GREATER_THAN_SIGN: { + this.state = State.DATA; + this.emitCurrentComment(token); + break; + } + case CODE_POINTS.EOF: { + this.emitCurrentComment(token); + this._emitEOFToken(); + break; + } + case CODE_POINTS.NULL: { + this._err(error_codes_ERR.unexpectedNullCharacter); + token.data += REPLACEMENT_CHARACTER; + break; + } + default: { + token.data += String.fromCodePoint(cp); + } + } + } + // Markup declaration open state + //------------------------------------------------------------------ + _stateMarkupDeclarationOpen(cp) { + if (this._consumeSequenceIfMatch(SEQUENCES.DASH_DASH, true)) { + this._createCommentToken(SEQUENCES.DASH_DASH.length + 1); + this.state = State.COMMENT_START; + } + else if (this._consumeSequenceIfMatch(SEQUENCES.DOCTYPE, false)) { + // NOTE: Doctypes tokens are created without fixed offsets. We keep track of the moment a doctype *might* start here. + this.currentLocation = this.getCurrentLocation(SEQUENCES.DOCTYPE.length + 1); + this.state = State.DOCTYPE; + } + else if (this._consumeSequenceIfMatch(SEQUENCES.CDATA_START, true)) { + if (this.inForeignNode) { + this.state = State.CDATA_SECTION; + } + else { + this._err(error_codes_ERR.cdataInHtmlContent); + this._createCommentToken(SEQUENCES.CDATA_START.length + 1); + this.currentToken.data = '[CDATA['; + this.state = State.BOGUS_COMMENT; + } + } + //NOTE: Sequence lookups can be abrupted by hibernation. In that case, lookup + //results are no longer valid and we will need to start over. + else if (!this._ensureHibernation()) { + this._err(error_codes_ERR.incorrectlyOpenedComment); + this._createCommentToken(2); + this.state = State.BOGUS_COMMENT; + this._stateBogusComment(cp); + } + } + // Comment start state + //------------------------------------------------------------------ + _stateCommentStart(cp) { + switch (cp) { + case CODE_POINTS.HYPHEN_MINUS: { + this.state = State.COMMENT_START_DASH; + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this._err(error_codes_ERR.abruptClosingOfEmptyComment); + this.state = State.DATA; + const token = this.currentToken; + this.emitCurrentComment(token); + break; + } + default: { + this.state = State.COMMENT; + this._stateComment(cp); + } + } + } + // Comment start dash state + //------------------------------------------------------------------ + _stateCommentStartDash(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.HYPHEN_MINUS: { + this.state = State.COMMENT_END; + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this._err(error_codes_ERR.abruptClosingOfEmptyComment); + this.state = State.DATA; + this.emitCurrentComment(token); + break; + } + case CODE_POINTS.EOF: { + this._err(error_codes_ERR.eofInComment); + this.emitCurrentComment(token); + this._emitEOFToken(); + break; + } + default: { + token.data += '-'; + this.state = State.COMMENT; + this._stateComment(cp); + } + } + } + // Comment state + //------------------------------------------------------------------ + _stateComment(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.HYPHEN_MINUS: { + this.state = State.COMMENT_END_DASH; + break; + } + case CODE_POINTS.LESS_THAN_SIGN: { + token.data += '<'; + this.state = State.COMMENT_LESS_THAN_SIGN; + break; + } + case CODE_POINTS.NULL: { + this._err(error_codes_ERR.unexpectedNullCharacter); + token.data += REPLACEMENT_CHARACTER; + break; + } + case CODE_POINTS.EOF: { + this._err(error_codes_ERR.eofInComment); + this.emitCurrentComment(token); + this._emitEOFToken(); + break; + } + default: { + token.data += String.fromCodePoint(cp); + } + } + } + // Comment less-than sign state + //------------------------------------------------------------------ + _stateCommentLessThanSign(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.EXCLAMATION_MARK: { + token.data += '!'; + this.state = State.COMMENT_LESS_THAN_SIGN_BANG; + break; + } + case CODE_POINTS.LESS_THAN_SIGN: { + token.data += '<'; + break; + } + default: { + this.state = State.COMMENT; + this._stateComment(cp); + } + } + } + // Comment less-than sign bang state + //------------------------------------------------------------------ + _stateCommentLessThanSignBang(cp) { + if (cp === CODE_POINTS.HYPHEN_MINUS) { + this.state = State.COMMENT_LESS_THAN_SIGN_BANG_DASH; + } + else { + this.state = State.COMMENT; + this._stateComment(cp); + } + } + // Comment less-than sign bang dash state + //------------------------------------------------------------------ + _stateCommentLessThanSignBangDash(cp) { + if (cp === CODE_POINTS.HYPHEN_MINUS) { + this.state = State.COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH; + } + else { + this.state = State.COMMENT_END_DASH; + this._stateCommentEndDash(cp); + } + } + // Comment less-than sign bang dash dash state + //------------------------------------------------------------------ + _stateCommentLessThanSignBangDashDash(cp) { + if (cp !== CODE_POINTS.GREATER_THAN_SIGN && cp !== CODE_POINTS.EOF) { + this._err(error_codes_ERR.nestedComment); + } + this.state = State.COMMENT_END; + this._stateCommentEnd(cp); + } + // Comment end dash state + //------------------------------------------------------------------ + _stateCommentEndDash(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.HYPHEN_MINUS: { + this.state = State.COMMENT_END; + break; + } + case CODE_POINTS.EOF: { + this._err(error_codes_ERR.eofInComment); + this.emitCurrentComment(token); + this._emitEOFToken(); + break; + } + default: { + token.data += '-'; + this.state = State.COMMENT; + this._stateComment(cp); + } + } + } + // Comment end state + //------------------------------------------------------------------ + _stateCommentEnd(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.GREATER_THAN_SIGN: { + this.state = State.DATA; + this.emitCurrentComment(token); + break; + } + case CODE_POINTS.EXCLAMATION_MARK: { + this.state = State.COMMENT_END_BANG; + break; + } + case CODE_POINTS.HYPHEN_MINUS: { + token.data += '-'; + break; + } + case CODE_POINTS.EOF: { + this._err(error_codes_ERR.eofInComment); + this.emitCurrentComment(token); + this._emitEOFToken(); + break; + } + default: { + token.data += '--'; + this.state = State.COMMENT; + this._stateComment(cp); + } + } + } + // Comment end bang state + //------------------------------------------------------------------ + _stateCommentEndBang(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.HYPHEN_MINUS: { + token.data += '--!'; + this.state = State.COMMENT_END_DASH; + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this._err(error_codes_ERR.incorrectlyClosedComment); + this.state = State.DATA; + this.emitCurrentComment(token); + break; + } + case CODE_POINTS.EOF: { + this._err(error_codes_ERR.eofInComment); + this.emitCurrentComment(token); + this._emitEOFToken(); + break; + } + default: { + token.data += '--!'; + this.state = State.COMMENT; + this._stateComment(cp); + } + } + } + // DOCTYPE state + //------------------------------------------------------------------ + _stateDoctype(cp) { + switch (cp) { + case CODE_POINTS.SPACE: + case CODE_POINTS.LINE_FEED: + case CODE_POINTS.TABULATION: + case CODE_POINTS.FORM_FEED: { + this.state = State.BEFORE_DOCTYPE_NAME; + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this.state = State.BEFORE_DOCTYPE_NAME; + this._stateBeforeDoctypeName(cp); + break; + } + case CODE_POINTS.EOF: { + this._err(error_codes_ERR.eofInDoctype); + this._createDoctypeToken(null); + const token = this.currentToken; + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this._emitEOFToken(); + break; + } + default: { + this._err(error_codes_ERR.missingWhitespaceBeforeDoctypeName); + this.state = State.BEFORE_DOCTYPE_NAME; + this._stateBeforeDoctypeName(cp); + } + } + } + // Before DOCTYPE name state + //------------------------------------------------------------------ + _stateBeforeDoctypeName(cp) { + if (isAsciiUpper(cp)) { + this._createDoctypeToken(String.fromCharCode(toAsciiLower(cp))); + this.state = State.DOCTYPE_NAME; + } + else + switch (cp) { + case CODE_POINTS.SPACE: + case CODE_POINTS.LINE_FEED: + case CODE_POINTS.TABULATION: + case CODE_POINTS.FORM_FEED: { + // Ignore whitespace + break; + } + case CODE_POINTS.NULL: { + this._err(error_codes_ERR.unexpectedNullCharacter); + this._createDoctypeToken(REPLACEMENT_CHARACTER); + this.state = State.DOCTYPE_NAME; + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this._err(error_codes_ERR.missingDoctypeName); + this._createDoctypeToken(null); + const token = this.currentToken; + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this.state = State.DATA; + break; + } + case CODE_POINTS.EOF: { + this._err(error_codes_ERR.eofInDoctype); + this._createDoctypeToken(null); + const token = this.currentToken; + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this._emitEOFToken(); + break; + } + default: { + this._createDoctypeToken(String.fromCodePoint(cp)); + this.state = State.DOCTYPE_NAME; + } + } + } + // DOCTYPE name state + //------------------------------------------------------------------ + _stateDoctypeName(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.SPACE: + case CODE_POINTS.LINE_FEED: + case CODE_POINTS.TABULATION: + case CODE_POINTS.FORM_FEED: { + this.state = State.AFTER_DOCTYPE_NAME; + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this.state = State.DATA; + this.emitCurrentDoctype(token); + break; + } + case CODE_POINTS.NULL: { + this._err(error_codes_ERR.unexpectedNullCharacter); + token.name += REPLACEMENT_CHARACTER; + break; + } + case CODE_POINTS.EOF: { + this._err(error_codes_ERR.eofInDoctype); + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this._emitEOFToken(); + break; + } + default: { + token.name += String.fromCodePoint(isAsciiUpper(cp) ? toAsciiLower(cp) : cp); + } + } + } + // After DOCTYPE name state + //------------------------------------------------------------------ + _stateAfterDoctypeName(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.SPACE: + case CODE_POINTS.LINE_FEED: + case CODE_POINTS.TABULATION: + case CODE_POINTS.FORM_FEED: { + // Ignore whitespace + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this.state = State.DATA; + this.emitCurrentDoctype(token); + break; + } + case CODE_POINTS.EOF: { + this._err(error_codes_ERR.eofInDoctype); + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this._emitEOFToken(); + break; + } + default: { + if (this._consumeSequenceIfMatch(SEQUENCES.PUBLIC, false)) { + this.state = State.AFTER_DOCTYPE_PUBLIC_KEYWORD; + } + else if (this._consumeSequenceIfMatch(SEQUENCES.SYSTEM, false)) { + this.state = State.AFTER_DOCTYPE_SYSTEM_KEYWORD; + } + //NOTE: sequence lookup can be abrupted by hibernation. In that case lookup + //results are no longer valid and we will need to start over. + else if (!this._ensureHibernation()) { + this._err(error_codes_ERR.invalidCharacterSequenceAfterDoctypeName); + token.forceQuirks = true; + this.state = State.BOGUS_DOCTYPE; + this._stateBogusDoctype(cp); + } + } + } + } + // After DOCTYPE public keyword state + //------------------------------------------------------------------ + _stateAfterDoctypePublicKeyword(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.SPACE: + case CODE_POINTS.LINE_FEED: + case CODE_POINTS.TABULATION: + case CODE_POINTS.FORM_FEED: { + this.state = State.BEFORE_DOCTYPE_PUBLIC_IDENTIFIER; + break; + } + case CODE_POINTS.QUOTATION_MARK: { + this._err(error_codes_ERR.missingWhitespaceAfterDoctypePublicKeyword); + token.publicId = ''; + this.state = State.DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED; + break; + } + case CODE_POINTS.APOSTROPHE: { + this._err(error_codes_ERR.missingWhitespaceAfterDoctypePublicKeyword); + token.publicId = ''; + this.state = State.DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED; + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this._err(error_codes_ERR.missingDoctypePublicIdentifier); + token.forceQuirks = true; + this.state = State.DATA; + this.emitCurrentDoctype(token); + break; + } + case CODE_POINTS.EOF: { + this._err(error_codes_ERR.eofInDoctype); + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this._emitEOFToken(); + break; + } + default: { + this._err(error_codes_ERR.missingQuoteBeforeDoctypePublicIdentifier); + token.forceQuirks = true; + this.state = State.BOGUS_DOCTYPE; + this._stateBogusDoctype(cp); + } + } + } + // Before DOCTYPE public identifier state + //------------------------------------------------------------------ + _stateBeforeDoctypePublicIdentifier(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.SPACE: + case CODE_POINTS.LINE_FEED: + case CODE_POINTS.TABULATION: + case CODE_POINTS.FORM_FEED: { + // Ignore whitespace + break; + } + case CODE_POINTS.QUOTATION_MARK: { + token.publicId = ''; + this.state = State.DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED; + break; + } + case CODE_POINTS.APOSTROPHE: { + token.publicId = ''; + this.state = State.DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED; + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this._err(error_codes_ERR.missingDoctypePublicIdentifier); + token.forceQuirks = true; + this.state = State.DATA; + this.emitCurrentDoctype(token); + break; + } + case CODE_POINTS.EOF: { + this._err(error_codes_ERR.eofInDoctype); + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this._emitEOFToken(); + break; + } + default: { + this._err(error_codes_ERR.missingQuoteBeforeDoctypePublicIdentifier); + token.forceQuirks = true; + this.state = State.BOGUS_DOCTYPE; + this._stateBogusDoctype(cp); + } + } + } + // DOCTYPE public identifier (double-quoted) state + //------------------------------------------------------------------ + _stateDoctypePublicIdentifierDoubleQuoted(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.QUOTATION_MARK: { + this.state = State.AFTER_DOCTYPE_PUBLIC_IDENTIFIER; + break; + } + case CODE_POINTS.NULL: { + this._err(error_codes_ERR.unexpectedNullCharacter); + token.publicId += REPLACEMENT_CHARACTER; + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this._err(error_codes_ERR.abruptDoctypePublicIdentifier); + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this.state = State.DATA; + break; + } + case CODE_POINTS.EOF: { + this._err(error_codes_ERR.eofInDoctype); + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this._emitEOFToken(); + break; + } + default: { + token.publicId += String.fromCodePoint(cp); + } + } + } + // DOCTYPE public identifier (single-quoted) state + //------------------------------------------------------------------ + _stateDoctypePublicIdentifierSingleQuoted(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.APOSTROPHE: { + this.state = State.AFTER_DOCTYPE_PUBLIC_IDENTIFIER; + break; + } + case CODE_POINTS.NULL: { + this._err(error_codes_ERR.unexpectedNullCharacter); + token.publicId += REPLACEMENT_CHARACTER; + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this._err(error_codes_ERR.abruptDoctypePublicIdentifier); + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this.state = State.DATA; + break; + } + case CODE_POINTS.EOF: { + this._err(error_codes_ERR.eofInDoctype); + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this._emitEOFToken(); + break; + } + default: { + token.publicId += String.fromCodePoint(cp); + } + } + } + // After DOCTYPE public identifier state + //------------------------------------------------------------------ + _stateAfterDoctypePublicIdentifier(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.SPACE: + case CODE_POINTS.LINE_FEED: + case CODE_POINTS.TABULATION: + case CODE_POINTS.FORM_FEED: { + this.state = State.BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS; + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this.state = State.DATA; + this.emitCurrentDoctype(token); + break; + } + case CODE_POINTS.QUOTATION_MARK: { + this._err(error_codes_ERR.missingWhitespaceBetweenDoctypePublicAndSystemIdentifiers); + token.systemId = ''; + this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED; + break; + } + case CODE_POINTS.APOSTROPHE: { + this._err(error_codes_ERR.missingWhitespaceBetweenDoctypePublicAndSystemIdentifiers); + token.systemId = ''; + this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED; + break; + } + case CODE_POINTS.EOF: { + this._err(error_codes_ERR.eofInDoctype); + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this._emitEOFToken(); + break; + } + default: { + this._err(error_codes_ERR.missingQuoteBeforeDoctypeSystemIdentifier); + token.forceQuirks = true; + this.state = State.BOGUS_DOCTYPE; + this._stateBogusDoctype(cp); + } + } + } + // Between DOCTYPE public and system identifiers state + //------------------------------------------------------------------ + _stateBetweenDoctypePublicAndSystemIdentifiers(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.SPACE: + case CODE_POINTS.LINE_FEED: + case CODE_POINTS.TABULATION: + case CODE_POINTS.FORM_FEED: { + // Ignore whitespace + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this.emitCurrentDoctype(token); + this.state = State.DATA; + break; + } + case CODE_POINTS.QUOTATION_MARK: { + token.systemId = ''; + this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED; + break; + } + case CODE_POINTS.APOSTROPHE: { + token.systemId = ''; + this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED; + break; + } + case CODE_POINTS.EOF: { + this._err(error_codes_ERR.eofInDoctype); + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this._emitEOFToken(); + break; + } + default: { + this._err(error_codes_ERR.missingQuoteBeforeDoctypeSystemIdentifier); + token.forceQuirks = true; + this.state = State.BOGUS_DOCTYPE; + this._stateBogusDoctype(cp); + } + } + } + // After DOCTYPE system keyword state + //------------------------------------------------------------------ + _stateAfterDoctypeSystemKeyword(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.SPACE: + case CODE_POINTS.LINE_FEED: + case CODE_POINTS.TABULATION: + case CODE_POINTS.FORM_FEED: { + this.state = State.BEFORE_DOCTYPE_SYSTEM_IDENTIFIER; + break; + } + case CODE_POINTS.QUOTATION_MARK: { + this._err(error_codes_ERR.missingWhitespaceAfterDoctypeSystemKeyword); + token.systemId = ''; + this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED; + break; + } + case CODE_POINTS.APOSTROPHE: { + this._err(error_codes_ERR.missingWhitespaceAfterDoctypeSystemKeyword); + token.systemId = ''; + this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED; + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this._err(error_codes_ERR.missingDoctypeSystemIdentifier); + token.forceQuirks = true; + this.state = State.DATA; + this.emitCurrentDoctype(token); + break; + } + case CODE_POINTS.EOF: { + this._err(error_codes_ERR.eofInDoctype); + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this._emitEOFToken(); + break; + } + default: { + this._err(error_codes_ERR.missingQuoteBeforeDoctypeSystemIdentifier); + token.forceQuirks = true; + this.state = State.BOGUS_DOCTYPE; + this._stateBogusDoctype(cp); + } + } + } + // Before DOCTYPE system identifier state + //------------------------------------------------------------------ + _stateBeforeDoctypeSystemIdentifier(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.SPACE: + case CODE_POINTS.LINE_FEED: + case CODE_POINTS.TABULATION: + case CODE_POINTS.FORM_FEED: { + // Ignore whitespace + break; + } + case CODE_POINTS.QUOTATION_MARK: { + token.systemId = ''; + this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED; + break; + } + case CODE_POINTS.APOSTROPHE: { + token.systemId = ''; + this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED; + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this._err(error_codes_ERR.missingDoctypeSystemIdentifier); + token.forceQuirks = true; + this.state = State.DATA; + this.emitCurrentDoctype(token); + break; + } + case CODE_POINTS.EOF: { + this._err(error_codes_ERR.eofInDoctype); + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this._emitEOFToken(); + break; + } + default: { + this._err(error_codes_ERR.missingQuoteBeforeDoctypeSystemIdentifier); + token.forceQuirks = true; + this.state = State.BOGUS_DOCTYPE; + this._stateBogusDoctype(cp); + } + } + } + // DOCTYPE system identifier (double-quoted) state + //------------------------------------------------------------------ + _stateDoctypeSystemIdentifierDoubleQuoted(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.QUOTATION_MARK: { + this.state = State.AFTER_DOCTYPE_SYSTEM_IDENTIFIER; + break; + } + case CODE_POINTS.NULL: { + this._err(error_codes_ERR.unexpectedNullCharacter); + token.systemId += REPLACEMENT_CHARACTER; + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this._err(error_codes_ERR.abruptDoctypeSystemIdentifier); + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this.state = State.DATA; + break; + } + case CODE_POINTS.EOF: { + this._err(error_codes_ERR.eofInDoctype); + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this._emitEOFToken(); + break; + } + default: { + token.systemId += String.fromCodePoint(cp); + } + } + } + // DOCTYPE system identifier (single-quoted) state + //------------------------------------------------------------------ + _stateDoctypeSystemIdentifierSingleQuoted(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.APOSTROPHE: { + this.state = State.AFTER_DOCTYPE_SYSTEM_IDENTIFIER; + break; + } + case CODE_POINTS.NULL: { + this._err(error_codes_ERR.unexpectedNullCharacter); + token.systemId += REPLACEMENT_CHARACTER; + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this._err(error_codes_ERR.abruptDoctypeSystemIdentifier); + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this.state = State.DATA; + break; + } + case CODE_POINTS.EOF: { + this._err(error_codes_ERR.eofInDoctype); + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this._emitEOFToken(); + break; + } + default: { + token.systemId += String.fromCodePoint(cp); + } + } + } + // After DOCTYPE system identifier state + //------------------------------------------------------------------ + _stateAfterDoctypeSystemIdentifier(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.SPACE: + case CODE_POINTS.LINE_FEED: + case CODE_POINTS.TABULATION: + case CODE_POINTS.FORM_FEED: { + // Ignore whitespace + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this.emitCurrentDoctype(token); + this.state = State.DATA; + break; + } + case CODE_POINTS.EOF: { + this._err(error_codes_ERR.eofInDoctype); + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this._emitEOFToken(); + break; + } + default: { + this._err(error_codes_ERR.unexpectedCharacterAfterDoctypeSystemIdentifier); + this.state = State.BOGUS_DOCTYPE; + this._stateBogusDoctype(cp); + } + } + } + // Bogus DOCTYPE state + //------------------------------------------------------------------ + _stateBogusDoctype(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.GREATER_THAN_SIGN: { + this.emitCurrentDoctype(token); + this.state = State.DATA; + break; + } + case CODE_POINTS.NULL: { + this._err(error_codes_ERR.unexpectedNullCharacter); + break; + } + case CODE_POINTS.EOF: { + this.emitCurrentDoctype(token); + this._emitEOFToken(); + break; + } + default: + // Do nothing + } + } + // CDATA section state + //------------------------------------------------------------------ + _stateCdataSection(cp) { + switch (cp) { + case CODE_POINTS.RIGHT_SQUARE_BRACKET: { + this.state = State.CDATA_SECTION_BRACKET; + break; + } + case CODE_POINTS.EOF: { + this._err(error_codes_ERR.eofInCdata); + this._emitEOFToken(); + break; + } + default: { + this._emitCodePoint(cp); + } + } + } + // CDATA section bracket state + //------------------------------------------------------------------ + _stateCdataSectionBracket(cp) { + if (cp === CODE_POINTS.RIGHT_SQUARE_BRACKET) { + this.state = State.CDATA_SECTION_END; + } + else { + this._emitChars(']'); + this.state = State.CDATA_SECTION; + this._stateCdataSection(cp); + } + } + // CDATA section end state + //------------------------------------------------------------------ + _stateCdataSectionEnd(cp) { + switch (cp) { + case CODE_POINTS.GREATER_THAN_SIGN: { + this.state = State.DATA; + break; + } + case CODE_POINTS.RIGHT_SQUARE_BRACKET: { + this._emitChars(']'); + break; + } + default: { + this._emitChars(']]'); + this.state = State.CDATA_SECTION; + this._stateCdataSection(cp); + } + } + } + // Character reference state + //------------------------------------------------------------------ + _stateCharacterReference(cp) { + if (cp === CODE_POINTS.NUMBER_SIGN) { + this.state = State.NUMERIC_CHARACTER_REFERENCE; + } + else if (tokenizer_isAsciiAlphaNumeric(cp)) { + this.state = State.NAMED_CHARACTER_REFERENCE; + this._stateNamedCharacterReference(cp); + } + else { + this._flushCodePointConsumedAsCharacterReference(CODE_POINTS.AMPERSAND); + this._reconsumeInState(this.returnState, cp); + } + } + // Named character reference state + //------------------------------------------------------------------ + _stateNamedCharacterReference(cp) { + const matchResult = this._matchNamedCharacterReference(cp); + //NOTE: Matching can be abrupted by hibernation. In that case, match + //results are no longer valid and we will need to start over. + if (this._ensureHibernation()) { + // Stay in the state, try again. + } + else if (matchResult) { + for (let i = 0; i < matchResult.length; i++) { + this._flushCodePointConsumedAsCharacterReference(matchResult[i]); + } + this.state = this.returnState; + } + else { + this._flushCodePointConsumedAsCharacterReference(CODE_POINTS.AMPERSAND); + this.state = State.AMBIGUOUS_AMPERSAND; + } + } + // Ambiguos ampersand state + //------------------------------------------------------------------ + _stateAmbiguousAmpersand(cp) { + if (tokenizer_isAsciiAlphaNumeric(cp)) { + this._flushCodePointConsumedAsCharacterReference(cp); + } + else { + if (cp === CODE_POINTS.SEMICOLON) { + this._err(error_codes_ERR.unknownNamedCharacterReference); + } + this._reconsumeInState(this.returnState, cp); + } + } + // Numeric character reference state + //------------------------------------------------------------------ + _stateNumericCharacterReference(cp) { + this.charRefCode = 0; + if (cp === CODE_POINTS.LATIN_SMALL_X || cp === CODE_POINTS.LATIN_CAPITAL_X) { + this.state = State.HEXADEMICAL_CHARACTER_REFERENCE_START; + } + // Inlined decimal character reference start state + else if (isAsciiDigit(cp)) { + this.state = State.DECIMAL_CHARACTER_REFERENCE; + this._stateDecimalCharacterReference(cp); + } + else { + this._err(error_codes_ERR.absenceOfDigitsInNumericCharacterReference); + this._flushCodePointConsumedAsCharacterReference(CODE_POINTS.AMPERSAND); + this._flushCodePointConsumedAsCharacterReference(CODE_POINTS.NUMBER_SIGN); + this._reconsumeInState(this.returnState, cp); + } + } + // Hexademical character reference start state + //------------------------------------------------------------------ + _stateHexademicalCharacterReferenceStart(cp) { + if (isAsciiHexDigit(cp)) { + this.state = State.HEXADEMICAL_CHARACTER_REFERENCE; + this._stateHexademicalCharacterReference(cp); + } + else { + this._err(error_codes_ERR.absenceOfDigitsInNumericCharacterReference); + this._flushCodePointConsumedAsCharacterReference(CODE_POINTS.AMPERSAND); + this._flushCodePointConsumedAsCharacterReference(CODE_POINTS.NUMBER_SIGN); + this._unconsume(2); + this.state = this.returnState; + } + } + // Hexademical character reference state + //------------------------------------------------------------------ + _stateHexademicalCharacterReference(cp) { + if (isAsciiUpperHexDigit(cp)) { + this.charRefCode = this.charRefCode * 16 + cp - 0x37; + } + else if (isAsciiLowerHexDigit(cp)) { + this.charRefCode = this.charRefCode * 16 + cp - 0x57; + } + else if (isAsciiDigit(cp)) { + this.charRefCode = this.charRefCode * 16 + cp - 0x30; + } + else if (cp === CODE_POINTS.SEMICOLON) { + this.state = State.NUMERIC_CHARACTER_REFERENCE_END; + } + else { + this._err(error_codes_ERR.missingSemicolonAfterCharacterReference); + this.state = State.NUMERIC_CHARACTER_REFERENCE_END; + this._stateNumericCharacterReferenceEnd(cp); + } + } + // Decimal character reference state + //------------------------------------------------------------------ + _stateDecimalCharacterReference(cp) { + if (isAsciiDigit(cp)) { + this.charRefCode = this.charRefCode * 10 + cp - 0x30; + } + else if (cp === CODE_POINTS.SEMICOLON) { + this.state = State.NUMERIC_CHARACTER_REFERENCE_END; + } + else { + this._err(error_codes_ERR.missingSemicolonAfterCharacterReference); + this.state = State.NUMERIC_CHARACTER_REFERENCE_END; + this._stateNumericCharacterReferenceEnd(cp); + } + } + // Numeric character reference end state + //------------------------------------------------------------------ + _stateNumericCharacterReferenceEnd(cp) { + if (this.charRefCode === CODE_POINTS.NULL) { + this._err(error_codes_ERR.nullCharacterReference); + this.charRefCode = CODE_POINTS.REPLACEMENT_CHARACTER; + } + else if (this.charRefCode > 1114111) { + this._err(error_codes_ERR.characterReferenceOutsideUnicodeRange); + this.charRefCode = CODE_POINTS.REPLACEMENT_CHARACTER; + } + else if (isSurrogate(this.charRefCode)) { + this._err(error_codes_ERR.surrogateCharacterReference); + this.charRefCode = CODE_POINTS.REPLACEMENT_CHARACTER; + } + else if (isUndefinedCodePoint(this.charRefCode)) { + this._err(error_codes_ERR.noncharacterCharacterReference); + } + else if (isControlCodePoint(this.charRefCode) || this.charRefCode === CODE_POINTS.CARRIAGE_RETURN) { + this._err(error_codes_ERR.controlCharacterReference); + const replacement = C1_CONTROLS_REFERENCE_REPLACEMENTS.get(this.charRefCode); + if (replacement !== undefined) { + this.charRefCode = replacement; + } + } + this._flushCodePointConsumedAsCharacterReference(this.charRefCode); + this._reconsumeInState(this.returnState, cp); + } +} +//# sourceMappingURL=index.js.map +;// CONCATENATED MODULE: ./node_modules/parse5/dist/parser/open-element-stack.js + +//Element utils +const IMPLICIT_END_TAG_REQUIRED = new Set([TAG_ID.DD, TAG_ID.DT, TAG_ID.LI, TAG_ID.OPTGROUP, TAG_ID.OPTION, TAG_ID.P, TAG_ID.RB, TAG_ID.RP, TAG_ID.RT, TAG_ID.RTC]); +const IMPLICIT_END_TAG_REQUIRED_THOROUGHLY = new Set([ + ...IMPLICIT_END_TAG_REQUIRED, + TAG_ID.CAPTION, + TAG_ID.COLGROUP, + TAG_ID.TBODY, + TAG_ID.TD, + TAG_ID.TFOOT, + TAG_ID.TH, + TAG_ID.THEAD, + TAG_ID.TR, +]); +const SCOPING_ELEMENT_NS = new Map([ + [TAG_ID.APPLET, html_NS.HTML], + [TAG_ID.CAPTION, html_NS.HTML], + [TAG_ID.HTML, html_NS.HTML], + [TAG_ID.MARQUEE, html_NS.HTML], + [TAG_ID.OBJECT, html_NS.HTML], + [TAG_ID.TABLE, html_NS.HTML], + [TAG_ID.TD, html_NS.HTML], + [TAG_ID.TEMPLATE, html_NS.HTML], + [TAG_ID.TH, html_NS.HTML], + [TAG_ID.ANNOTATION_XML, html_NS.MATHML], + [TAG_ID.MI, html_NS.MATHML], + [TAG_ID.MN, html_NS.MATHML], + [TAG_ID.MO, html_NS.MATHML], + [TAG_ID.MS, html_NS.MATHML], + [TAG_ID.MTEXT, html_NS.MATHML], + [TAG_ID.DESC, html_NS.SVG], + [TAG_ID.FOREIGN_OBJECT, html_NS.SVG], + [TAG_ID.TITLE, html_NS.SVG], +]); +const NAMED_HEADERS = [TAG_ID.H1, TAG_ID.H2, TAG_ID.H3, TAG_ID.H4, TAG_ID.H5, TAG_ID.H6]; +const TABLE_ROW_CONTEXT = [TAG_ID.TR, TAG_ID.TEMPLATE, TAG_ID.HTML]; +const TABLE_BODY_CONTEXT = [TAG_ID.TBODY, TAG_ID.TFOOT, TAG_ID.THEAD, TAG_ID.TEMPLATE, TAG_ID.HTML]; +const TABLE_CONTEXT = [TAG_ID.TABLE, TAG_ID.TEMPLATE, TAG_ID.HTML]; +const TABLE_CELLS = [TAG_ID.TD, TAG_ID.TH]; +//Stack of open elements +class open_element_stack_OpenElementStack { + get currentTmplContentOrNode() { + return this._isInTemplate() ? this.treeAdapter.getTemplateContent(this.current) : this.current; + } + constructor(document, treeAdapter, handler) { + this.treeAdapter = treeAdapter; + this.handler = handler; + this.items = []; + this.tagIDs = []; + this.stackTop = -1; + this.tmplCount = 0; + this.currentTagId = $.UNKNOWN; + this.current = document; + } + //Index of element + _indexOf(element) { + return this.items.lastIndexOf(element, this.stackTop); + } + //Update current element + _isInTemplate() { + return this.currentTagId === $.TEMPLATE && this.treeAdapter.getNamespaceURI(this.current) === NS.HTML; + } + _updateCurrentElement() { + this.current = this.items[this.stackTop]; + this.currentTagId = this.tagIDs[this.stackTop]; + } + //Mutations + push(element, tagID) { + this.stackTop++; + this.items[this.stackTop] = element; + this.current = element; + this.tagIDs[this.stackTop] = tagID; + this.currentTagId = tagID; + if (this._isInTemplate()) { + this.tmplCount++; + } + this.handler.onItemPush(element, tagID, true); + } + pop() { + const popped = this.current; + if (this.tmplCount > 0 && this._isInTemplate()) { + this.tmplCount--; + } + this.stackTop--; + this._updateCurrentElement(); + this.handler.onItemPop(popped, true); + } + replace(oldElement, newElement) { + const idx = this._indexOf(oldElement); + this.items[idx] = newElement; + if (idx === this.stackTop) { + this.current = newElement; + } + } + insertAfter(referenceElement, newElement, newElementID) { + const insertionIdx = this._indexOf(referenceElement) + 1; + this.items.splice(insertionIdx, 0, newElement); + this.tagIDs.splice(insertionIdx, 0, newElementID); + this.stackTop++; + if (insertionIdx === this.stackTop) { + this._updateCurrentElement(); + } + this.handler.onItemPush(this.current, this.currentTagId, insertionIdx === this.stackTop); + } + popUntilTagNamePopped(tagName) { + let targetIdx = this.stackTop + 1; + do { + targetIdx = this.tagIDs.lastIndexOf(tagName, targetIdx - 1); + } while (targetIdx > 0 && this.treeAdapter.getNamespaceURI(this.items[targetIdx]) !== NS.HTML); + this.shortenToLength(targetIdx < 0 ? 0 : targetIdx); + } + shortenToLength(idx) { + while (this.stackTop >= idx) { + const popped = this.current; + if (this.tmplCount > 0 && this._isInTemplate()) { + this.tmplCount -= 1; + } + this.stackTop--; + this._updateCurrentElement(); + this.handler.onItemPop(popped, this.stackTop < idx); + } + } + popUntilElementPopped(element) { + const idx = this._indexOf(element); + this.shortenToLength(idx < 0 ? 0 : idx); + } + popUntilPopped(tagNames, targetNS) { + const idx = this._indexOfTagNames(tagNames, targetNS); + this.shortenToLength(idx < 0 ? 0 : idx); + } + popUntilNumberedHeaderPopped() { + this.popUntilPopped(NAMED_HEADERS, NS.HTML); + } + popUntilTableCellPopped() { + this.popUntilPopped(TABLE_CELLS, NS.HTML); + } + popAllUpToHtmlElement() { + //NOTE: here we assume that the root element is always first in the open element stack, so + //we perform this fast stack clean up. + this.tmplCount = 0; + this.shortenToLength(1); + } + _indexOfTagNames(tagNames, namespace) { + for (let i = this.stackTop; i >= 0; i--) { + if (tagNames.includes(this.tagIDs[i]) && this.treeAdapter.getNamespaceURI(this.items[i]) === namespace) { + return i; + } + } + return -1; + } + clearBackTo(tagNames, targetNS) { + const idx = this._indexOfTagNames(tagNames, targetNS); + this.shortenToLength(idx + 1); + } + clearBackToTableContext() { + this.clearBackTo(TABLE_CONTEXT, NS.HTML); + } + clearBackToTableBodyContext() { + this.clearBackTo(TABLE_BODY_CONTEXT, NS.HTML); + } + clearBackToTableRowContext() { + this.clearBackTo(TABLE_ROW_CONTEXT, NS.HTML); + } + remove(element) { + const idx = this._indexOf(element); + if (idx >= 0) { + if (idx === this.stackTop) { + this.pop(); + } + else { + this.items.splice(idx, 1); + this.tagIDs.splice(idx, 1); + this.stackTop--; + this._updateCurrentElement(); + this.handler.onItemPop(element, false); + } + } + } + //Search + tryPeekProperlyNestedBodyElement() { + //Properly nested element (should be second element in stack). + return this.stackTop >= 1 && this.tagIDs[1] === $.BODY ? this.items[1] : null; + } + contains(element) { + return this._indexOf(element) > -1; + } + getCommonAncestor(element) { + const elementIdx = this._indexOf(element) - 1; + return elementIdx >= 0 ? this.items[elementIdx] : null; + } + isRootHtmlElementCurrent() { + return this.stackTop === 0 && this.tagIDs[0] === $.HTML; + } + //Element in scope + hasInScope(tagName) { + for (let i = this.stackTop; i >= 0; i--) { + const tn = this.tagIDs[i]; + const ns = this.treeAdapter.getNamespaceURI(this.items[i]); + if (tn === tagName && ns === NS.HTML) { + return true; + } + if (SCOPING_ELEMENT_NS.get(tn) === ns) { + return false; + } + } + return true; + } + hasNumberedHeaderInScope() { + for (let i = this.stackTop; i >= 0; i--) { + const tn = this.tagIDs[i]; + const ns = this.treeAdapter.getNamespaceURI(this.items[i]); + if (isNumberedHeader(tn) && ns === NS.HTML) { + return true; + } + if (SCOPING_ELEMENT_NS.get(tn) === ns) { + return false; + } + } + return true; + } + hasInListItemScope(tagName) { + for (let i = this.stackTop; i >= 0; i--) { + const tn = this.tagIDs[i]; + const ns = this.treeAdapter.getNamespaceURI(this.items[i]); + if (tn === tagName && ns === NS.HTML) { + return true; + } + if (((tn === $.UL || tn === $.OL) && ns === NS.HTML) || SCOPING_ELEMENT_NS.get(tn) === ns) { + return false; + } + } + return true; + } + hasInButtonScope(tagName) { + for (let i = this.stackTop; i >= 0; i--) { + const tn = this.tagIDs[i]; + const ns = this.treeAdapter.getNamespaceURI(this.items[i]); + if (tn === tagName && ns === NS.HTML) { + return true; + } + if ((tn === $.BUTTON && ns === NS.HTML) || SCOPING_ELEMENT_NS.get(tn) === ns) { + return false; + } + } + return true; + } + hasInTableScope(tagName) { + for (let i = this.stackTop; i >= 0; i--) { + const tn = this.tagIDs[i]; + const ns = this.treeAdapter.getNamespaceURI(this.items[i]); + if (ns !== NS.HTML) { + continue; + } + if (tn === tagName) { + return true; + } + if (tn === $.TABLE || tn === $.TEMPLATE || tn === $.HTML) { + return false; + } + } + return true; + } + hasTableBodyContextInTableScope() { + for (let i = this.stackTop; i >= 0; i--) { + const tn = this.tagIDs[i]; + const ns = this.treeAdapter.getNamespaceURI(this.items[i]); + if (ns !== NS.HTML) { + continue; + } + if (tn === $.TBODY || tn === $.THEAD || tn === $.TFOOT) { + return true; + } + if (tn === $.TABLE || tn === $.HTML) { + return false; + } + } + return true; + } + hasInSelectScope(tagName) { + for (let i = this.stackTop; i >= 0; i--) { + const tn = this.tagIDs[i]; + const ns = this.treeAdapter.getNamespaceURI(this.items[i]); + if (ns !== NS.HTML) { + continue; + } + if (tn === tagName) { + return true; + } + if (tn !== $.OPTION && tn !== $.OPTGROUP) { + return false; + } + } + return true; + } + //Implied end tags + generateImpliedEndTags() { + while (IMPLICIT_END_TAG_REQUIRED.has(this.currentTagId)) { + this.pop(); + } + } + generateImpliedEndTagsThoroughly() { + while (IMPLICIT_END_TAG_REQUIRED_THOROUGHLY.has(this.currentTagId)) { + this.pop(); + } + } + generateImpliedEndTagsWithExclusion(exclusionId) { + while (this.currentTagId !== exclusionId && IMPLICIT_END_TAG_REQUIRED_THOROUGHLY.has(this.currentTagId)) { + this.pop(); + } + } +} +//# sourceMappingURL=open-element-stack.js.map +;// CONCATENATED MODULE: ./node_modules/parse5/dist/parser/formatting-element-list.js +//Const +const NOAH_ARK_CAPACITY = 3; +var formatting_element_list_EntryType; +(function (EntryType) { + EntryType[EntryType["Marker"] = 0] = "Marker"; + EntryType[EntryType["Element"] = 1] = "Element"; +})(formatting_element_list_EntryType = formatting_element_list_EntryType || (formatting_element_list_EntryType = {})); +const MARKER = { type: formatting_element_list_EntryType.Marker }; +//List of formatting elements +class formatting_element_list_FormattingElementList { + constructor(treeAdapter) { + this.treeAdapter = treeAdapter; + this.entries = []; + this.bookmark = null; + } + //Noah Ark's condition + //OPTIMIZATION: at first we try to find possible candidates for exclusion using + //lightweight heuristics without thorough attributes check. + _getNoahArkConditionCandidates(newElement, neAttrs) { + const candidates = []; + const neAttrsLength = neAttrs.length; + const neTagName = this.treeAdapter.getTagName(newElement); + const neNamespaceURI = this.treeAdapter.getNamespaceURI(newElement); + for (let i = 0; i < this.entries.length; i++) { + const entry = this.entries[i]; + if (entry.type === formatting_element_list_EntryType.Marker) { + break; + } + const { element } = entry; + if (this.treeAdapter.getTagName(element) === neTagName && + this.treeAdapter.getNamespaceURI(element) === neNamespaceURI) { + const elementAttrs = this.treeAdapter.getAttrList(element); + if (elementAttrs.length === neAttrsLength) { + candidates.push({ idx: i, attrs: elementAttrs }); + } + } + } + return candidates; + } + _ensureNoahArkCondition(newElement) { + if (this.entries.length < NOAH_ARK_CAPACITY) + return; + const neAttrs = this.treeAdapter.getAttrList(newElement); + const candidates = this._getNoahArkConditionCandidates(newElement, neAttrs); + if (candidates.length < NOAH_ARK_CAPACITY) + return; + //NOTE: build attrs map for the new element, so we can perform fast lookups + const neAttrsMap = new Map(neAttrs.map((neAttr) => [neAttr.name, neAttr.value])); + let validCandidates = 0; + //NOTE: remove bottommost candidates, until Noah's Ark condition will not be met + for (let i = 0; i < candidates.length; i++) { + const candidate = candidates[i]; + // We know that `candidate.attrs.length === neAttrs.length` + if (candidate.attrs.every((cAttr) => neAttrsMap.get(cAttr.name) === cAttr.value)) { + validCandidates += 1; + if (validCandidates >= NOAH_ARK_CAPACITY) { + this.entries.splice(candidate.idx, 1); + } + } + } + } + //Mutations + insertMarker() { + this.entries.unshift(MARKER); + } + pushElement(element, token) { + this._ensureNoahArkCondition(element); + this.entries.unshift({ + type: formatting_element_list_EntryType.Element, + element, + token, + }); + } + insertElementAfterBookmark(element, token) { + const bookmarkIdx = this.entries.indexOf(this.bookmark); + this.entries.splice(bookmarkIdx, 0, { + type: formatting_element_list_EntryType.Element, + element, + token, + }); + } + removeEntry(entry) { + const entryIndex = this.entries.indexOf(entry); + if (entryIndex >= 0) { + this.entries.splice(entryIndex, 1); + } + } + /** + * Clears the list of formatting elements up to the last marker. + * + * @see https://html.spec.whatwg.org/multipage/parsing.html#clear-the-list-of-active-formatting-elements-up-to-the-last-marker + */ + clearToLastMarker() { + const markerIdx = this.entries.indexOf(MARKER); + if (markerIdx >= 0) { + this.entries.splice(0, markerIdx + 1); + } + else { + this.entries.length = 0; + } + } + //Search + getElementEntryInScopeWithTagName(tagName) { + const entry = this.entries.find((entry) => entry.type === formatting_element_list_EntryType.Marker || this.treeAdapter.getTagName(entry.element) === tagName); + return entry && entry.type === formatting_element_list_EntryType.Element ? entry : null; + } + getElementEntry(element) { + return this.entries.find((entry) => entry.type === formatting_element_list_EntryType.Element && entry.element === element); + } +} +//# sourceMappingURL=formatting-element-list.js.map +;// CONCATENATED MODULE: ./node_modules/parse5/dist/tree-adapters/default.js + +function createTextNode(value) { + return { + nodeName: '#text', + value, + parentNode: null, + }; +} +const defaultTreeAdapter = { + //Node construction + createDocument() { + return { + nodeName: '#document', + mode: html_DOCUMENT_MODE.NO_QUIRKS, + childNodes: [], + }; + }, + createDocumentFragment() { + return { + nodeName: '#document-fragment', + childNodes: [], + }; + }, + createElement(tagName, namespaceURI, attrs) { + return { + nodeName: tagName, + tagName, + attrs, + namespaceURI, + childNodes: [], + parentNode: null, + }; + }, + createCommentNode(data) { + return { + nodeName: '#comment', + data, + parentNode: null, + }; + }, + //Tree mutation + appendChild(parentNode, newNode) { + parentNode.childNodes.push(newNode); + newNode.parentNode = parentNode; + }, + insertBefore(parentNode, newNode, referenceNode) { + const insertionIdx = parentNode.childNodes.indexOf(referenceNode); + parentNode.childNodes.splice(insertionIdx, 0, newNode); + newNode.parentNode = parentNode; + }, + setTemplateContent(templateElement, contentElement) { + templateElement.content = contentElement; + }, + getTemplateContent(templateElement) { + return templateElement.content; + }, + setDocumentType(document, name, publicId, systemId) { + const doctypeNode = document.childNodes.find((node) => node.nodeName === '#documentType'); + if (doctypeNode) { + doctypeNode.name = name; + doctypeNode.publicId = publicId; + doctypeNode.systemId = systemId; + } + else { + const node = { + nodeName: '#documentType', + name, + publicId, + systemId, + parentNode: null, + }; + defaultTreeAdapter.appendChild(document, node); + } + }, + setDocumentMode(document, mode) { + document.mode = mode; + }, + getDocumentMode(document) { + return document.mode; + }, + detachNode(node) { + if (node.parentNode) { + const idx = node.parentNode.childNodes.indexOf(node); + node.parentNode.childNodes.splice(idx, 1); + node.parentNode = null; + } + }, + insertText(parentNode, text) { + if (parentNode.childNodes.length > 0) { + const prevNode = parentNode.childNodes[parentNode.childNodes.length - 1]; + if (defaultTreeAdapter.isTextNode(prevNode)) { + prevNode.value += text; + return; + } + } + defaultTreeAdapter.appendChild(parentNode, createTextNode(text)); + }, + insertTextBefore(parentNode, text, referenceNode) { + const prevNode = parentNode.childNodes[parentNode.childNodes.indexOf(referenceNode) - 1]; + if (prevNode && defaultTreeAdapter.isTextNode(prevNode)) { + prevNode.value += text; + } + else { + defaultTreeAdapter.insertBefore(parentNode, createTextNode(text), referenceNode); + } + }, + adoptAttributes(recipient, attrs) { + const recipientAttrsMap = new Set(recipient.attrs.map((attr) => attr.name)); + for (let j = 0; j < attrs.length; j++) { + if (!recipientAttrsMap.has(attrs[j].name)) { + recipient.attrs.push(attrs[j]); + } + } + }, + //Tree traversing + getFirstChild(node) { + return node.childNodes[0]; + }, + getChildNodes(node) { + return node.childNodes; + }, + getParentNode(node) { + return node.parentNode; + }, + getAttrList(element) { + return element.attrs; + }, + //Node data + getTagName(element) { + return element.tagName; + }, + getNamespaceURI(element) { + return element.namespaceURI; + }, + getTextNodeContent(textNode) { + return textNode.value; + }, + getCommentNodeContent(commentNode) { + return commentNode.data; + }, + getDocumentTypeNodeName(doctypeNode) { + return doctypeNode.name; + }, + getDocumentTypeNodePublicId(doctypeNode) { + return doctypeNode.publicId; + }, + getDocumentTypeNodeSystemId(doctypeNode) { + return doctypeNode.systemId; + }, + //Node types + isTextNode(node) { + return node.nodeName === '#text'; + }, + isCommentNode(node) { + return node.nodeName === '#comment'; + }, + isDocumentTypeNode(node) { + return node.nodeName === '#documentType'; + }, + isElementNode(node) { + return Object.prototype.hasOwnProperty.call(node, 'tagName'); + }, + // Source code location + setNodeSourceCodeLocation(node, location) { + node.sourceCodeLocation = location; + }, + getNodeSourceCodeLocation(node) { + return node.sourceCodeLocation; + }, + updateNodeSourceCodeLocation(node, endLocation) { + node.sourceCodeLocation = { ...node.sourceCodeLocation, ...endLocation }; + }, +}; +//# sourceMappingURL=default.js.map +;// CONCATENATED MODULE: ./node_modules/parse5/dist/common/doctype.js + +//Const +const VALID_DOCTYPE_NAME = 'html'; +const VALID_SYSTEM_ID = 'about:legacy-compat'; +const QUIRKS_MODE_SYSTEM_ID = 'http://www.ibm.com/data/dtd/v11/ibmxhtml1-transitional.dtd'; +const QUIRKS_MODE_PUBLIC_ID_PREFIXES = [ + '+//silmaril//dtd html pro v0r11 19970101//', + '-//as//dtd html 3.0 aswedit + extensions//', + '-//advasoft ltd//dtd html 3.0 aswedit + extensions//', + '-//ietf//dtd html 2.0 level 1//', + '-//ietf//dtd html 2.0 level 2//', + '-//ietf//dtd html 2.0 strict level 1//', + '-//ietf//dtd html 2.0 strict level 2//', + '-//ietf//dtd html 2.0 strict//', + '-//ietf//dtd html 2.0//', + '-//ietf//dtd html 2.1e//', + '-//ietf//dtd html 3.0//', + '-//ietf//dtd html 3.2 final//', + '-//ietf//dtd html 3.2//', + '-//ietf//dtd html 3//', + '-//ietf//dtd html level 0//', + '-//ietf//dtd html level 1//', + '-//ietf//dtd html level 2//', + '-//ietf//dtd html level 3//', + '-//ietf//dtd html strict level 0//', + '-//ietf//dtd html strict level 1//', + '-//ietf//dtd html strict level 2//', + '-//ietf//dtd html strict level 3//', + '-//ietf//dtd html strict//', + '-//ietf//dtd html//', + '-//metrius//dtd metrius presentational//', + '-//microsoft//dtd internet explorer 2.0 html strict//', + '-//microsoft//dtd internet explorer 2.0 html//', + '-//microsoft//dtd internet explorer 2.0 tables//', + '-//microsoft//dtd internet explorer 3.0 html strict//', + '-//microsoft//dtd internet explorer 3.0 html//', + '-//microsoft//dtd internet explorer 3.0 tables//', + '-//netscape comm. corp.//dtd html//', + '-//netscape comm. corp.//dtd strict html//', + "-//o'reilly and associates//dtd html 2.0//", + "-//o'reilly and associates//dtd html extended 1.0//", + "-//o'reilly and associates//dtd html extended relaxed 1.0//", + '-//sq//dtd html 2.0 hotmetal + extensions//', + '-//softquad software//dtd hotmetal pro 6.0::19990601::extensions to html 4.0//', + '-//softquad//dtd hotmetal pro 4.0::19971010::extensions to html 4.0//', + '-//spyglass//dtd html 2.0 extended//', + '-//sun microsystems corp.//dtd hotjava html//', + '-//sun microsystems corp.//dtd hotjava strict html//', + '-//w3c//dtd html 3 1995-03-24//', + '-//w3c//dtd html 3.2 draft//', + '-//w3c//dtd html 3.2 final//', + '-//w3c//dtd html 3.2//', + '-//w3c//dtd html 3.2s draft//', + '-//w3c//dtd html 4.0 frameset//', + '-//w3c//dtd html 4.0 transitional//', + '-//w3c//dtd html experimental 19960712//', + '-//w3c//dtd html experimental 970421//', + '-//w3c//dtd w3 html//', + '-//w3o//dtd w3 html 3.0//', + '-//webtechs//dtd mozilla html 2.0//', + '-//webtechs//dtd mozilla html//', +]; +const QUIRKS_MODE_NO_SYSTEM_ID_PUBLIC_ID_PREFIXES = [ + ...QUIRKS_MODE_PUBLIC_ID_PREFIXES, + '-//w3c//dtd html 4.01 frameset//', + '-//w3c//dtd html 4.01 transitional//', +]; +const QUIRKS_MODE_PUBLIC_IDS = new Set([ + '-//w3o//dtd w3 html strict 3.0//en//', + '-/w3c/dtd html 4.0 transitional/en', + 'html', +]); +const LIMITED_QUIRKS_PUBLIC_ID_PREFIXES = ['-//w3c//dtd xhtml 1.0 frameset//', '-//w3c//dtd xhtml 1.0 transitional//']; +const LIMITED_QUIRKS_WITH_SYSTEM_ID_PUBLIC_ID_PREFIXES = [ + ...LIMITED_QUIRKS_PUBLIC_ID_PREFIXES, + '-//w3c//dtd html 4.01 frameset//', + '-//w3c//dtd html 4.01 transitional//', +]; +//Utils +function hasPrefix(publicId, prefixes) { + return prefixes.some((prefix) => publicId.startsWith(prefix)); +} +//API +function isConforming(token) { + return (token.name === VALID_DOCTYPE_NAME && + token.publicId === null && + (token.systemId === null || token.systemId === VALID_SYSTEM_ID)); +} +function getDocumentMode(token) { + if (token.name !== VALID_DOCTYPE_NAME) { + return DOCUMENT_MODE.QUIRKS; + } + const { systemId } = token; + if (systemId && systemId.toLowerCase() === QUIRKS_MODE_SYSTEM_ID) { + return DOCUMENT_MODE.QUIRKS; + } + let { publicId } = token; + if (publicId !== null) { + publicId = publicId.toLowerCase(); + if (QUIRKS_MODE_PUBLIC_IDS.has(publicId)) { + return DOCUMENT_MODE.QUIRKS; + } + let prefixes = systemId === null ? QUIRKS_MODE_NO_SYSTEM_ID_PUBLIC_ID_PREFIXES : QUIRKS_MODE_PUBLIC_ID_PREFIXES; + if (hasPrefix(publicId, prefixes)) { + return DOCUMENT_MODE.QUIRKS; + } + prefixes = + systemId === null ? LIMITED_QUIRKS_PUBLIC_ID_PREFIXES : LIMITED_QUIRKS_WITH_SYSTEM_ID_PUBLIC_ID_PREFIXES; + if (hasPrefix(publicId, prefixes)) { + return DOCUMENT_MODE.LIMITED_QUIRKS; + } + } + return DOCUMENT_MODE.NO_QUIRKS; +} +//# sourceMappingURL=doctype.js.map +;// CONCATENATED MODULE: ./node_modules/parse5/dist/common/foreign-content.js + +//MIME types +const MIME_TYPES = { + TEXT_HTML: 'text/html', + APPLICATION_XML: 'application/xhtml+xml', +}; +//Attributes +const DEFINITION_URL_ATTR = 'definitionurl'; +const ADJUSTED_DEFINITION_URL_ATTR = 'definitionURL'; +const SVG_ATTRS_ADJUSTMENT_MAP = new Map([ + 'attributeName', + 'attributeType', + 'baseFrequency', + 'baseProfile', + 'calcMode', + 'clipPathUnits', + 'diffuseConstant', + 'edgeMode', + 'filterUnits', + 'glyphRef', + 'gradientTransform', + 'gradientUnits', + 'kernelMatrix', + 'kernelUnitLength', + 'keyPoints', + 'keySplines', + 'keyTimes', + 'lengthAdjust', + 'limitingConeAngle', + 'markerHeight', + 'markerUnits', + 'markerWidth', + 'maskContentUnits', + 'maskUnits', + 'numOctaves', + 'pathLength', + 'patternContentUnits', + 'patternTransform', + 'patternUnits', + 'pointsAtX', + 'pointsAtY', + 'pointsAtZ', + 'preserveAlpha', + 'preserveAspectRatio', + 'primitiveUnits', + 'refX', + 'refY', + 'repeatCount', + 'repeatDur', + 'requiredExtensions', + 'requiredFeatures', + 'specularConstant', + 'specularExponent', + 'spreadMethod', + 'startOffset', + 'stdDeviation', + 'stitchTiles', + 'surfaceScale', + 'systemLanguage', + 'tableValues', + 'targetX', + 'targetY', + 'textLength', + 'viewBox', + 'viewTarget', + 'xChannelSelector', + 'yChannelSelector', + 'zoomAndPan', +].map((attr) => [attr.toLowerCase(), attr])); +const XML_ATTRS_ADJUSTMENT_MAP = new Map([ + ['xlink:actuate', { prefix: 'xlink', name: 'actuate', namespace: html_NS.XLINK }], + ['xlink:arcrole', { prefix: 'xlink', name: 'arcrole', namespace: html_NS.XLINK }], + ['xlink:href', { prefix: 'xlink', name: 'href', namespace: html_NS.XLINK }], + ['xlink:role', { prefix: 'xlink', name: 'role', namespace: html_NS.XLINK }], + ['xlink:show', { prefix: 'xlink', name: 'show', namespace: html_NS.XLINK }], + ['xlink:title', { prefix: 'xlink', name: 'title', namespace: html_NS.XLINK }], + ['xlink:type', { prefix: 'xlink', name: 'type', namespace: html_NS.XLINK }], + ['xml:base', { prefix: 'xml', name: 'base', namespace: html_NS.XML }], + ['xml:lang', { prefix: 'xml', name: 'lang', namespace: html_NS.XML }], + ['xml:space', { prefix: 'xml', name: 'space', namespace: html_NS.XML }], + ['xmlns', { prefix: '', name: 'xmlns', namespace: html_NS.XMLNS }], + ['xmlns:xlink', { prefix: 'xmlns', name: 'xlink', namespace: html_NS.XMLNS }], +]); +//SVG tag names adjustment map +const SVG_TAG_NAMES_ADJUSTMENT_MAP = new Map([ + 'altGlyph', + 'altGlyphDef', + 'altGlyphItem', + 'animateColor', + 'animateMotion', + 'animateTransform', + 'clipPath', + 'feBlend', + 'feColorMatrix', + 'feComponentTransfer', + 'feComposite', + 'feConvolveMatrix', + 'feDiffuseLighting', + 'feDisplacementMap', + 'feDistantLight', + 'feFlood', + 'feFuncA', + 'feFuncB', + 'feFuncG', + 'feFuncR', + 'feGaussianBlur', + 'feImage', + 'feMerge', + 'feMergeNode', + 'feMorphology', + 'feOffset', + 'fePointLight', + 'feSpecularLighting', + 'feSpotLight', + 'feTile', + 'feTurbulence', + 'foreignObject', + 'glyphRef', + 'linearGradient', + 'radialGradient', + 'textPath', +].map((tn) => [tn.toLowerCase(), tn])); +//Tags that causes exit from foreign content +const EXITS_FOREIGN_CONTENT = new Set([ + TAG_ID.B, + TAG_ID.BIG, + TAG_ID.BLOCKQUOTE, + TAG_ID.BODY, + TAG_ID.BR, + TAG_ID.CENTER, + TAG_ID.CODE, + TAG_ID.DD, + TAG_ID.DIV, + TAG_ID.DL, + TAG_ID.DT, + TAG_ID.EM, + TAG_ID.EMBED, + TAG_ID.H1, + TAG_ID.H2, + TAG_ID.H3, + TAG_ID.H4, + TAG_ID.H5, + TAG_ID.H6, + TAG_ID.HEAD, + TAG_ID.HR, + TAG_ID.I, + TAG_ID.IMG, + TAG_ID.LI, + TAG_ID.LISTING, + TAG_ID.MENU, + TAG_ID.META, + TAG_ID.NOBR, + TAG_ID.OL, + TAG_ID.P, + TAG_ID.PRE, + TAG_ID.RUBY, + TAG_ID.S, + TAG_ID.SMALL, + TAG_ID.SPAN, + TAG_ID.STRONG, + TAG_ID.STRIKE, + TAG_ID.SUB, + TAG_ID.SUP, + TAG_ID.TABLE, + TAG_ID.TT, + TAG_ID.U, + TAG_ID.UL, + TAG_ID.VAR, +]); +//Check exit from foreign content +function causesExit(startTagToken) { + const tn = startTagToken.tagID; + const isFontWithAttrs = tn === TAG_ID.FONT && + startTagToken.attrs.some(({ name }) => name === html_ATTRS.COLOR || name === html_ATTRS.SIZE || name === html_ATTRS.FACE); + return isFontWithAttrs || EXITS_FOREIGN_CONTENT.has(tn); +} +//Token adjustments +function adjustTokenMathMLAttrs(token) { + for (let i = 0; i < token.attrs.length; i++) { + if (token.attrs[i].name === DEFINITION_URL_ATTR) { + token.attrs[i].name = ADJUSTED_DEFINITION_URL_ATTR; + break; + } + } +} +function adjustTokenSVGAttrs(token) { + for (let i = 0; i < token.attrs.length; i++) { + const adjustedAttrName = SVG_ATTRS_ADJUSTMENT_MAP.get(token.attrs[i].name); + if (adjustedAttrName != null) { + token.attrs[i].name = adjustedAttrName; + } + } +} +function adjustTokenXMLAttrs(token) { + for (let i = 0; i < token.attrs.length; i++) { + const adjustedAttrEntry = XML_ATTRS_ADJUSTMENT_MAP.get(token.attrs[i].name); + if (adjustedAttrEntry) { + token.attrs[i].prefix = adjustedAttrEntry.prefix; + token.attrs[i].name = adjustedAttrEntry.name; + token.attrs[i].namespace = adjustedAttrEntry.namespace; + } + } +} +function adjustTokenSVGTagName(token) { + const adjustedTagName = SVG_TAG_NAMES_ADJUSTMENT_MAP.get(token.tagName); + if (adjustedTagName != null) { + token.tagName = adjustedTagName; + token.tagID = html_getTagID(token.tagName); + } +} +//Integration points +function isMathMLTextIntegrationPoint(tn, ns) { + return ns === html_NS.MATHML && (tn === TAG_ID.MI || tn === TAG_ID.MO || tn === TAG_ID.MN || tn === TAG_ID.MS || tn === TAG_ID.MTEXT); +} +function isHtmlIntegrationPoint(tn, ns, attrs) { + if (ns === html_NS.MATHML && tn === TAG_ID.ANNOTATION_XML) { + for (let i = 0; i < attrs.length; i++) { + if (attrs[i].name === html_ATTRS.ENCODING) { + const value = attrs[i].value.toLowerCase(); + return value === MIME_TYPES.TEXT_HTML || value === MIME_TYPES.APPLICATION_XML; + } + } + } + return ns === html_NS.SVG && (tn === TAG_ID.FOREIGN_OBJECT || tn === TAG_ID.DESC || tn === TAG_ID.TITLE); +} +function isIntegrationPoint(tn, ns, attrs, foreignNS) { + return (((!foreignNS || foreignNS === html_NS.HTML) && isHtmlIntegrationPoint(tn, ns, attrs)) || + ((!foreignNS || foreignNS === html_NS.MATHML) && isMathMLTextIntegrationPoint(tn, ns))); +} +//# sourceMappingURL=foreign-content.js.map +;// CONCATENATED MODULE: ./node_modules/parse5/dist/parser/index.js + + + + + + + + + + +//Misc constants +const HIDDEN_INPUT_TYPE = 'hidden'; +//Adoption agency loops iteration count +const AA_OUTER_LOOP_ITER = 8; +const AA_INNER_LOOP_ITER = 3; +//Insertion modes +var InsertionMode; +(function (InsertionMode) { + InsertionMode[InsertionMode["INITIAL"] = 0] = "INITIAL"; + InsertionMode[InsertionMode["BEFORE_HTML"] = 1] = "BEFORE_HTML"; + InsertionMode[InsertionMode["BEFORE_HEAD"] = 2] = "BEFORE_HEAD"; + InsertionMode[InsertionMode["IN_HEAD"] = 3] = "IN_HEAD"; + InsertionMode[InsertionMode["IN_HEAD_NO_SCRIPT"] = 4] = "IN_HEAD_NO_SCRIPT"; + InsertionMode[InsertionMode["AFTER_HEAD"] = 5] = "AFTER_HEAD"; + InsertionMode[InsertionMode["IN_BODY"] = 6] = "IN_BODY"; + InsertionMode[InsertionMode["TEXT"] = 7] = "TEXT"; + InsertionMode[InsertionMode["IN_TABLE"] = 8] = "IN_TABLE"; + InsertionMode[InsertionMode["IN_TABLE_TEXT"] = 9] = "IN_TABLE_TEXT"; + InsertionMode[InsertionMode["IN_CAPTION"] = 10] = "IN_CAPTION"; + InsertionMode[InsertionMode["IN_COLUMN_GROUP"] = 11] = "IN_COLUMN_GROUP"; + InsertionMode[InsertionMode["IN_TABLE_BODY"] = 12] = "IN_TABLE_BODY"; + InsertionMode[InsertionMode["IN_ROW"] = 13] = "IN_ROW"; + InsertionMode[InsertionMode["IN_CELL"] = 14] = "IN_CELL"; + InsertionMode[InsertionMode["IN_SELECT"] = 15] = "IN_SELECT"; + InsertionMode[InsertionMode["IN_SELECT_IN_TABLE"] = 16] = "IN_SELECT_IN_TABLE"; + InsertionMode[InsertionMode["IN_TEMPLATE"] = 17] = "IN_TEMPLATE"; + InsertionMode[InsertionMode["AFTER_BODY"] = 18] = "AFTER_BODY"; + InsertionMode[InsertionMode["IN_FRAMESET"] = 19] = "IN_FRAMESET"; + InsertionMode[InsertionMode["AFTER_FRAMESET"] = 20] = "AFTER_FRAMESET"; + InsertionMode[InsertionMode["AFTER_AFTER_BODY"] = 21] = "AFTER_AFTER_BODY"; + InsertionMode[InsertionMode["AFTER_AFTER_FRAMESET"] = 22] = "AFTER_AFTER_FRAMESET"; +})(InsertionMode || (InsertionMode = {})); +const BASE_LOC = { + startLine: -1, + startCol: -1, + startOffset: -1, + endLine: -1, + endCol: -1, + endOffset: -1, +}; +const TABLE_STRUCTURE_TAGS = new Set([TAG_ID.TABLE, TAG_ID.TBODY, TAG_ID.TFOOT, TAG_ID.THEAD, TAG_ID.TR]); +const defaultParserOptions = { + scriptingEnabled: true, + sourceCodeLocationInfo: false, + treeAdapter: defaultTreeAdapter, + onParseError: null, +}; +//Parser +class parser_Parser { + constructor(options, document, fragmentContext = null, scriptHandler = null) { + this.fragmentContext = fragmentContext; + this.scriptHandler = scriptHandler; + this.currentToken = null; + this.stopped = false; + this.insertionMode = InsertionMode.INITIAL; + this.originalInsertionMode = InsertionMode.INITIAL; + this.headElement = null; + this.formElement = null; + /** Indicates that the current node is not an element in the HTML namespace */ + this.currentNotInHTML = false; + /** + * The template insertion mode stack is maintained from the left. + * Ie. the topmost element will always have index 0. + */ + this.tmplInsertionModeStack = []; + this.pendingCharacterTokens = []; + this.hasNonWhitespacePendingCharacterToken = false; + this.framesetOk = true; + this.skipNextNewLine = false; + this.fosterParentingEnabled = false; + this.options = { + ...defaultParserOptions, + ...options, + }; + this.treeAdapter = this.options.treeAdapter; + this.onParseError = this.options.onParseError; + // Always enable location info if we report parse errors. + if (this.onParseError) { + this.options.sourceCodeLocationInfo = true; + } + this.document = document !== null && document !== void 0 ? document : this.treeAdapter.createDocument(); + this.tokenizer = new Tokenizer(this.options, this); + this.activeFormattingElements = new FormattingElementList(this.treeAdapter); + this.fragmentContextID = fragmentContext ? getTagID(this.treeAdapter.getTagName(fragmentContext)) : $.UNKNOWN; + this._setContextModes(fragmentContext !== null && fragmentContext !== void 0 ? fragmentContext : this.document, this.fragmentContextID); + this.openElements = new OpenElementStack(this.document, this.treeAdapter, this); + } + // API + static parse(html, options) { + const parser = new this(options); + parser.tokenizer.write(html, true); + return parser.document; + } + static getFragmentParser(fragmentContext, options) { + const opts = { + ...defaultParserOptions, + ...options, + }; + //NOTE: use a